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 5*2caf0dcdSrshoaib * Common Development and Distribution License (the "License"). 6*2caf0dcdSrshoaib * 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 */ 21*2caf0dcdSrshoaib 227c478bd9Sstevel@tonic-gate /* 23*2caf0dcdSrshoaib * Copyright 2006 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> 497c478bd9Sstevel@tonic-gate #include <sys/esunddi.h> 507c478bd9Sstevel@tonic-gate #include <sys/flock.h> 517c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 527c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 537c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate #include <sys/socket.h> 567c478bd9Sstevel@tonic-gate #include <sys/socketvar.h> 577c478bd9Sstevel@tonic-gate #include <netinet/in.h> 587c478bd9Sstevel@tonic-gate #include <sys/sendfile.h> 597c478bd9Sstevel@tonic-gate #include <sys/un.h> 607c478bd9Sstevel@tonic-gate #include <sys/tihdr.h> 617c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate #include <inet/common.h> 647c478bd9Sstevel@tonic-gate #include <inet/ip.h> 657c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 667c478bd9Sstevel@tonic-gate #include <inet/tcp.h> 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate extern int sosendfile64(file_t *, file_t *, const struct ksendfilevec64 *, 697c478bd9Sstevel@tonic-gate ssize32_t *); 707c478bd9Sstevel@tonic-gate extern void nl7c_sendfilev(struct sonode *, u_offset_t, struct sendfilevec *, 717c478bd9Sstevel@tonic-gate int); 727c478bd9Sstevel@tonic-gate 73ff550d0eSmasputra /* 74ff550d0eSmasputra * kstrwritemp() has very similar semantics as that of strwrite(). 75ff550d0eSmasputra * The main difference is it obtains mblks from the caller and also 76ff550d0eSmasputra * does not do any copy as done in strwrite() from user buffers to 77ff550d0eSmasputra * kernel buffers. 78ff550d0eSmasputra * 79ff550d0eSmasputra * Currently, this routine is used by sendfile to send data allocated 80ff550d0eSmasputra * within the kernel without any copying. This interface does not use the 81ff550d0eSmasputra * synchronous stream interface as synch. stream interface implies 82ff550d0eSmasputra * copying. 83ff550d0eSmasputra */ 84ff550d0eSmasputra int 85ff550d0eSmasputra kstrwritemp(struct vnode *vp, mblk_t *mp, ushort_t fmode) 86ff550d0eSmasputra { 87ff550d0eSmasputra struct stdata *stp; 88ff550d0eSmasputra struct queue *wqp; 89c28749e9Skais mblk_t *newmp; 90ff550d0eSmasputra char waitflag; 91ff550d0eSmasputra int tempmode; 92ff550d0eSmasputra int error = 0; 93ff550d0eSmasputra int done = 0; 94ff550d0eSmasputra struct sonode *so; 95ff550d0eSmasputra boolean_t direct; 96ff550d0eSmasputra 97ff550d0eSmasputra ASSERT(vp->v_stream); 98ff550d0eSmasputra stp = vp->v_stream; 99ff550d0eSmasputra 100ff550d0eSmasputra so = VTOSO(vp); 101ff550d0eSmasputra direct = (so->so_state & SS_DIRECT); 102ff550d0eSmasputra 103ff550d0eSmasputra /* 104ff550d0eSmasputra * This is the sockfs direct fast path. canputnext() need 105ff550d0eSmasputra * not be accurate so we don't grab the sd_lock here. If 106ff550d0eSmasputra * we get flow-controlled, we grab sd_lock just before the 107ff550d0eSmasputra * do..while loop below to emulate what strwrite() does. 108ff550d0eSmasputra */ 109ff550d0eSmasputra wqp = stp->sd_wrq; 110ff550d0eSmasputra if (canputnext(wqp) && direct && 111ff550d0eSmasputra !(stp->sd_flag & (STWRERR|STRHUP|STPLEX))) { 112ff550d0eSmasputra return (sostream_direct(so, NULL, mp, CRED())); 113ff550d0eSmasputra } else if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) { 114ff550d0eSmasputra /* Fast check of flags before acquiring the lock */ 115ff550d0eSmasputra mutex_enter(&stp->sd_lock); 116ff550d0eSmasputra error = strgeterr(stp, STWRERR|STRHUP|STPLEX, 0); 117ff550d0eSmasputra mutex_exit(&stp->sd_lock); 118ff550d0eSmasputra if (error != 0) { 119ff550d0eSmasputra if (!(stp->sd_flag & STPLEX) && 120ff550d0eSmasputra (stp->sd_wput_opt & SW_SIGPIPE)) { 121ff550d0eSmasputra tsignal(curthread, SIGPIPE); 122ff550d0eSmasputra error = EPIPE; 123ff550d0eSmasputra } 124ff550d0eSmasputra return (error); 125ff550d0eSmasputra } 126ff550d0eSmasputra } 127ff550d0eSmasputra 128ff550d0eSmasputra waitflag = WRITEWAIT; 129ff550d0eSmasputra if (stp->sd_flag & OLDNDELAY) 130ff550d0eSmasputra tempmode = fmode & ~FNDELAY; 131ff550d0eSmasputra else 132ff550d0eSmasputra tempmode = fmode; 133ff550d0eSmasputra 134ff550d0eSmasputra mutex_enter(&stp->sd_lock); 135ff550d0eSmasputra do { 136ff550d0eSmasputra if (canputnext(wqp)) { 137ff550d0eSmasputra mutex_exit(&stp->sd_lock); 138c28749e9Skais if (stp->sd_wputdatafunc != NULL) { 139c28749e9Skais newmp = (stp->sd_wputdatafunc)(vp, mp, NULL, 140c28749e9Skais NULL, NULL, NULL); 141c28749e9Skais if (newmp == NULL) { 142c28749e9Skais /* The caller will free mp */ 143c28749e9Skais return (ECOMM); 144c28749e9Skais } 145c28749e9Skais mp = newmp; 146c28749e9Skais } 147ff550d0eSmasputra putnext(wqp, mp); 148ff550d0eSmasputra return (0); 149ff550d0eSmasputra } 150ff550d0eSmasputra error = strwaitq(stp, waitflag, (ssize_t)0, tempmode, -1, 151ff550d0eSmasputra &done); 152ff550d0eSmasputra } while (error == 0 && !done); 153ff550d0eSmasputra 154ff550d0eSmasputra mutex_exit(&stp->sd_lock); 155ff550d0eSmasputra /* 156ff550d0eSmasputra * EAGAIN tells the application to try again. ENOMEM 157ff550d0eSmasputra * is returned only if the memory allocation size 158ff550d0eSmasputra * exceeds the physical limits of the system. ENOMEM 159ff550d0eSmasputra * can't be true here. 160ff550d0eSmasputra */ 161ff550d0eSmasputra if (error == ENOMEM) 162ff550d0eSmasputra error = EAGAIN; 163ff550d0eSmasputra return (error); 164ff550d0eSmasputra } 165ff550d0eSmasputra 1667c478bd9Sstevel@tonic-gate #define SEND_MAX_CHUNK 16 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 1697c478bd9Sstevel@tonic-gate /* 1707c478bd9Sstevel@tonic-gate * 64 bit offsets for 32 bit applications only running either on 1717c478bd9Sstevel@tonic-gate * 64 bit kernel or 32 bit kernel. For 32 bit apps, we can't transfer 1727c478bd9Sstevel@tonic-gate * more than 2GB of data. 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate int 1757c478bd9Sstevel@tonic-gate sendvec_chunk64(file_t *fp, u_offset_t *fileoff, struct ksendfilevec64 *sfv, 1767c478bd9Sstevel@tonic-gate int copy_cnt, ssize32_t *count) 1777c478bd9Sstevel@tonic-gate { 1787c478bd9Sstevel@tonic-gate struct vnode *vp; 1797c478bd9Sstevel@tonic-gate ushort_t fflag; 1807c478bd9Sstevel@tonic-gate int ioflag; 1817c478bd9Sstevel@tonic-gate size32_t cnt; 1827c478bd9Sstevel@tonic-gate ssize32_t sfv_len; 1837c478bd9Sstevel@tonic-gate ssize32_t tmpcount; 1847c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 1857c478bd9Sstevel@tonic-gate struct uio auio; 1867c478bd9Sstevel@tonic-gate struct iovec aiov; 1877c478bd9Sstevel@tonic-gate int i, error; 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 1907c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 1917c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 1947c478bd9Sstevel@tonic-gate return (EINTR); 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate /* 1977c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 1987c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 1997c478bd9Sstevel@tonic-gate */ 2007c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)sfv->sfv_len; 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate if (sfv_len == 0) 2037c478bd9Sstevel@tonic-gate continue; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate if (sfv_len < 0) 2067c478bd9Sstevel@tonic-gate return (EINVAL); 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 2097c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 2107c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 2117c478bd9Sstevel@tonic-gate (void) rctl_action( 2127c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 2137c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 2147c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 2157c478bd9Sstevel@tonic-gate return (EFBIG); 2167c478bd9Sstevel@tonic-gate } 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate if (*fileoff >= OFFSET_MAX(fp)) 2197c478bd9Sstevel@tonic-gate return (EFBIG); 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > OFFSET_MAX(fp)) 2227c478bd9Sstevel@tonic-gate return (EINVAL); 2237c478bd9Sstevel@tonic-gate } 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate tmpcount = *count + sfv_len; 2267c478bd9Sstevel@tonic-gate if (tmpcount < 0) 2277c478bd9Sstevel@tonic-gate return (EINVAL); 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate sfv_off = sfv->sfv_off; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 2327c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 2337c478bd9Sstevel@tonic-gate aiov.iov_len = sfv_len; 2347c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 2357c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 2367c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 2377c478bd9Sstevel@tonic-gate auio.uio_resid = sfv_len; 2387c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 2397c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 2407c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 2417c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 2427c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & (FAPPEND|FSYNC|FDSYNC|FRSYNC); 2437c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 2447c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 2457c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 2467c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 2477c478bd9Sstevel@tonic-gate sfv_len -= cnt; 2487c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 2497c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 2507c478bd9Sstevel@tonic-gate *fileoff += cnt; 2517c478bd9Sstevel@tonic-gate *count += cnt; 2527c478bd9Sstevel@tonic-gate if (error != 0) 2537c478bd9Sstevel@tonic-gate return (error); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate } else { 2567c478bd9Sstevel@tonic-gate file_t *ffp; 2577c478bd9Sstevel@tonic-gate vnode_t *readvp; 2587c478bd9Sstevel@tonic-gate int readflg = 0; 2597c478bd9Sstevel@tonic-gate size_t size; 2607c478bd9Sstevel@tonic-gate caddr_t ptr; 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 2637c478bd9Sstevel@tonic-gate return (EBADF); 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 2667c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2677c478bd9Sstevel@tonic-gate return (EBADF); 2687c478bd9Sstevel@tonic-gate } 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 2717c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 2727c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2737c478bd9Sstevel@tonic-gate return (EINVAL); 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate /* 2777c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 2787c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 2797c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 2807c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 2817c478bd9Sstevel@tonic-gate */ 2827c478bd9Sstevel@tonic-gate if (VN_CMP(vp, readvp)) { 2837c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2847c478bd9Sstevel@tonic-gate return (EINVAL); 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 2897c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 2907c478bd9Sstevel@tonic-gate */ 2917c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate /* 2947c478bd9Sstevel@tonic-gate * Same checks as in pread64. 2957c478bd9Sstevel@tonic-gate */ 2967c478bd9Sstevel@tonic-gate if (sfv_off > MAXOFFSET_T) { 2977c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 2987c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2997c478bd9Sstevel@tonic-gate return (EINVAL); 3007c478bd9Sstevel@tonic-gate } 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > MAXOFFSET_T) 3037c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)(MAXOFFSET_T - sfv_off); 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 3067c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 3077c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 3087c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 3097c478bd9Sstevel@tonic-gate ptr = kmem_alloc(size, KM_SLEEP); 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 3127c478bd9Sstevel@tonic-gate size_t iov_len; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 3157c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 3167c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 3177c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 3187c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 3197c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 3207c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 3217c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 3227c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 3237c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 3247c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 3257c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate /* 3287c478bd9Sstevel@tonic-gate * If read sync is not asked for, 3297c478bd9Sstevel@tonic-gate * filter sync flags 3307c478bd9Sstevel@tonic-gate */ 3317c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 3327c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 3337c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 3347c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 3357c478bd9Sstevel@tonic-gate if (error) { 3367c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3377c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3387c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3397c478bd9Sstevel@tonic-gate return (error); 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate /* 3437c478bd9Sstevel@tonic-gate * Check how must data was really read. 3447c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 3457c478bd9Sstevel@tonic-gate * 'off' appropriately. 3467c478bd9Sstevel@tonic-gate */ 3477c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 3487c478bd9Sstevel@tonic-gate if (cnt == 0) { 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 3517c478bd9Sstevel@tonic-gate * not implemented), we may now lose 3527c478bd9Sstevel@tonic-gate * data. 3537c478bd9Sstevel@tonic-gate */ 3547c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3557c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3567c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3577c478bd9Sstevel@tonic-gate return (EINVAL); 3587c478bd9Sstevel@tonic-gate } 3597c478bd9Sstevel@tonic-gate sfv_len -= cnt; 3607c478bd9Sstevel@tonic-gate sfv_off += cnt; 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 3637c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 3647c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 3657c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 3667c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 3677c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 3687c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 3697c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 3707c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 3717c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 3727c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate /* 3757c478bd9Sstevel@tonic-gate * Check how much data was written. Increment 3767c478bd9Sstevel@tonic-gate * the 'len' and decrement the 'off' if all 3777c478bd9Sstevel@tonic-gate * the data was not written. 3787c478bd9Sstevel@tonic-gate */ 3797c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 3807c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 3817c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 3827c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 3837c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 3847c478bd9Sstevel@tonic-gate *fileoff += cnt; 3857c478bd9Sstevel@tonic-gate *count += cnt; 3867c478bd9Sstevel@tonic-gate if (error != 0) { 3877c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3887c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3897c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3907c478bd9Sstevel@tonic-gate return (error); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3947c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3957c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate sfv++; 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate return (0); 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate ssize32_t 4037c478bd9Sstevel@tonic-gate sendvec64(file_t *fp, const struct ksendfilevec64 *vec, int sfvcnt, 4047c478bd9Sstevel@tonic-gate size32_t *xferred, int fildes) 4057c478bd9Sstevel@tonic-gate { 4067c478bd9Sstevel@tonic-gate int rwflag; 4077c478bd9Sstevel@tonic-gate u_offset_t fileoff; 4087c478bd9Sstevel@tonic-gate int copy_cnt; 4097c478bd9Sstevel@tonic-gate const struct ksendfilevec64 *copy_vec; 4107c478bd9Sstevel@tonic-gate struct ksendfilevec64 sfv[SEND_MAX_CHUNK]; 4117c478bd9Sstevel@tonic-gate struct vnode *vp; 4127c478bd9Sstevel@tonic-gate int error; 4137c478bd9Sstevel@tonic-gate ssize32_t count = 0; 4147c478bd9Sstevel@tonic-gate int osfvcnt; 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate rwflag = 1; 4177c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 4187c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(vp, rwflag, NULL); 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate copy_vec = vec; 4217c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 4227c478bd9Sstevel@tonic-gate osfvcnt = sfvcnt; 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate do { 4257c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 4267c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, copy_cnt * 4277c478bd9Sstevel@tonic-gate sizeof (struct ksendfilevec64))) { 4287c478bd9Sstevel@tonic-gate error = EFAULT; 4297c478bd9Sstevel@tonic-gate break; 4307c478bd9Sstevel@tonic-gate } 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate /* 4337c478bd9Sstevel@tonic-gate * Optimize the single regular file over 4347c478bd9Sstevel@tonic-gate * the socket case. 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK && osfvcnt == 1 && 4377c478bd9Sstevel@tonic-gate sfv->sfv_fd != SFV_FD_SELF) { 4387c478bd9Sstevel@tonic-gate file_t *rfp; 4397c478bd9Sstevel@tonic-gate vnode_t *rvp; 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if ((rfp = getf(sfv->sfv_fd)) == NULL) { 4427c478bd9Sstevel@tonic-gate error = EBADF; 4437c478bd9Sstevel@tonic-gate break; 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate if ((rfp->f_flag & FREAD) == 0) { 4467c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4477c478bd9Sstevel@tonic-gate error = EBADF; 4487c478bd9Sstevel@tonic-gate break; 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate rvp = rfp->f_vnode; 4517c478bd9Sstevel@tonic-gate if (rvp->v_type == VREG) { 4527c478bd9Sstevel@tonic-gate error = sosendfile64(fp, rfp, sfv, &count); 4537c478bd9Sstevel@tonic-gate break; 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate error = sendvec_chunk64(fp, &fileoff, sfv, copy_cnt, &count); 4587c478bd9Sstevel@tonic-gate if (error != 0) 4597c478bd9Sstevel@tonic-gate break; 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 4627c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 4637c478bd9Sstevel@tonic-gate } while (sfvcnt > 0); 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 4667c478bd9Sstevel@tonic-gate fp->f_offset += count; 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(vp, rwflag, NULL); 4697c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 4707c478bd9Sstevel@tonic-gate error = EFAULT; 4717c478bd9Sstevel@tonic-gate releasef(fildes); 4727c478bd9Sstevel@tonic-gate if (error != 0) 4737c478bd9Sstevel@tonic-gate return (set_errno(error)); 4747c478bd9Sstevel@tonic-gate return (count); 4757c478bd9Sstevel@tonic-gate } 4767c478bd9Sstevel@tonic-gate #endif 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate int 4797c478bd9Sstevel@tonic-gate sendvec_small_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 4807c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t total_size, int maxblk, ssize_t *count) 4817c478bd9Sstevel@tonic-gate { 4827c478bd9Sstevel@tonic-gate struct vnode *vp; 4837c478bd9Sstevel@tonic-gate struct uio auio; 4847c478bd9Sstevel@tonic-gate struct iovec aiov; 4857c478bd9Sstevel@tonic-gate ushort_t fflag; 4867c478bd9Sstevel@tonic-gate int ioflag; 4877c478bd9Sstevel@tonic-gate int i, error; 4887c478bd9Sstevel@tonic-gate size_t cnt; 4897c478bd9Sstevel@tonic-gate ssize_t sfv_len; 4907c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 4917c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4927c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 4937c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 4947c478bd9Sstevel@tonic-gate MAXOFF32_T : MAXOFFSET_T; 4957c478bd9Sstevel@tonic-gate #else 4967c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 4977c478bd9Sstevel@tonic-gate #endif 4987c478bd9Sstevel@tonic-gate mblk_t *dmp = NULL; 4997c478bd9Sstevel@tonic-gate int wroff; 5007c478bd9Sstevel@tonic-gate int buf_left = 0; 5017c478bd9Sstevel@tonic-gate size_t iov_len; 5027c478bd9Sstevel@tonic-gate mblk_t *head, *tmp; 5037c478bd9Sstevel@tonic-gate size_t size = total_size; 504c28749e9Skais size_t extra; 505c28749e9Skais int tail_len; 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 5087c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VSOCK); 5117c478bd9Sstevel@tonic-gate ASSERT(maxblk > 0); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate wroff = (int)vp->v_stream->sd_wroff; 514c28749e9Skais tail_len = (int)vp->v_stream->sd_tail; 515c28749e9Skais extra = wroff + tail_len; 516c28749e9Skais 5177c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 518c28749e9Skais head = dmp = allocb(buf_left + extra, BPRI_HI); 5197c478bd9Sstevel@tonic-gate if (head == NULL) 5207c478bd9Sstevel@tonic-gate return (ENOMEM); 5217c478bd9Sstevel@tonic-gate head->b_wptr = head->b_rptr = head->b_rptr + wroff; 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 5247c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 5257c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 5267c478bd9Sstevel@tonic-gate return (EINTR); 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate /* 5297c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 5307c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 5317c478bd9Sstevel@tonic-gate */ 5327c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 5357c478bd9Sstevel@tonic-gate sfv++; 5367c478bd9Sstevel@tonic-gate continue; 5377c478bd9Sstevel@tonic-gate } 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate /* Make sure sfv_len is not negative */ 5407c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5417c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 5427c478bd9Sstevel@tonic-gate if ((ssize32_t)sfv_len < 0) 5437c478bd9Sstevel@tonic-gate return (EINVAL); 5447c478bd9Sstevel@tonic-gate } else 5457c478bd9Sstevel@tonic-gate #endif 5467c478bd9Sstevel@tonic-gate if (sfv_len < 0) 5477c478bd9Sstevel@tonic-gate return (EINVAL); 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate /* Check for overflow */ 5507c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5517c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 5527c478bd9Sstevel@tonic-gate if (((ssize32_t)(*count + sfv_len)) < 0) 5537c478bd9Sstevel@tonic-gate return (EINVAL); 5547c478bd9Sstevel@tonic-gate } else 5557c478bd9Sstevel@tonic-gate #endif 5567c478bd9Sstevel@tonic-gate if ((*count + sfv_len) < 0) 5577c478bd9Sstevel@tonic-gate return (EINVAL); 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 5627c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 5637c478bd9Sstevel@tonic-gate if (buf_left == 0) { 5647c478bd9Sstevel@tonic-gate tmp = dmp; 5657c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 5667c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 567c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 5687c478bd9Sstevel@tonic-gate if (dmp == NULL) { 5697c478bd9Sstevel@tonic-gate freemsg(head); 5707c478bd9Sstevel@tonic-gate return (ENOMEM); 5717c478bd9Sstevel@tonic-gate } 5727c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 5737c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 5747c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 5757c478bd9Sstevel@tonic-gate } else { 5767c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 5807c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 5817c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 5827c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 5837c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 5847c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 5857c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 5867c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 5877c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate buf_left -= iov_len; 5907c478bd9Sstevel@tonic-gate total_size -= iov_len; 5917c478bd9Sstevel@tonic-gate sfv_len -= iov_len; 5927c478bd9Sstevel@tonic-gate sfv_off += iov_len; 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate error = uiomove((caddr_t)dmp->b_wptr, 5957c478bd9Sstevel@tonic-gate iov_len, UIO_WRITE, &auio); 5967c478bd9Sstevel@tonic-gate if (error != 0) { 5977c478bd9Sstevel@tonic-gate freemsg(head); 5987c478bd9Sstevel@tonic-gate return (error); 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate dmp->b_wptr += iov_len; 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate } else { 6037c478bd9Sstevel@tonic-gate file_t *ffp; 6047c478bd9Sstevel@tonic-gate vnode_t *readvp; 6057c478bd9Sstevel@tonic-gate int readflg = 0; 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) { 6087c478bd9Sstevel@tonic-gate freemsg(head); 6097c478bd9Sstevel@tonic-gate return (EBADF); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 6137c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6147c478bd9Sstevel@tonic-gate freemsg(head); 6157c478bd9Sstevel@tonic-gate return (EACCES); 6167c478bd9Sstevel@tonic-gate } 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 6197c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 6207c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6217c478bd9Sstevel@tonic-gate freemsg(head); 6227c478bd9Sstevel@tonic-gate return (EINVAL); 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate /* 6267c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 6277c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 6287c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 6297c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 6307c478bd9Sstevel@tonic-gate */ 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate if (VN_CMP(vp, readvp)) { 6337c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6347c478bd9Sstevel@tonic-gate freemsg(head); 6357c478bd9Sstevel@tonic-gate return (EINVAL); 6367c478bd9Sstevel@tonic-gate } 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate /* 6397c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 6407c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 6417c478bd9Sstevel@tonic-gate */ 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 6467c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 6477c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 6487c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6497c478bd9Sstevel@tonic-gate freemsg(head); 6507c478bd9Sstevel@tonic-gate return (EINVAL); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 6537c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 6547c478bd9Sstevel@tonic-gate sfv_off); 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 6587c478bd9Sstevel@tonic-gate if (buf_left == 0) { 6597c478bd9Sstevel@tonic-gate tmp = dmp; 6607c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 6617c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 662c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 6637c478bd9Sstevel@tonic-gate if (dmp == NULL) { 6647c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 6657c478bd9Sstevel@tonic-gate NULL); 6667c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6677c478bd9Sstevel@tonic-gate freemsg(head); 6687c478bd9Sstevel@tonic-gate return (ENOMEM); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 6717c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 6727c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 6737c478bd9Sstevel@tonic-gate } else { 6747c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)dmp->b_wptr; 6777c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 6787c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 6797c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 6807c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 6817c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 6827c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 6837c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 6847c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 6857c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 6867c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate /* 6897c478bd9Sstevel@tonic-gate * If read sync is not asked for, 6907c478bd9Sstevel@tonic-gate * filter sync flags 6917c478bd9Sstevel@tonic-gate */ 6927c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 6937c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 6947c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 6957c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 6967c478bd9Sstevel@tonic-gate if (error != 0) { 6977c478bd9Sstevel@tonic-gate /* 6987c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 6997c478bd9Sstevel@tonic-gate * not implemented), we may now loose 7007c478bd9Sstevel@tonic-gate * data. 7017c478bd9Sstevel@tonic-gate */ 7027c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7037c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7047c478bd9Sstevel@tonic-gate freemsg(head); 7057c478bd9Sstevel@tonic-gate return (error); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate /* 7097c478bd9Sstevel@tonic-gate * Check how much data was really read. 7107c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 7117c478bd9Sstevel@tonic-gate * 'off' appropriately. 7127c478bd9Sstevel@tonic-gate */ 7137c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 7147c478bd9Sstevel@tonic-gate if (cnt == 0) { 7157c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7167c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7177c478bd9Sstevel@tonic-gate freemsg(head); 7187c478bd9Sstevel@tonic-gate return (EINVAL); 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate sfv_len -= cnt; 7217c478bd9Sstevel@tonic-gate sfv_off += cnt; 7227c478bd9Sstevel@tonic-gate total_size -= cnt; 7237c478bd9Sstevel@tonic-gate buf_left -= cnt; 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate dmp->b_wptr += cnt; 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7287c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate sfv++; 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate ASSERT(total_size == 0); 7347c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, head, fflag); 7357c478bd9Sstevel@tonic-gate if (error != 0) { 7367c478bd9Sstevel@tonic-gate freemsg(head); 7377c478bd9Sstevel@tonic-gate return (error); 7387c478bd9Sstevel@tonic-gate } 7397c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)size; 7407c478bd9Sstevel@tonic-gate *count += size; 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate return (0); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate int 7477c478bd9Sstevel@tonic-gate sendvec_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 7487c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t *count) 7497c478bd9Sstevel@tonic-gate { 7507c478bd9Sstevel@tonic-gate struct vnode *vp; 7517c478bd9Sstevel@tonic-gate struct uio auio; 7527c478bd9Sstevel@tonic-gate struct iovec aiov; 7537c478bd9Sstevel@tonic-gate ushort_t fflag; 7547c478bd9Sstevel@tonic-gate int ioflag; 7557c478bd9Sstevel@tonic-gate int i, error; 7567c478bd9Sstevel@tonic-gate size_t cnt; 7577c478bd9Sstevel@tonic-gate ssize_t sfv_len; 7587c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 7597c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 7607c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 7617c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 7627c478bd9Sstevel@tonic-gate MAXOFF32_T : MAXOFFSET_T; 7637c478bd9Sstevel@tonic-gate #else 7647c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 7657c478bd9Sstevel@tonic-gate #endif 7661574ae68Sjohansen mblk_t *dmp = NULL; 7671574ae68Sjohansen char *buf = NULL; 768c28749e9Skais size_t extra; 769c28749e9Skais int maxblk, wroff, tail_len; 770c28749e9Skais struct sonode *so; 771c28749e9Skais stdata_t *stp; 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 7747c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 7757c478bd9Sstevel@tonic-gate 776c28749e9Skais if (vp->v_type == VSOCK) { 777c28749e9Skais so = VTOSO(vp); 778c28749e9Skais stp = vp->v_stream; 779c28749e9Skais wroff = (int)stp->sd_wroff; 780c28749e9Skais tail_len = (int)stp->sd_tail; 781c28749e9Skais maxblk = (int)stp->sd_maxblk; 782c28749e9Skais extra = wroff + tail_len; 783c28749e9Skais } 784c28749e9Skais 7857c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 7867c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 7877c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 7887c478bd9Sstevel@tonic-gate return (EINTR); 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /* 7917c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 7927c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 7937c478bd9Sstevel@tonic-gate */ 7947c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 7977c478bd9Sstevel@tonic-gate sfv++; 7987c478bd9Sstevel@tonic-gate continue; 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* Make sure sfv_len is not negative */ 8027c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 8037c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 8047c478bd9Sstevel@tonic-gate if ((ssize32_t)sfv_len < 0) 8057c478bd9Sstevel@tonic-gate return (EINVAL); 8067c478bd9Sstevel@tonic-gate } else 8077c478bd9Sstevel@tonic-gate #endif 8087c478bd9Sstevel@tonic-gate if (sfv_len < 0) 8097c478bd9Sstevel@tonic-gate return (EINVAL); 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 8127c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 8137c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 8147c478bd9Sstevel@tonic-gate (void) rctl_action( 8157c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 8167c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 8177c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate return (EFBIG); 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate if (*fileoff >= maxoff) 8237c478bd9Sstevel@tonic-gate return (EFBIG); 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > maxoff) 8267c478bd9Sstevel@tonic-gate return (EINVAL); 8277c478bd9Sstevel@tonic-gate } 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate /* Check for overflow */ 8307c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 8317c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 8327c478bd9Sstevel@tonic-gate if (((ssize32_t)(*count + sfv_len)) < 0) 8337c478bd9Sstevel@tonic-gate return (EINVAL); 8347c478bd9Sstevel@tonic-gate } else 8357c478bd9Sstevel@tonic-gate #endif 8367c478bd9Sstevel@tonic-gate if ((*count + sfv_len) < 0) 8377c478bd9Sstevel@tonic-gate return (EINVAL); 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 8427c478bd9Sstevel@tonic-gate aiov.iov_len = sfv_len; 8437c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 8447c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 8457c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 8467c478bd9Sstevel@tonic-gate auio.uio_resid = sfv_len; 8477c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 8487c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 8497c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 8507c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate /* 8557c478bd9Sstevel@tonic-gate * Optimize for the socket case 8567c478bd9Sstevel@tonic-gate */ 8577c478bd9Sstevel@tonic-gate 858c28749e9Skais dmp = allocb(sfv_len + extra, BPRI_HI); 8597c478bd9Sstevel@tonic-gate if (dmp == NULL) 8607c478bd9Sstevel@tonic-gate return (ENOMEM); 8617c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = dmp->b_rptr + wroff; 8627c478bd9Sstevel@tonic-gate error = uiomove((caddr_t)dmp->b_wptr, 8637c478bd9Sstevel@tonic-gate sfv_len, UIO_WRITE, &auio); 8647c478bd9Sstevel@tonic-gate if (error != 0) { 8657c478bd9Sstevel@tonic-gate freeb(dmp); 8667c478bd9Sstevel@tonic-gate return (error); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate dmp->b_wptr += sfv_len; 8697c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, dmp, fflag); 8707c478bd9Sstevel@tonic-gate if (error != 0) { 8717c478bd9Sstevel@tonic-gate freeb(dmp); 8727c478bd9Sstevel@tonic-gate return (error); 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 8757c478bd9Sstevel@tonic-gate (ulong_t)sfv_len; 8767c478bd9Sstevel@tonic-gate *count += sfv_len; 8777c478bd9Sstevel@tonic-gate } else { 8787c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 8797c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 8807c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 8817c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 8827c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 8837c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 8847c478bd9Sstevel@tonic-gate sfv_len -= cnt; 8857c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 8867c478bd9Sstevel@tonic-gate (ulong_t)cnt; 8877c478bd9Sstevel@tonic-gate *fileoff += cnt; 8887c478bd9Sstevel@tonic-gate *count += cnt; 8897c478bd9Sstevel@tonic-gate if (error != 0) 8907c478bd9Sstevel@tonic-gate return (error); 8917c478bd9Sstevel@tonic-gate } 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate } else { 8947c478bd9Sstevel@tonic-gate file_t *ffp; 8957c478bd9Sstevel@tonic-gate vnode_t *readvp; 8967c478bd9Sstevel@tonic-gate int readflg = 0; 8977c478bd9Sstevel@tonic-gate size_t size; 8987c478bd9Sstevel@tonic-gate caddr_t ptr; 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 9017c478bd9Sstevel@tonic-gate return (EBADF); 9027c478bd9Sstevel@tonic-gate 9037c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 9047c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9057c478bd9Sstevel@tonic-gate return (EBADF); 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate 9087c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 9097c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 9107c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9117c478bd9Sstevel@tonic-gate return (EINVAL); 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate /* 9157c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 9167c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 9177c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 9187c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 9197c478bd9Sstevel@tonic-gate */ 9207c478bd9Sstevel@tonic-gate if (VN_CMP(vp, readvp)) { 9217c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9227c478bd9Sstevel@tonic-gate return (EINVAL); 9237c478bd9Sstevel@tonic-gate } 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate /* 9267c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 9277c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 9287c478bd9Sstevel@tonic-gate */ 9297c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 9327c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 9337c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 9347c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9357c478bd9Sstevel@tonic-gate return (EINVAL); 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 9387c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 9397c478bd9Sstevel@tonic-gate sfv_off); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 9427c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 9437c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 9447c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 9457c478bd9Sstevel@tonic-gate 9461574ae68Sjohansen if (vp->v_type != VSOCK) { 9471574ae68Sjohansen buf = kmem_alloc(size, KM_NOSLEEP); 9481574ae68Sjohansen if (buf == NULL) { 9491574ae68Sjohansen VOP_RWUNLOCK(readvp, readflg, NULL); 9501574ae68Sjohansen releasef(sfv->sfv_fd); 9511574ae68Sjohansen return (ENOMEM); 9521574ae68Sjohansen } 953c28749e9Skais } else { 954c28749e9Skais /* 955c28749e9Skais * For sockets acting as an SSL proxy, we 956c28749e9Skais * need to adjust the size to the maximum 957c28749e9Skais * SSL record size set in the stream head. 958c28749e9Skais */ 959c28749e9Skais if (so->so_kssl_ctx != NULL) 960c28749e9Skais size = MIN(size, maxblk); 9611574ae68Sjohansen } 9621574ae68Sjohansen 9637c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 9647c478bd9Sstevel@tonic-gate size_t iov_len; 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 9677c478bd9Sstevel@tonic-gate 9681574ae68Sjohansen if (vp->v_type == VSOCK) { 969c28749e9Skais dmp = allocb(iov_len + extra, BPRI_HI); 9701574ae68Sjohansen if (dmp == NULL) { 9711574ae68Sjohansen VOP_RWUNLOCK(readvp, readflg, 9721574ae68Sjohansen NULL); 9731574ae68Sjohansen releasef(sfv->sfv_fd); 9741574ae68Sjohansen return (ENOMEM); 9751574ae68Sjohansen } 976c28749e9Skais dmp->b_wptr = dmp->b_rptr = 977c28749e9Skais dmp->b_rptr + wroff; 9781574ae68Sjohansen ptr = (caddr_t)dmp->b_rptr; 9791574ae68Sjohansen } else { 9801574ae68Sjohansen ptr = buf; 9817c478bd9Sstevel@tonic-gate } 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 9847c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 9857c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 9867c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 9877c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 9887c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 9897c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 9907c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 9917c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 9927c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 9937c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate /* 9967c478bd9Sstevel@tonic-gate * If read sync is not asked for, 9977c478bd9Sstevel@tonic-gate * filter sync flags 9987c478bd9Sstevel@tonic-gate */ 9997c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 10007c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 10017c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 10027c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 10037c478bd9Sstevel@tonic-gate if (error != 0) { 10047c478bd9Sstevel@tonic-gate /* 10057c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 10067c478bd9Sstevel@tonic-gate * not implemented), we may now lose 10077c478bd9Sstevel@tonic-gate * data. 10087c478bd9Sstevel@tonic-gate */ 10091574ae68Sjohansen if (vp->v_type == VSOCK) 10101574ae68Sjohansen freeb(dmp); 10111574ae68Sjohansen else 10121574ae68Sjohansen kmem_free(buf, size); 10137c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 10147c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10157c478bd9Sstevel@tonic-gate return (error); 10167c478bd9Sstevel@tonic-gate } 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate /* 10197c478bd9Sstevel@tonic-gate * Check how much data was really read. 10207c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 10217c478bd9Sstevel@tonic-gate * 'off' appropriately. 10227c478bd9Sstevel@tonic-gate */ 10237c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 10247c478bd9Sstevel@tonic-gate if (cnt == 0) { 10251574ae68Sjohansen if (vp->v_type == VSOCK) 10261574ae68Sjohansen freeb(dmp); 10271574ae68Sjohansen else 10281574ae68Sjohansen kmem_free(buf, size); 10297c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 10307c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10317c478bd9Sstevel@tonic-gate return (EINVAL); 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate sfv_len -= cnt; 10347c478bd9Sstevel@tonic-gate sfv_off += cnt; 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 10377c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr + cnt; 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, dmp, fflag); 10407c478bd9Sstevel@tonic-gate if (error != 0) { 10417c478bd9Sstevel@tonic-gate freeb(dmp); 10427c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 10437c478bd9Sstevel@tonic-gate NULL); 10447c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10457c478bd9Sstevel@tonic-gate return (error); 10467c478bd9Sstevel@tonic-gate } 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 10497c478bd9Sstevel@tonic-gate (ulong_t)cnt; 10507c478bd9Sstevel@tonic-gate *count += cnt; 10517c478bd9Sstevel@tonic-gate } else { 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 10547c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 10557c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 10567c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 10577c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 10587c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 10597c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 10607c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 10617c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 10627c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 10637c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * Check how much data was written. 10677c478bd9Sstevel@tonic-gate * Increment the 'len' and decrement the 10687c478bd9Sstevel@tonic-gate * 'off' if all the data was not 10697c478bd9Sstevel@tonic-gate * written. 10707c478bd9Sstevel@tonic-gate */ 10717c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 10727c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 10737c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 10747c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 10757c478bd9Sstevel@tonic-gate (ulong_t)cnt; 10767c478bd9Sstevel@tonic-gate *fileoff += cnt; 10777c478bd9Sstevel@tonic-gate *count += cnt; 10787c478bd9Sstevel@tonic-gate if (error != 0) { 10797c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 10807c478bd9Sstevel@tonic-gate NULL); 10817c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10827c478bd9Sstevel@tonic-gate return (error); 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate } 10861574ae68Sjohansen if (buf) { 10871574ae68Sjohansen kmem_free(buf, size); 10881574ae68Sjohansen buf = NULL; 10891574ae68Sjohansen } 10907c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 10917c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10927c478bd9Sstevel@tonic-gate } 10937c478bd9Sstevel@tonic-gate sfv++; 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate return (0); 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate 10987c478bd9Sstevel@tonic-gate ssize_t 10997c478bd9Sstevel@tonic-gate sendfilev(int opcode, int fildes, const struct sendfilevec *vec, int sfvcnt, 11007c478bd9Sstevel@tonic-gate size_t *xferred) 11017c478bd9Sstevel@tonic-gate { 11027c478bd9Sstevel@tonic-gate int error; 11037c478bd9Sstevel@tonic-gate file_t *fp; 11047c478bd9Sstevel@tonic-gate struct vnode *vp; 11057c478bd9Sstevel@tonic-gate struct sonode *so; 11067c478bd9Sstevel@tonic-gate u_offset_t fileoff; 11077c478bd9Sstevel@tonic-gate int copy_cnt; 11087c478bd9Sstevel@tonic-gate const struct sendfilevec *copy_vec; 11097c478bd9Sstevel@tonic-gate struct sendfilevec sfv[SEND_MAX_CHUNK]; 11107c478bd9Sstevel@tonic-gate ssize_t count = 0; 11117c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 11127c478bd9Sstevel@tonic-gate struct ksendfilevec32 sfv32[SEND_MAX_CHUNK]; 11137c478bd9Sstevel@tonic-gate #endif 11147c478bd9Sstevel@tonic-gate ssize_t total_size = 0; 11157c478bd9Sstevel@tonic-gate int i; 11167c478bd9Sstevel@tonic-gate boolean_t is_sock = B_FALSE; 11177c478bd9Sstevel@tonic-gate int maxblk = 0; 11187c478bd9Sstevel@tonic-gate 11197c478bd9Sstevel@tonic-gate if (sfvcnt <= 0) 11207c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate if ((fp = getf(fildes)) == NULL) 11237c478bd9Sstevel@tonic-gate return (set_errno(EBADF)); 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate if (((fp->f_flag) & FWRITE) == 0) { 11267c478bd9Sstevel@tonic-gate error = EBADF; 11277c478bd9Sstevel@tonic-gate goto err; 11287c478bd9Sstevel@tonic-gate } 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 11317c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate switch (vp->v_type) { 11347c478bd9Sstevel@tonic-gate case VSOCK: 11357c478bd9Sstevel@tonic-gate so = VTOSO(vp); 11367c478bd9Sstevel@tonic-gate /* sendfile not supported for SCTP */ 11377c478bd9Sstevel@tonic-gate if (so->so_protocol == IPPROTO_SCTP) { 11387c478bd9Sstevel@tonic-gate error = EPROTONOSUPPORT; 11397c478bd9Sstevel@tonic-gate goto err; 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate is_sock = B_TRUE; 11427c478bd9Sstevel@tonic-gate switch (so->so_family) { 11437c478bd9Sstevel@tonic-gate case AF_INET: 11447c478bd9Sstevel@tonic-gate case AF_INET6: 11457c478bd9Sstevel@tonic-gate /* 11467c478bd9Sstevel@tonic-gate * Make similar checks done in SOP_WRITE(). 11477c478bd9Sstevel@tonic-gate */ 11487c478bd9Sstevel@tonic-gate if (so->so_state & SS_CANTSENDMORE) { 11497c478bd9Sstevel@tonic-gate tsignal(curthread, SIGPIPE); 11507c478bd9Sstevel@tonic-gate error = EPIPE; 11517c478bd9Sstevel@tonic-gate goto err; 11527c478bd9Sstevel@tonic-gate } 11537c478bd9Sstevel@tonic-gate if (so->so_type != SOCK_STREAM) { 11547c478bd9Sstevel@tonic-gate error = EOPNOTSUPP; 11557c478bd9Sstevel@tonic-gate goto err; 11567c478bd9Sstevel@tonic-gate } 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate if ((so->so_state & (SS_ISCONNECTED|SS_ISBOUND)) != 11597c478bd9Sstevel@tonic-gate (SS_ISCONNECTED|SS_ISBOUND)) { 11607c478bd9Sstevel@tonic-gate error = ENOTCONN; 11617c478bd9Sstevel@tonic-gate goto err; 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate 1164ff550d0eSmasputra if ((so->so_state & SS_DIRECT) && 1165c28749e9Skais (so->so_priv != NULL) && 1166c28749e9Skais (so->so_kssl_ctx == NULL)) { 11677c478bd9Sstevel@tonic-gate maxblk = ((tcp_t *)so->so_priv)->tcp_mss; 11687c478bd9Sstevel@tonic-gate } else { 11697c478bd9Sstevel@tonic-gate maxblk = (int)vp->v_stream->sd_maxblk; 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate break; 11727c478bd9Sstevel@tonic-gate default: 11737c478bd9Sstevel@tonic-gate error = EAFNOSUPPORT; 11747c478bd9Sstevel@tonic-gate goto err; 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate break; 11777c478bd9Sstevel@tonic-gate case VREG: 11787c478bd9Sstevel@tonic-gate break; 11797c478bd9Sstevel@tonic-gate default: 11807c478bd9Sstevel@tonic-gate error = EINVAL; 11817c478bd9Sstevel@tonic-gate goto err; 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate switch (opcode) { 11857c478bd9Sstevel@tonic-gate case SENDFILEV : 11867c478bd9Sstevel@tonic-gate break; 11877c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 11887c478bd9Sstevel@tonic-gate case SENDFILEV64 : 11897c478bd9Sstevel@tonic-gate return (sendvec64(fp, (struct ksendfilevec64 *)vec, sfvcnt, 11907c478bd9Sstevel@tonic-gate (size32_t *)xferred, fildes)); 11917c478bd9Sstevel@tonic-gate #endif 11927c478bd9Sstevel@tonic-gate default : 11937c478bd9Sstevel@tonic-gate error = ENOSYS; 11947c478bd9Sstevel@tonic-gate break; 11957c478bd9Sstevel@tonic-gate } 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 11987c478bd9Sstevel@tonic-gate copy_vec = vec; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate do { 12017c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 12027c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12037c478bd9Sstevel@tonic-gate /* 32-bit callers need to have their iovec expanded. */ 12047c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 12057c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv32, 12067c478bd9Sstevel@tonic-gate copy_cnt * sizeof (ksendfilevec32_t))) { 12077c478bd9Sstevel@tonic-gate error = EFAULT; 12087c478bd9Sstevel@tonic-gate break; 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 12127c478bd9Sstevel@tonic-gate sfv[i].sfv_fd = sfv32[i].sfv_fd; 12137c478bd9Sstevel@tonic-gate sfv[i].sfv_off = 12147c478bd9Sstevel@tonic-gate (off_t)(uint32_t)sfv32[i].sfv_off; 12157c478bd9Sstevel@tonic-gate sfv[i].sfv_len = (size_t)sfv32[i].sfv_len; 12167c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 12177c478bd9Sstevel@tonic-gate sfv[i].sfv_flag = sfv32[i].sfv_flag; 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate } else { 12207c478bd9Sstevel@tonic-gate #endif 12217c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, 12227c478bd9Sstevel@tonic-gate copy_cnt * sizeof (sendfilevec_t))) { 12237c478bd9Sstevel@tonic-gate error = EFAULT; 12247c478bd9Sstevel@tonic-gate break; 12257c478bd9Sstevel@tonic-gate } 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 12287c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 12297c478bd9Sstevel@tonic-gate } 12307c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate #endif 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate /* 12357c478bd9Sstevel@tonic-gate * The task between deciding to use sendvec_small_chunk 12367c478bd9Sstevel@tonic-gate * and sendvec_chunk is dependant on multiple things: 12377c478bd9Sstevel@tonic-gate * 12387c478bd9Sstevel@tonic-gate * i) latency is important for smaller files. So if the 12397c478bd9Sstevel@tonic-gate * data is smaller than 'tcp_slow_start_initial' times 12407c478bd9Sstevel@tonic-gate * maxblk, then use sendvec_small_chunk which creates 12417c478bd9Sstevel@tonic-gate * maxblk size mblks and chains then together and sends 12427c478bd9Sstevel@tonic-gate * them to TCP in one shot. It also leaves 'wroff' size 12437c478bd9Sstevel@tonic-gate * space for the headers in each mblk. 12447c478bd9Sstevel@tonic-gate * 12457c478bd9Sstevel@tonic-gate * ii) for total size bigger than 'tcp_slow_start_initial' 12467c478bd9Sstevel@tonic-gate * time maxblk, its probably real file data which is 12477c478bd9Sstevel@tonic-gate * dominating. So its better to use sendvec_chunk because 12487c478bd9Sstevel@tonic-gate * performance goes to dog if we don't do pagesize reads. 12497c478bd9Sstevel@tonic-gate * sendvec_chunk will do pagesize reads and write them 12507c478bd9Sstevel@tonic-gate * in pagesize mblks to TCP. 12517c478bd9Sstevel@tonic-gate * 12527c478bd9Sstevel@tonic-gate * Side Notes: A write to file has not been optimized. 12537c478bd9Sstevel@tonic-gate * Future zero copy code will plugin into sendvec_chunk 12547c478bd9Sstevel@tonic-gate * only because doing zero copy for files smaller then 12557c478bd9Sstevel@tonic-gate * pagesize is useless. 12567c478bd9Sstevel@tonic-gate * 12577c478bd9Sstevel@tonic-gate * Note, if socket has NL7C enabled then call NL7C's 12587c478bd9Sstevel@tonic-gate * senfilev() function to give NL7C a chance to copy 12597c478bd9Sstevel@tonic-gate * the vec for caching, then continue processing as 12607c478bd9Sstevel@tonic-gate * normal. 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate if (is_sock) { 12637c478bd9Sstevel@tonic-gate switch (so->so_family) { 12647c478bd9Sstevel@tonic-gate case AF_INET: 12657c478bd9Sstevel@tonic-gate case AF_INET6: 12667c478bd9Sstevel@tonic-gate if (so->so_nl7c_flags != 0) { 12677c478bd9Sstevel@tonic-gate nl7c_sendfilev(so, fileoff, 12687c478bd9Sstevel@tonic-gate sfv, copy_cnt); 12697c478bd9Sstevel@tonic-gate } 12707c478bd9Sstevel@tonic-gate if (total_size <= (4 * maxblk)) 12717c478bd9Sstevel@tonic-gate error = sendvec_small_chunk(fp, 12727c478bd9Sstevel@tonic-gate &fileoff, sfv, copy_cnt, 12737c478bd9Sstevel@tonic-gate total_size, maxblk, &count); 12747c478bd9Sstevel@tonic-gate else 12757c478bd9Sstevel@tonic-gate error = sendvec_chunk(fp, &fileoff, 12767c478bd9Sstevel@tonic-gate sfv, copy_cnt, &count); 12777c478bd9Sstevel@tonic-gate break; 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate } else { 12807c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VREG); 12817c478bd9Sstevel@tonic-gate error = sendvec_chunk(fp, &fileoff, sfv, copy_cnt, 12827c478bd9Sstevel@tonic-gate &count); 12837c478bd9Sstevel@tonic-gate } 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12877c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) 12887c478bd9Sstevel@tonic-gate copy_vec = (const struct sendfilevec *)((char *)copy_vec + 12897c478bd9Sstevel@tonic-gate (copy_cnt * sizeof (ksendfilevec32_t))); 12907c478bd9Sstevel@tonic-gate else 12917c478bd9Sstevel@tonic-gate #endif 12927c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 12937c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 12947c478bd9Sstevel@tonic-gate } while (sfvcnt > 0); 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 12977c478bd9Sstevel@tonic-gate fp->f_offset += count; 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 13037c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 13047c478bd9Sstevel@tonic-gate ssize32_t count32 = (ssize32_t)count; 13057c478bd9Sstevel@tonic-gate if (copyout(&count32, xferred, sizeof (count32))) 13067c478bd9Sstevel@tonic-gate error = EFAULT; 13077c478bd9Sstevel@tonic-gate releasef(fildes); 13087c478bd9Sstevel@tonic-gate if (error != 0) 13097c478bd9Sstevel@tonic-gate return (set_errno(error)); 13107c478bd9Sstevel@tonic-gate return (count32); 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate #endif 13137c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 13147c478bd9Sstevel@tonic-gate error = EFAULT; 13157c478bd9Sstevel@tonic-gate releasef(fildes); 13167c478bd9Sstevel@tonic-gate if (error != 0) 13177c478bd9Sstevel@tonic-gate return (set_errno(error)); 13187c478bd9Sstevel@tonic-gate return (count); 13197c478bd9Sstevel@tonic-gate err: 13207c478bd9Sstevel@tonic-gate ASSERT(error != 0); 13217c478bd9Sstevel@tonic-gate releasef(fildes); 13227c478bd9Sstevel@tonic-gate return (set_errno(error)); 13237c478bd9Sstevel@tonic-gate } 1324