subr_hash.c revision 138424
11541Srgrimes/* 21541Srgrimes * Copyright (c) 1982, 1986, 1991, 1993 31541Srgrimes * The Regents of the University of California. All rights reserved. 41541Srgrimes * (c) UNIX System Laboratories, Inc. 51541Srgrimes * All or some portions of this file are derived from material licensed 61541Srgrimes * to the University of California by American Telephone and Telegraph 71541Srgrimes * Co. or Unix System Laboratories, Inc. and are reproduced herein with 81541Srgrimes * the permission of UNIX System Laboratories, Inc. 91541Srgrimes * 101541Srgrimes * Redistribution and use in source and binary forms, with or without 111541Srgrimes * modification, are permitted provided that the following conditions 121541Srgrimes * are met: 131541Srgrimes * 1. Redistributions of source code must retain the above copyright 141541Srgrimes * notice, this list of conditions and the following disclaimer. 151541Srgrimes * 2. Redistributions in binary form must reproduce the above copyright 161541Srgrimes * notice, this list of conditions and the following disclaimer in the 171541Srgrimes * documentation and/or other materials provided with the distribution. 181541Srgrimes * 4. Neither the name of the University nor the names of its contributors 191541Srgrimes * may be used to endorse or promote products derived from this software 201541Srgrimes * without specific prior written permission. 211541Srgrimes * 221541Srgrimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 231541Srgrimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 241541Srgrimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 251541Srgrimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 261541Srgrimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 271541Srgrimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 281541Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 291541Srgrimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 301541Srgrimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 311541Srgrimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 321541Srgrimes * SUCH DAMAGE. 331541Srgrimes * 341541Srgrimes * @(#)kern_subr.c 8.3 (Berkeley) 1/21/94 351541Srgrimes */ 361541Srgrimes 37116182Sobrien#include <sys/cdefs.h> 38116182Sobrien__FBSDID("$FreeBSD: head/sys/kern/kern_subr.c 138424 2004-12-06 00:43:40Z alc $"); 39116182Sobrien 4098849Sken#include "opt_zero.h" 4198849Sken 421541Srgrimes#include <sys/param.h> 431541Srgrimes#include <sys/systm.h> 4444218Sbde#include <sys/kernel.h> 4565557Sjasone#include <sys/ktr.h> 46120665Snectar#include <sys/limits.h> 4776166Smarkm#include <sys/lock.h> 4876166Smarkm#include <sys/mutex.h> 491541Srgrimes#include <sys/proc.h> 501541Srgrimes#include <sys/malloc.h> 5143529Sbde#include <sys/resourcevar.h> 52104964Sjeff#include <sys/sched.h> 5378431Swollman#include <sys/sysctl.h> 5432702Sdyson#include <sys/vnode.h> 551541Srgrimes 5631853Sdyson#include <vm/vm.h> 5731853Sdyson#include <vm/vm_page.h> 5831853Sdyson#include <vm/vm_map.h> 5999848Sken#ifdef ZERO_COPY_SOCKETS 6099848Sken#include <vm/vm_param.h> 6199848Sken#include <vm/vm_object.h> 6299848Sken#endif 6331853Sdyson 64111737SdesSYSCTL_INT(_kern, KERN_IOV_MAX, iov_max, CTLFLAG_RD, NULL, UIO_MAXIOV, 6578431Swollman "Maximum number of elements in an I/O vector; sysconf(_SC_IOV_MAX)"); 6678431Swollman 6798849Sken#ifdef ZERO_COPY_SOCKETS 6898849Sken/* Declared in uipc_socket.c */ 6998849Skenextern int so_zero_copy_receive; 7098849Sken 7198849Skenstatic int 72137377Salcvm_pgmoveco(vm_map_t mapa, vm_offset_t kaddr, vm_offset_t uaddr) 7398849Sken{ 7498849Sken vm_map_t map = mapa; 7598849Sken vm_page_t kern_pg, user_pg; 7698849Sken vm_object_t uobject; 7798849Sken vm_map_entry_t entry; 78137244Salc vm_pindex_t upindex; 7998849Sken vm_prot_t prot; 8098849Sken boolean_t wired; 8198849Sken 8298849Sken /* 8398849Sken * First lookup the kernel page. 8498849Sken */ 8598849Sken kern_pg = PHYS_TO_VM_PAGE(vtophys(kaddr)); 86138424Salc 8798849Sken if ((vm_map_lookup(&map, uaddr, 88111977Sken VM_PROT_WRITE, &entry, &uobject, 8998849Sken &upindex, &prot, &wired)) != KERN_SUCCESS) { 9098849Sken return(EFAULT); 9198849Sken } 92116110Salc VM_OBJECT_LOCK(uobject); 9398849Sken if ((user_pg = vm_page_lookup(uobject, upindex)) != NULL) { 94107371Salc do 95107371Salc vm_page_lock_queues(); 96107371Salc while (vm_page_sleep_if_busy(user_pg, 1, "vm_pgmoveco")); 97107371Salc pmap_remove_all(user_pg); 9898849Sken vm_page_free(user_pg); 99108139Salc } else 100108139Salc vm_page_lock_queues(); 10198849Sken if (kern_pg->busy || ((kern_pg->queue - kern_pg->pc) == PQ_FREE) || 10298849Sken (kern_pg->hold_count != 0)|| (kern_pg->flags & PG_BUSY)) { 10398849Sken printf("vm_pgmoveco: pindex(%lu), busy(%d), PG_BUSY(%d), " 10498849Sken "hold(%d) paddr(0x%lx)\n", (u_long)kern_pg->pindex, 10598849Sken kern_pg->busy, (kern_pg->flags & PG_BUSY) ? 1 : 0, 10698849Sken kern_pg->hold_count, (u_long)kern_pg->phys_addr); 10798849Sken if ((kern_pg->queue - kern_pg->pc) == PQ_FREE) 10898849Sken panic("vm_pgmoveco: renaming free page"); 10998849Sken else 11098849Sken panic("vm_pgmoveco: renaming busy page"); 11198849Sken } 112138424Salc vm_page_insert(kern_pg, uobject, upindex); 113138424Salc vm_page_dirty(kern_pg); 11498849Sken kern_pg->valid = VM_PAGE_BITS_ALL; 115108139Salc vm_page_unlock_queues(); 116116110Salc VM_OBJECT_UNLOCK(uobject); 11798849Sken vm_map_lookup_done(map, entry); 11898849Sken return(KERN_SUCCESS); 11998849Sken} 12098849Sken#endif /* ZERO_COPY_SOCKETS */ 12198849Sken 1221549Srgrimesint 123111739Sdesuiomove(void *cp, int n, struct uio *uio) 1241541Srgrimes{ 12583366Sjulian struct thread *td = curthread; 126111737Sdes struct iovec *iov; 1271541Srgrimes u_int cnt; 12844681Sjulian int error = 0; 12944681Sjulian int save = 0; 1301541Srgrimes 13142408Seivind KASSERT(uio->uio_rw == UIO_READ || uio->uio_rw == UIO_WRITE, 13242453Seivind ("uiomove: mode")); 13383366Sjulian KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_td == curthread, 13442453Seivind ("uiomove proc")); 135136444Sjhb WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, 136136444Sjhb "Calling uiomove()"); 13742408Seivind 138130028Stjr save = td->td_pflags & TDP_DEADLKTREAT; 139130028Stjr td->td_pflags |= TDP_DEADLKTREAT; 14044681Sjulian 1411541Srgrimes while (n > 0 && uio->uio_resid) { 1421541Srgrimes iov = uio->uio_iov; 1431541Srgrimes cnt = iov->iov_len; 1441541Srgrimes if (cnt == 0) { 1451541Srgrimes uio->uio_iov++; 1461541Srgrimes uio->uio_iovcnt--; 1471541Srgrimes continue; 1481541Srgrimes } 1491541Srgrimes if (cnt > n) 1501541Srgrimes cnt = n; 1516324Sdg 1521541Srgrimes switch (uio->uio_segflg) { 1531541Srgrimes 1541541Srgrimes case UIO_USERSPACE: 15570861Sjake if (ticks - PCPU_GET(switchticks) >= hogticks) 15643529Sbde uio_yield(); 1571541Srgrimes if (uio->uio_rw == UIO_READ) 1581541Srgrimes error = copyout(cp, iov->iov_base, cnt); 1591541Srgrimes else 1601541Srgrimes error = copyin(iov->iov_base, cp, cnt); 1611541Srgrimes if (error) 16290413Stmm goto out; 1631541Srgrimes break; 1641541Srgrimes 1651541Srgrimes case UIO_SYSSPACE: 1661541Srgrimes if (uio->uio_rw == UIO_READ) 16798998Salfred bcopy(cp, iov->iov_base, cnt); 1681541Srgrimes else 16998998Salfred bcopy(iov->iov_base, cp, cnt); 1701541Srgrimes break; 1717611Sdg case UIO_NOCOPY: 1727611Sdg break; 1731541Srgrimes } 174104908Smike iov->iov_base = (char *)iov->iov_base + cnt; 1751541Srgrimes iov->iov_len -= cnt; 1761541Srgrimes uio->uio_resid -= cnt; 1771541Srgrimes uio->uio_offset += cnt; 178111739Sdes cp = (char *)cp + cnt; 1791541Srgrimes n -= cnt; 1801541Srgrimes } 18190413Stmmout: 182130028Stjr if (save == 0) 183130023Stjr td->td_pflags &= ~TDP_DEADLKTREAT; 18444681Sjulian return (error); 1851541Srgrimes} 1861541Srgrimes 187120665Snectar/* 188120665Snectar * Wrapper for uiomove() that validates the arguments against a known-good 189120665Snectar * kernel buffer. Currently, uiomove accepts a signed (n) argument, which 190120665Snectar * is almost definitely a bad thing, so we catch that here as well. We 191120665Snectar * return a runtime failure, but it might be desirable to generate a runtime 192120665Snectar * assertion failure instead. 193120665Snectar */ 194120665Snectarint 195120665Snectaruiomove_frombuf(void *buf, int buflen, struct uio *uio) 196120665Snectar{ 197120665Snectar unsigned int offset, n; 198120665Snectar 199120665Snectar if (uio->uio_offset < 0 || uio->uio_resid < 0 || 200120665Snectar (offset = uio->uio_offset) != uio->uio_offset) 201120665Snectar return (EINVAL); 202120665Snectar if (buflen <= 0 || offset >= buflen) 203120665Snectar return (0); 204120665Snectar if ((n = buflen - offset) > INT_MAX) 205120665Snectar return (EINVAL); 206120665Snectar return (uiomove((char *)buf + offset, n, uio)); 207120665Snectar} 208120665Snectar 209111937Salc#ifdef ZERO_COPY_SOCKETS 21096080Salc/* 21196080Salc * Experimental support for zero-copy I/O 21296080Salc */ 21398849Skenstatic int 214111739Sdesuserspaceco(void *cp, u_int cnt, struct uio *uio, struct vm_object *obj, 215111737Sdes int disposable) 21698849Sken{ 21798849Sken struct iovec *iov; 21898849Sken int error; 21998849Sken 22098849Sken iov = uio->uio_iov; 22198849Sken if (uio->uio_rw == UIO_READ) { 22298849Sken if ((so_zero_copy_receive != 0) 223138424Salc && (obj == NULL) 22498849Sken && ((cnt & PAGE_MASK) == 0) 22598849Sken && ((((intptr_t) iov->iov_base) & PAGE_MASK) == 0) 22698849Sken && ((uio->uio_offset & PAGE_MASK) == 0) 22798849Sken && ((((intptr_t) cp) & PAGE_MASK) == 0) 22898849Sken && (disposable != 0)) { 22998849Sken /* SOCKET: use page-trading */ 23098849Sken /* 23198849Sken * We only want to call vm_pgmoveco() on 23298849Sken * disposeable pages, since it gives the 23398849Sken * kernel page to the userland process. 23498849Sken */ 23598849Sken error = vm_pgmoveco(&curproc->p_vmspace->vm_map, 236137377Salc (vm_offset_t)cp, (vm_offset_t)iov->iov_base); 23798849Sken 23898849Sken /* 23998849Sken * If we get an error back, attempt 24098849Sken * to use copyout() instead. The 24198849Sken * disposable page should be freed 24298849Sken * automatically if we weren't able to move 24398849Sken * it into userland. 24498849Sken */ 24598849Sken if (error != 0) 24698849Sken error = copyout(cp, iov->iov_base, cnt); 24798849Sken } else { 24898849Sken error = copyout(cp, iov->iov_base, cnt); 24998849Sken } 25098849Sken } else { 25198849Sken error = copyin(iov->iov_base, cp, cnt); 25298849Sken } 25398849Sken return (error); 25498849Sken} 25598849Sken 25631853Sdysonint 257111739Sdesuiomoveco(void *cp, int n, struct uio *uio, struct vm_object *obj, 258111737Sdes int disposable) 25931853Sdyson{ 26031853Sdyson struct iovec *iov; 26131853Sdyson u_int cnt; 26231853Sdyson int error; 26331853Sdyson 26442408Seivind KASSERT(uio->uio_rw == UIO_READ || uio->uio_rw == UIO_WRITE, 26542453Seivind ("uiomoveco: mode")); 26683366Sjulian KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_td == curthread, 26742453Seivind ("uiomoveco proc")); 26842408Seivind 26931853Sdyson while (n > 0 && uio->uio_resid) { 27031853Sdyson iov = uio->uio_iov; 27131853Sdyson cnt = iov->iov_len; 27231853Sdyson if (cnt == 0) { 27331853Sdyson uio->uio_iov++; 27431853Sdyson uio->uio_iovcnt--; 27531853Sdyson continue; 27631853Sdyson } 27731853Sdyson if (cnt > n) 27831853Sdyson cnt = n; 27931853Sdyson 28031853Sdyson switch (uio->uio_segflg) { 28131853Sdyson 28231853Sdyson case UIO_USERSPACE: 28370861Sjake if (ticks - PCPU_GET(switchticks) >= hogticks) 28443529Sbde uio_yield(); 28598849Sken 28698849Sken error = userspaceco(cp, cnt, uio, obj, disposable); 28798849Sken 28831853Sdyson if (error) 28931853Sdyson return (error); 29031853Sdyson break; 29131853Sdyson 29231853Sdyson case UIO_SYSSPACE: 29331853Sdyson if (uio->uio_rw == UIO_READ) 29498998Salfred bcopy(cp, iov->iov_base, cnt); 29531853Sdyson else 29698998Salfred bcopy(iov->iov_base, cp, cnt); 29731853Sdyson break; 29831853Sdyson case UIO_NOCOPY: 29931853Sdyson break; 30031853Sdyson } 301104908Smike iov->iov_base = (char *)iov->iov_base + cnt; 30231853Sdyson iov->iov_len -= cnt; 30331853Sdyson uio->uio_resid -= cnt; 30431853Sdyson uio->uio_offset += cnt; 305111739Sdes cp = (char *)cp + cnt; 30631853Sdyson n -= cnt; 30731853Sdyson } 30831853Sdyson return (0); 30931853Sdyson} 310111937Salc#endif /* ZERO_COPY_SOCKETS */ 31131853Sdyson 31296080Salc/* 3131541Srgrimes * Give next character to user as result of read. 3141541Srgrimes */ 3151549Srgrimesint 316111737Sdesureadc(int c, struct uio *uio) 3171541Srgrimes{ 318111737Sdes struct iovec *iov; 319111737Sdes char *iov_base; 3201541Srgrimes 3211541Srgrimesagain: 3221541Srgrimes if (uio->uio_iovcnt == 0 || uio->uio_resid == 0) 3231541Srgrimes panic("ureadc"); 3241541Srgrimes iov = uio->uio_iov; 3251541Srgrimes if (iov->iov_len == 0) { 3261541Srgrimes uio->uio_iovcnt--; 3271541Srgrimes uio->uio_iov++; 3281541Srgrimes goto again; 3291541Srgrimes } 3301541Srgrimes switch (uio->uio_segflg) { 3311541Srgrimes 3321541Srgrimes case UIO_USERSPACE: 3331541Srgrimes if (subyte(iov->iov_base, c) < 0) 3341541Srgrimes return (EFAULT); 3351541Srgrimes break; 3361541Srgrimes 3371541Srgrimes case UIO_SYSSPACE: 338104908Smike iov_base = iov->iov_base; 339104908Smike *iov_base = c; 340104908Smike iov->iov_base = iov_base; 3411541Srgrimes break; 3421541Srgrimes 3438177Sdg case UIO_NOCOPY: 3448177Sdg break; 3451541Srgrimes } 346104908Smike iov->iov_base = (char *)iov->iov_base + 1; 3471541Srgrimes iov->iov_len--; 3481541Srgrimes uio->uio_resid--; 3491541Srgrimes uio->uio_offset++; 3501541Srgrimes return (0); 3511541Srgrimes} 3521541Srgrimes 3531541Srgrimes/* 3541541Srgrimes * General routine to allocate a hash table. 3551541Srgrimes */ 3561541Srgrimesvoid * 357111737Sdeshashinit(int elements, struct malloc_type *type, u_long *hashmask) 3581541Srgrimes{ 3591541Srgrimes long hashsize; 36060938Sjake LIST_HEAD(generic, generic) *hashtbl; 3611541Srgrimes int i; 3621541Srgrimes 3631541Srgrimes if (elements <= 0) 3648364Sdg panic("hashinit: bad elements"); 3651541Srgrimes for (hashsize = 1; hashsize <= elements; hashsize <<= 1) 3661541Srgrimes continue; 3671541Srgrimes hashsize >>= 1; 368111119Simp hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK); 3691541Srgrimes for (i = 0; i < hashsize; i++) 3701541Srgrimes LIST_INIT(&hashtbl[i]); 3711541Srgrimes *hashmask = hashsize - 1; 3721541Srgrimes return (hashtbl); 3731541Srgrimes} 3747611Sdg 37599098Siedowsevoid 376111737Sdeshashdestroy(void *vhashtbl, struct malloc_type *type, u_long hashmask) 37799098Siedowse{ 37899098Siedowse LIST_HEAD(generic, generic) *hashtbl, *hp; 37999098Siedowse 38099098Siedowse hashtbl = vhashtbl; 38199098Siedowse for (hp = hashtbl; hp <= &hashtbl[hashmask]; hp++) 38299098Siedowse if (!LIST_EMPTY(hp)) 38399098Siedowse panic("hashdestroy: hash not empty"); 38499098Siedowse free(hashtbl, type); 38599098Siedowse} 38699098Siedowse 3877683Sdgstatic int primes[] = { 1, 13, 31, 61, 127, 251, 509, 761, 1021, 1531, 2039, 3887683Sdg 2557, 3067, 3583, 4093, 4603, 5119, 5623, 6143, 6653, 3897611Sdg 7159, 7673, 8191, 12281, 16381, 24571, 32749 }; 39026205Salex#define NPRIMES (sizeof(primes) / sizeof(primes[0])) 3917611Sdg 3927611Sdg/* 3937611Sdg * General routine to allocate a prime number sized hash table. 3947611Sdg */ 3957611Sdgvoid * 396111737Sdesphashinit(int elements, struct malloc_type *type, u_long *nentries) 3977611Sdg{ 3987611Sdg long hashsize; 39960938Sjake LIST_HEAD(generic, generic) *hashtbl; 4007611Sdg int i; 4017611Sdg 4027611Sdg if (elements <= 0) 4038364Sdg panic("phashinit: bad elements"); 4047611Sdg for (i = 1, hashsize = primes[1]; hashsize <= elements;) { 4057611Sdg i++; 4067611Sdg if (i == NPRIMES) 4077611Sdg break; 4087611Sdg hashsize = primes[i]; 4097611Sdg } 4107611Sdg hashsize = primes[i - 1]; 411111119Simp hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK); 4127611Sdg for (i = 0; i < hashsize; i++) 4137611Sdg LIST_INIT(&hashtbl[i]); 4147611Sdg *nentries = hashsize; 4157611Sdg return (hashtbl); 4167611Sdg} 41743529Sbde 41883959Sdillonvoid 419111737Sdesuio_yield(void) 42043529Sbde{ 42183366Sjulian struct thread *td; 42243529Sbde 42383366Sjulian td = curthread; 42472200Sbmilekic mtx_lock_spin(&sched_lock); 42588900Sjhb DROP_GIANT(); 426104964Sjeff sched_prio(td, td->td_ksegrp->kg_user_pri); /* XXXKSE */ 427131473Sjhb mi_switch(SW_INVOL, NULL); 42872200Sbmilekic mtx_unlock_spin(&sched_lock); 42968808Sjhb PICKUP_GIANT(); 43043529Sbde} 43172537Sjlemon 43272537Sjlemonint 433123852Salfredcopyinfrom(const void * __restrict src, void * __restrict dst, size_t len, 434123852Salfred int seg) 43572537Sjlemon{ 43672537Sjlemon int error = 0; 43772537Sjlemon 43872537Sjlemon switch (seg) { 43972537Sjlemon case UIO_USERSPACE: 44072537Sjlemon error = copyin(src, dst, len); 44172537Sjlemon break; 44272537Sjlemon case UIO_SYSSPACE: 44372537Sjlemon bcopy(src, dst, len); 44472537Sjlemon break; 44572537Sjlemon default: 44672537Sjlemon panic("copyinfrom: bad seg %d\n", seg); 44772537Sjlemon } 44872537Sjlemon return (error); 44972537Sjlemon} 45072537Sjlemon 45172537Sjlemonint 452123852Salfredcopyinstrfrom(const void * __restrict src, void * __restrict dst, size_t len, 453123852Salfred size_t * __restrict copied, int seg) 45472537Sjlemon{ 45572537Sjlemon int error = 0; 45672537Sjlemon 45772537Sjlemon switch (seg) { 45872537Sjlemon case UIO_USERSPACE: 45972537Sjlemon error = copyinstr(src, dst, len, copied); 46072537Sjlemon break; 46172537Sjlemon case UIO_SYSSPACE: 46272537Sjlemon error = copystr(src, dst, len, copied); 46372537Sjlemon break; 46472537Sjlemon default: 46572537Sjlemon panic("copyinstrfrom: bad seg %d\n", seg); 46672537Sjlemon } 46772537Sjlemon return (error); 46872537Sjlemon} 469125296Ssilby 470125296Ssilbyint 471131897Sphkcopyiniov(struct iovec *iovp, u_int iovcnt, struct iovec **iov, int error) 472125296Ssilby{ 473131897Sphk u_int iovlen; 474131897Sphk 475131897Sphk *iov = NULL; 476131897Sphk if (iovcnt > UIO_MAXIOV) 477131897Sphk return (error); 478131897Sphk iovlen = iovcnt * sizeof (struct iovec); 479131897Sphk *iov = malloc(iovlen, M_IOV, M_WAITOK); 480131897Sphk error = copyin(iovp, *iov, iovlen); 481131897Sphk if (error) { 482131897Sphk free(*iov, M_IOV); 483131897Sphk *iov = NULL; 484131897Sphk } 485131897Sphk return (error); 486131897Sphk} 487131897Sphk 488131897Sphkint 489131897Sphkcopyinuio(struct iovec *iovp, u_int iovcnt, struct uio **uiop) 490131897Sphk{ 491125420Ssilby struct iovec *iov; 492131897Sphk struct uio *uio; 493125296Ssilby u_int iovlen; 494125420Ssilby int error, i; 495125296Ssilby 496131897Sphk *uiop = NULL; 497131897Sphk if (iovcnt > UIO_MAXIOV) 498131897Sphk return (EINVAL); 499125420Ssilby iovlen = iovcnt * sizeof (struct iovec); 500131897Sphk uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK); 501131897Sphk iov = (struct iovec *)(uio + 1); 502131897Sphk error = copyin(iovp, iov, iovlen); 503131897Sphk if (error) { 504131897Sphk free(uio, M_IOV); 505131897Sphk return (error); 506125420Ssilby } 507125420Ssilby uio->uio_iov = iov; 508125420Ssilby uio->uio_iovcnt = iovcnt; 509125420Ssilby uio->uio_segflg = UIO_USERSPACE; 510125420Ssilby uio->uio_offset = -1; 511125420Ssilby uio->uio_resid = 0; 512125420Ssilby for (i = 0; i < iovcnt; i++) { 513125420Ssilby if (iov->iov_len > INT_MAX - uio->uio_resid) { 514131897Sphk free(uio, M_IOV); 515131897Sphk return (EINVAL); 516125420Ssilby } 517125420Ssilby uio->uio_resid += iov->iov_len; 518125420Ssilby iov++; 519125420Ssilby } 520131897Sphk *uiop = uio; 521131897Sphk return (0); 522131897Sphk} 523125296Ssilby 524131897Sphkstruct uio * 525131897Sphkcloneuio(struct uio *uiop) 526131897Sphk{ 527131897Sphk struct uio *uio; 528131897Sphk int iovlen; 529125296Ssilby 530131897Sphk iovlen = uiop->uio_iovcnt * sizeof (struct iovec); 531131897Sphk uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK); 532131897Sphk *uio = *uiop; 533131897Sphk uio->uio_iov = (struct iovec *)(uio + 1); 534131897Sphk bcopy(uiop->uio_iov, uio->uio_iov, iovlen); 535131897Sphk return (uio); 536125296Ssilby} 537