sys/opencrypto/criov.c

   1 /*      $NetBSD: criov.c,v 1.6 2008/02/01 04:52:35 tls Exp $ */
   2 /*      $OpenBSD: criov.c,v 1.11 2002/06/10 19:36:43 espie Exp $        */
   3
   4 /*
   5  * Copyright (c) 1999 Theo de Raadt
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *   notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *   notice, this list of conditions and the following disclaimer in the
  15  *   documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *   derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __KERNEL_RCSID(0, "$NetBSD: criov.c,v 1.6 2008/02/01 04:52:35 tls Exp $");
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/proc.h>
  37 #include <sys/errno.h>
  38 #include <sys/malloc.h>
  39 #include <sys/kernel.h>
  40 #include <sys/mbuf.h>
  41
  42 #include <uvm/uvm_extern.h>
  43
  44 #include <opencrypto/cryptodev.h>
  45 int cuio_getindx(struct uio *uio, int loc, int *off);
  46
  47
  48 void
  49 cuio_copydata(struct uio *uio, int off, int len, void *cp)
  50 {
  51         struct iovec *iov = uio->uio_iov;
  52         int iol = uio->uio_iovcnt;
  53         unsigned count;
  54
  55         if (off < 0)
  56                 panic("cuio_copydata: off %d < 0", off);
  57         if (len < 0)
  58                 panic("cuio_copydata: len %d < 0", len);
  59         while (off > 0) {
  60                 if (iol == 0)
  61                         panic("iov_copydata: empty in skip");
  62                 if (off < iov->iov_len)
  63                         break;
  64                 off -= iov->iov_len;
  65                 iol--;
  66                 iov++;
  67         }
  68         while (len > 0) {
  69                 if (iol == 0)
  70                         panic("cuio_copydata: empty");
  71                 count = min(iov->iov_len - off, len);
  72                 memcpy(cp, (char *)iov->iov_base + off, count);
  73                 len -= count;
  74                 cp = (char *)cp + count;
  75                 off = 0;
  76                 iol--;
  77                 iov++;
  78         }
  79 }
  80
  81 void
  82 cuio_copyback(struct uio *uio, int off, int len, void *cp)
  83 {
  84         struct iovec *iov = uio->uio_iov;
  85         int iol = uio->uio_iovcnt;
  86         unsigned count;
  87
  88         if (off < 0)
  89                 panic("cuio_copyback: off %d < 0", off);
  90         if (len < 0)
  91                 panic("cuio_copyback: len %d < 0", len);
  92         while (off > 0) {
  93                 if (iol == 0)
  94                         panic("cuio_copyback: empty in skip");
  95                 if (off < iov->iov_len)
  96                         break;
  97                 off -= iov->iov_len;
  98                 iol--;
  99                 iov++;
 100         }
 101         while (len > 0) {
 102                 if (iol == 0)
 103                         panic("uio_copyback: empty");
 104                 count = min(iov->iov_len - off, len);
 105                 memcpy((char *)iov->iov_base + off, cp, count);
 106                 len -= count;
 107                 cp = (char *)cp + count;
 108                 off = 0;
 109                 iol--;
 110                 iov++;
 111         }
 112 }
 113
 114 /*
 115  * Return a pointer to iov/offset of location in iovec list.
 116  */
 117
 118 int
 119 cuio_getptr(struct uio *uio, int loc, int *off)
 120 {
 121         int ind, len;
 122
 123         ind = 0;
 124         while (loc >= 0 && ind < uio->uio_iovcnt) {
 125                 len = uio->uio_iov[ind].iov_len;
 126                 if (len > loc) {
 127                         *off = loc;
 128                         return (ind);
 129                 }
 130                 loc -= len;
 131                 ind++;
 132         }
 133
 134         if (ind > 0 && loc == 0) {
 135                 ind--;
 136                 *off = uio->uio_iov[ind].iov_len;
 137                 return (ind);
 138         }
 139
 140         return (-1);
 141 }
 142
 143 int
 144 cuio_apply(struct uio *uio, int off, int len,
 145     int (*f)(void *, void *, unsigned int), void *fstate)
 146 {
 147         int rval, ind, uiolen;
 148         unsigned int count;
 149
 150         if (len < 0)
 151                 panic("%s: len %d < 0", __func__, len);
 152         if (off < 0)
 153                 panic("%s: off %d < 0", __func__, off);
 154
 155         ind = 0;
 156         while (off > 0) {
 157                 if (ind >= uio->uio_iovcnt)
 158                         panic("cuio_apply: out of ivecs before data in uio");
 159                 uiolen = uio->uio_iov[ind].iov_len;
 160                 if (off < uiolen)
 161                         break;
 162                 off -= uiolen;
 163                 ind++;
 164         }
 165         while (len > 0) {
 166                 if (ind >= uio->uio_iovcnt)
 167                         panic("cuio_apply: out of ivecs when processing uio");
 168                 count = min(uio->uio_iov[ind].iov_len - off, len);
 169
 170                 rval = f(fstate,
 171                          ((char *)uio->uio_iov[ind].iov_base + off), count);
 172                 if (rval)
 173                         return (rval);
 174
 175                 len -= count;
 176                 off = 0;
 177                 ind++;
 178         }
 179
 180         return (0);
 181 }