sys/opencrypto/criov.c

   1 /*      $OpenBSD: criov.c,v 1.9 2002/01/29 15:48:29 jason Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1999 Theo de Raadt
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/proc.h>
  36 #include <sys/errno.h>
  37 #include <sys/malloc.h>
  38 #include <sys/kernel.h>
  39 #include <sys/mbuf.h>
  40 #include <sys/uio.h>
  41 #include <sys/limits.h>
  42 #include <sys/lock.h>
  43 #include <sys/sdt.h>
  44
  45 #include <machine/vmparam.h>
  46
  47 #include <vm/vm.h>
  48 #include <vm/vm_page.h>
  49 #include <vm/pmap.h>
  50
  51 #include <opencrypto/cryptodev.h>
  52
  53 SDT_PROVIDER_DECLARE(opencrypto);
  54
  55 /*
  56  * These macros are only for avoiding code duplication, as we need to skip
  57  * given number of bytes in the same way in several functions below.
  58  */
  59 #define CUIO_SKIP()     do {                                            \
  60         KASSERT(off >= 0, ("%s: off %d < 0", __func__, off));           \
  61         KASSERT(len >= 0, ("%s: len %d < 0", __func__, len));           \
  62         while (off > 0) {                                               \
  63                 KASSERT(iol >= 0, ("%s: empty in skip", __func__));     \
  64                 if (off < iov->iov_len)                                 \
  65                         break;                                          \
  66                 off -= iov->iov_len;                                    \
  67                 iol--;                                                  \
  68                 iov++;                                                  \
  69         }                                                               \
  70 } while (0)
  71
  72 #define CVM_PAGE_SKIP() do {                                    \
  73         KASSERT(off >= 0, ("%s: off %d < 0", __func__, off));           \
  74         KASSERT(len >= 0, ("%s: len %d < 0", __func__, len));           \
  75         while (off > 0) {                                               \
  76                 if (off < PAGE_SIZE)                                    \
  77                         break;                                          \
  78                 processed += PAGE_SIZE - off;                           \
  79                 off -= PAGE_SIZE - off;                                 \
  80                 pages++;                                                \
  81         }                                                               \
  82 } while (0)
  83
  84 static void
  85 cuio_copydata(struct uio* uio, int off, int len, caddr_t cp)
  86 {
  87         struct iovec *iov = uio->uio_iov;
  88         int iol = uio->uio_iovcnt;
  89         unsigned count;
  90
  91         CUIO_SKIP();
  92         while (len > 0) {
  93                 KASSERT(iol >= 0, ("%s: empty", __func__));
  94                 count = min(iov->iov_len - off, len);
  95                 bcopy(((caddr_t)iov->iov_base) + off, cp, count);
  96                 len -= count;
  97                 cp += count;
  98                 off = 0;
  99                 iol--;
 100                 iov++;
 101         }
 102 }
 103
 104 static void
 105 cuio_copyback(struct uio* uio, int off, int len, c_caddr_t cp)
 106 {
 107         struct iovec *iov = uio->uio_iov;
 108         int iol = uio->uio_iovcnt;
 109         unsigned count;
 110
 111         CUIO_SKIP();
 112         while (len > 0) {
 113                 KASSERT(iol >= 0, ("%s: empty", __func__));
 114                 count = min(iov->iov_len - off, len);
 115                 bcopy(cp, ((caddr_t)iov->iov_base) + off, count);
 116                 len -= count;
 117                 cp += count;
 118                 off = 0;
 119                 iol--;
 120                 iov++;
 121         }
 122 }
 123
 124 /*
 125  * Return the index and offset of location in iovec list.
 126  */
 127 static int
 128 cuio_getptr(struct uio *uio, int loc, int *off)
 129 {
 130         int ind, len;
 131
 132         ind = 0;
 133         while (loc >= 0 && ind < uio->uio_iovcnt) {
 134                 len = uio->uio_iov[ind].iov_len;
 135                 if (len > loc) {
 136                         *off = loc;
 137                         return (ind);
 138                 }
 139                 loc -= len;
 140                 ind++;
 141         }
 142
 143         if (ind > 0 && loc == 0) {
 144                 ind--;
 145                 *off = uio->uio_iov[ind].iov_len;
 146                 return (ind);
 147         }
 148
 149         return (-1);
 150 }
 151
 152 #if CRYPTO_MAY_HAVE_VMPAGE
 153 /*
 154  * Apply function f to the data in a vm_page_t list starting "off" bytes from
 155  * the beginning, continuing for "len" bytes.
 156  */
 157 static int
 158 cvm_page_apply(vm_page_t *pages, int off, int len,
 159     int (*f)(void *, const void *, u_int), void *arg)
 160 {
 161         int processed = 0;
 162         unsigned count;
 163         int rval;
 164
 165         CVM_PAGE_SKIP();
 166         while (len > 0) {
 167                 char *kaddr = (char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages));
 168                 count = min(PAGE_SIZE - off, len);
 169                 rval = (*f)(arg, kaddr + off, count);
 170                 if (rval)
 171                         return (rval);
 172                 len -= count;
 173                 processed += count;
 174                 off = 0;
 175                 pages++;
 176         }
 177         return (0);
 178 }
 179
 180 static inline void *
 181 cvm_page_contiguous_segment(vm_page_t *pages, size_t skip, int len)
 182 {
 183         if ((skip + len - 1) / PAGE_SIZE > skip / PAGE_SIZE)
 184                 return (NULL);
 185
 186         pages += (skip / PAGE_SIZE);
 187         skip -= rounddown(skip, PAGE_SIZE);
 188         return (((char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages))) + skip);
 189 }
 190
 191 /*
 192  * Copy len bytes of data from the vm_page_t array, skipping the first off
 193  * bytes, into the pointer cp.  Return the number of bytes skipped and copied.
 194  * Does not verify the length of the array.
 195  */
 196 static int
 197 cvm_page_copyback(vm_page_t *pages, int off, int len, c_caddr_t cp)
 198 {
 199         int processed = 0;
 200         unsigned count;
 201
 202         CVM_PAGE_SKIP();
 203         while (len > 0) {
 204                 count = min(PAGE_SIZE - off, len);
 205                 bcopy(cp, (char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages)) + off,
 206                     count);
 207                 len -= count;
 208                 cp += count;
 209                 processed += count;
 210                 off = 0;
 211                 pages++;
 212         }
 213         return (processed);
 214 }
 215
 216 /*
 217  * Copy len bytes of data from the pointer cp into the vm_page_t array,
 218  * skipping the first off bytes, Return the number of bytes skipped and copied.
 219  * Does not verify the length of the array.
 220  */
 221 static int
 222 cvm_page_copydata(vm_page_t *pages, int off, int len, caddr_t cp)
 223 {
 224         int processed = 0;
 225         unsigned count;
 226
 227         CVM_PAGE_SKIP();
 228         while (len > 0) {
 229                 count = min(PAGE_SIZE - off, len);
 230                 bcopy(((char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages)) + off), cp,
 231                     count);
 232                 len -= count;
 233                 cp += count;
 234                 processed += count;
 235                 off = 0;
 236                 pages++;
 237         }
 238         return processed;
 239 }
 240 #endif /* CRYPTO_MAY_HAVE_VMPAGE */
 241
 242 /*
 243  * Given a starting page in an m_epg, determine the length of the
 244  * current physically contiguous segment.
 245  */
 246 static __inline size_t
 247 m_epg_pages_extent(struct mbuf *m, int idx, u_int pglen)
 248 {
 249         size_t len;
 250         u_int i;
 251
 252         len = pglen;
 253         for (i = idx + 1; i < m->m_epg_npgs; i++) {
 254                 if (m->m_epg_pa[i - 1] + PAGE_SIZE != m->m_epg_pa[i])
 255                         break;
 256                 len += m_epg_pagelen(m, i, 0);
 257         }
 258         return (len);
 259 }
 260
 261 static __inline void *
 262 m_epg_segbase(struct mbuf *m, size_t offset)
 263 {
 264         u_int i, pglen, pgoff;
 265
 266         offset += mtod(m, vm_offset_t);
 267         if (offset < m->m_epg_hdrlen)
 268                 return (m->m_epg_hdr + offset);
 269         offset -= m->m_epg_hdrlen;
 270         pgoff = m->m_epg_1st_off;
 271         for (i = 0; i < m->m_epg_npgs; i++) {
 272                 pglen = m_epg_pagelen(m, i, pgoff);
 273                 if (offset < pglen)
 274                         return ((void *)PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff +
 275                             offset));
 276                 offset -= pglen;
 277                 pgoff = 0;
 278         }
 279         KASSERT(offset <= m->m_epg_trllen, ("%s: offset beyond trailer",
 280             __func__));
 281         return (m->m_epg_trail + offset);
 282 }
 283
 284 static __inline size_t
 285 m_epg_seglen(struct mbuf *m, size_t offset)
 286 {
 287         u_int i, pglen, pgoff;
 288
 289         offset += mtod(m, vm_offset_t);
 290         if (offset < m->m_epg_hdrlen)
 291                 return (m->m_epg_hdrlen - offset);
 292         offset -= m->m_epg_hdrlen;
 293         pgoff = m->m_epg_1st_off;
 294         for (i = 0; i < m->m_epg_npgs; i++) {
 295                 pglen = m_epg_pagelen(m, i, pgoff);
 296                 if (offset < pglen)
 297                         return (m_epg_pages_extent(m, i, pglen) - offset);
 298                 offset -= pglen;
 299                 pgoff = 0;
 300         }
 301         KASSERT(offset <= m->m_epg_trllen, ("%s: offset beyond trailer",
 302             __func__));
 303         return (m->m_epg_trllen - offset);
 304 }
 305
 306 static __inline void *
 307 m_epg_contiguous_subsegment(struct mbuf *m, size_t skip, size_t len)
 308 {
 309         u_int i, pglen, pgoff;
 310
 311         skip += mtod(m, vm_offset_t);
 312         if (skip < m->m_epg_hdrlen) {
 313                 if (len > m->m_epg_hdrlen - skip)
 314                         return (NULL);
 315                 return (m->m_epg_hdr + skip);
 316         }
 317         skip -= m->m_epg_hdrlen;
 318         pgoff = m->m_epg_1st_off;
 319         for (i = 0; i < m->m_epg_npgs; i++) {
 320                 pglen = m_epg_pagelen(m, i, pgoff);
 321                 if (skip < pglen) {
 322                         if (len > m_epg_pages_extent(m, i, pglen) - skip)
 323                                 return (NULL);
 324                         return ((void *)PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff +
 325                             skip));
 326                 }
 327                 skip -= pglen;
 328                 pgoff = 0;
 329         }
 330         KASSERT(skip <= m->m_epg_trllen && len <= m->m_epg_trllen - skip,
 331             ("%s: segment beyond trailer", __func__));
 332         return (m->m_epg_trail + skip);
 333 }
 334
 335 void
 336 crypto_cursor_init(struct crypto_buffer_cursor *cc,
 337     const struct crypto_buffer *cb)
 338 {
 339         memset(cc, 0, sizeof(*cc));
 340         cc->cc_type = cb->cb_type;
 341         switch (cc->cc_type) {
 342         case CRYPTO_BUF_CONTIG:
 343                 cc->cc_buf = cb->cb_buf;
 344                 cc->cc_buf_len = cb->cb_buf_len;
 345                 break;
 346         case CRYPTO_BUF_MBUF:
 347         case CRYPTO_BUF_SINGLE_MBUF:
 348                 cc->cc_mbuf = cb->cb_mbuf;
 349                 break;
 350         case CRYPTO_BUF_VMPAGE:
 351                 cc->cc_vmpage = cb->cb_vm_page;
 352                 cc->cc_buf_len = cb->cb_vm_page_len;
 353                 cc->cc_offset = cb->cb_vm_page_offset;
 354                 break;
 355         case CRYPTO_BUF_UIO:
 356                 cc->cc_iov = cb->cb_uio->uio_iov;
 357                 break;
 358         default:
 359 #ifdef INVARIANTS
 360                 panic("%s: invalid buffer type %d", __func__, cb->cb_type);
 361 #endif
 362                 break;
 363         }
 364 }
 365
 366 SDT_PROBE_DEFINE2(opencrypto, criov, cursor_advance, vmpage, "struct crypto_buffer_cursor*", "size_t");
 367
 368 void
 369 crypto_cursor_advance(struct crypto_buffer_cursor *cc, size_t amount)
 370 {
 371         size_t remain;
 372
 373         switch (cc->cc_type) {
 374         case CRYPTO_BUF_CONTIG:
 375                 MPASS(cc->cc_buf_len >= amount);
 376                 cc->cc_buf += amount;
 377                 cc->cc_buf_len -= amount;
 378                 break;
 379         case CRYPTO_BUF_MBUF:
 380                 for (;;) {
 381                         remain = cc->cc_mbuf->m_len - cc->cc_offset;
 382                         if (amount < remain) {
 383                                 cc->cc_offset += amount;
 384                                 break;
 385                         }
 386                         amount -= remain;
 387                         cc->cc_mbuf = cc->cc_mbuf->m_next;
 388                         cc->cc_offset = 0;
 389                         if (amount == 0)
 390                                 break;
 391                 }
 392                 break;
 393         case CRYPTO_BUF_SINGLE_MBUF:
 394                 MPASS(cc->cc_mbuf->m_len >= cc->cc_offset + amount);
 395                 cc->cc_offset += amount;
 396                 break;
 397         case CRYPTO_BUF_VMPAGE:
 398                 for (;;) {
 399                         SDT_PROBE2(opencrypto, criov, cursor_advance, vmpage,
 400                             cc, amount);
 401                         remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);
 402                         if (amount < remain) {
 403                                 cc->cc_buf_len -= amount;
 404                                 cc->cc_offset += amount;
 405                                 break;
 406                         }
 407                         cc->cc_buf_len -= remain;
 408                         amount -= remain;
 409                         cc->cc_vmpage++;
 410                         cc->cc_offset = 0;
 411                         if (amount == 0 || cc->cc_buf_len == 0)
 412                                 break;
 413                 }
 414                 break;
 415         case CRYPTO_BUF_UIO:
 416                 for (;;) {
 417                         remain = cc->cc_iov->iov_len - cc->cc_offset;
 418                         if (amount < remain) {
 419                                 cc->cc_offset += amount;
 420                                 break;
 421                         }
 422                         amount -= remain;
 423                         cc->cc_iov++;
 424                         cc->cc_offset = 0;
 425                         if (amount == 0)
 426                                 break;
 427                 }
 428                 break;
 429         default:
 430 #ifdef INVARIANTS
 431                 panic("%s: invalid buffer type %d", __func__, cc->cc_type);
 432 #endif
 433                 break;
 434         }
 435 }
 436
 437 void *
 438 crypto_cursor_segbase(struct crypto_buffer_cursor *cc)
 439 {
 440         switch (cc->cc_type) {
 441         case CRYPTO_BUF_CONTIG:
 442                 return (cc->cc_buf);
 443         case CRYPTO_BUF_MBUF:
 444         case CRYPTO_BUF_SINGLE_MBUF:
 445                 if (cc->cc_mbuf == NULL)
 446                         return (NULL);
 447                 if (cc->cc_mbuf->m_flags & M_EXTPG)
 448                         return (m_epg_segbase(cc->cc_mbuf, cc->cc_offset));
 449                 return (mtod(cc->cc_mbuf, char *) + cc->cc_offset);
 450         case CRYPTO_BUF_VMPAGE:
 451                 return ((char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(
 452                     *cc->cc_vmpage)) + cc->cc_offset);
 453         case CRYPTO_BUF_UIO:
 454                 return ((char *)cc->cc_iov->iov_base + cc->cc_offset);
 455         default:
 456 #ifdef INVARIANTS
 457                 panic("%s: invalid buffer type %d", __func__, cc->cc_type);
 458 #endif
 459                 return (NULL);
 460         }
 461 }
 462
 463 size_t
 464 crypto_cursor_seglen(struct crypto_buffer_cursor *cc)
 465 {
 466         switch (cc->cc_type) {
 467         case CRYPTO_BUF_CONTIG:
 468                 return (cc->cc_buf_len);
 469         case CRYPTO_BUF_VMPAGE:
 470                 return (PAGE_SIZE - cc->cc_offset);
 471         case CRYPTO_BUF_MBUF:
 472         case CRYPTO_BUF_SINGLE_MBUF:
 473                 if (cc->cc_mbuf == NULL)
 474                         return (0);
 475                 if (cc->cc_mbuf->m_flags & M_EXTPG)
 476                         return (m_epg_seglen(cc->cc_mbuf, cc->cc_offset));
 477                 return (cc->cc_mbuf->m_len - cc->cc_offset);
 478         case CRYPTO_BUF_UIO:
 479                 return (cc->cc_iov->iov_len - cc->cc_offset);
 480         default:
 481 #ifdef INVARIANTS
 482                 panic("%s: invalid buffer type %d", __func__, cc->cc_type);
 483 #endif
 484                 return (0);
 485         }
 486 }
 487
 488 void
 489 crypto_cursor_copyback(struct crypto_buffer_cursor *cc, int size,
 490     const void *vsrc)
 491 {
 492         size_t remain, todo;
 493         const char *src;
 494         char *dst;
 495
 496         src = vsrc;
 497         switch (cc->cc_type) {
 498         case CRYPTO_BUF_CONTIG:
 499                 MPASS(cc->cc_buf_len >= size);
 500                 memcpy(cc->cc_buf, src, size);
 501                 cc->cc_buf += size;
 502                 cc->cc_buf_len -= size;
 503                 break;
 504         case CRYPTO_BUF_MBUF:
 505                 for (;;) {
 506                         /*
 507                          * This uses m_copyback() for individual
 508                          * mbufs so that cc_mbuf and cc_offset are
 509                          * updated.
 510                          */
 511                         remain = cc->cc_mbuf->m_len - cc->cc_offset;
 512                         todo = MIN(remain, size);
 513                         m_copyback(cc->cc_mbuf, cc->cc_offset, todo, src);
 514                         src += todo;
 515                         if (todo < remain) {
 516                                 cc->cc_offset += todo;
 517                                 break;
 518                         }
 519                         size -= todo;
 520                         cc->cc_mbuf = cc->cc_mbuf->m_next;
 521                         cc->cc_offset = 0;
 522                         if (size == 0)
 523                                 break;
 524                 }
 525                 break;
 526         case CRYPTO_BUF_SINGLE_MBUF:
 527                 MPASS(cc->cc_mbuf->m_len >= cc->cc_offset + size);
 528                 m_copyback(cc->cc_mbuf, cc->cc_offset, size, src);
 529                 cc->cc_offset += size;
 530                 break;
 531         case CRYPTO_BUF_VMPAGE:
 532                 for (;;) {
 533                         dst = (char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(
 534                             *cc->cc_vmpage)) + cc->cc_offset;
 535                         remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);
 536                         todo = MIN(remain, size);
 537                         memcpy(dst, src, todo);
 538                         src += todo;
 539                         cc->cc_buf_len -= todo;
 540                         if (todo < remain) {
 541                                 cc->cc_offset += todo;
 542                                 break;
 543                         }
 544                         size -= todo;
 545                         cc->cc_vmpage++;
 546                         cc->cc_offset = 0;
 547                         if (size == 0)
 548                                 break;
 549                 }
 550                 break;
 551         case CRYPTO_BUF_UIO:
 552                 for (;;) {
 553                         dst = (char *)cc->cc_iov->iov_base + cc->cc_offset;
 554                         remain = cc->cc_iov->iov_len - cc->cc_offset;
 555                         todo = MIN(remain, size);
 556                         memcpy(dst, src, todo);
 557                         src += todo;
 558                         if (todo < remain) {
 559                                 cc->cc_offset += todo;
 560                                 break;
 561                         }
 562                         size -= todo;
 563                         cc->cc_iov++;
 564                         cc->cc_offset = 0;
 565                         if (size == 0)
 566                                 break;
 567                 }
 568                 break;
 569         default:
 570 #ifdef INVARIANTS
 571                 panic("%s: invalid buffer type %d", __func__, cc->cc_type);
 572 #endif
 573                 break;
 574         }
 575 }
 576
 577 void
 578 crypto_cursor_copydata(struct crypto_buffer_cursor *cc, int size, void *vdst)
 579 {
 580         size_t remain, todo;
 581         const char *src;
 582         char *dst;
 583
 584         dst = vdst;
 585         switch (cc->cc_type) {
 586         case CRYPTO_BUF_CONTIG:
 587                 MPASS(cc->cc_buf_len >= size);
 588                 memcpy(dst, cc->cc_buf, size);
 589                 cc->cc_buf += size;
 590                 cc->cc_buf_len -= size;
 591                 break;
 592         case CRYPTO_BUF_MBUF:
 593                 for (;;) {
 594                         /*
 595                          * This uses m_copydata() for individual
 596                          * mbufs so that cc_mbuf and cc_offset are
 597                          * updated.
 598                          */
 599                         remain = cc->cc_mbuf->m_len - cc->cc_offset;
 600                         todo = MIN(remain, size);
 601                         m_copydata(cc->cc_mbuf, cc->cc_offset, todo, dst);
 602                         dst += todo;
 603                         if (todo < remain) {
 604                                 cc->cc_offset += todo;
 605                                 break;
 606                         }
 607                         size -= todo;
 608                         cc->cc_mbuf = cc->cc_mbuf->m_next;
 609                         cc->cc_offset = 0;
 610                         if (size == 0)
 611                                 break;
 612                 }
 613                 break;
 614         case CRYPTO_BUF_SINGLE_MBUF:
 615                 MPASS(cc->cc_mbuf->m_len >= cc->cc_offset + size);
 616                 m_copydata(cc->cc_mbuf, cc->cc_offset, size, dst);
 617                 cc->cc_offset += size;
 618                 break;
 619         case CRYPTO_BUF_VMPAGE:
 620                 for (;;) {
 621                         src = (char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(
 622                             *cc->cc_vmpage)) + cc->cc_offset;
 623                         remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);
 624                         todo = MIN(remain, size);
 625                         memcpy(dst, src, todo);
 626                         src += todo;
 627                         cc->cc_buf_len -= todo;
 628                         if (todo < remain) {
 629                                 cc->cc_offset += todo;
 630                                 break;
 631                         }
 632                         size -= todo;
 633                         cc->cc_vmpage++;
 634                         cc->cc_offset = 0;
 635                         if (size == 0)
 636                                 break;
 637                 }
 638                 break;
 639         case CRYPTO_BUF_UIO:
 640                 for (;;) {
 641                         src = (const char *)cc->cc_iov->iov_base +
 642                             cc->cc_offset;
 643                         remain = cc->cc_iov->iov_len - cc->cc_offset;
 644                         todo = MIN(remain, size);
 645                         memcpy(dst, src, todo);
 646                         dst += todo;
 647                         if (todo < remain) {
 648                                 cc->cc_offset += todo;
 649                                 break;
 650                         }
 651                         size -= todo;
 652                         cc->cc_iov++;
 653                         cc->cc_offset = 0;
 654                         if (size == 0)
 655                                 break;
 656                 }
 657                 break;
 658         default:
 659 #ifdef INVARIANTS
 660                 panic("%s: invalid buffer type %d", __func__, cc->cc_type);
 661 #endif
 662                 break;
 663         }
 664 }
 665
 666 /*
 667  * To avoid advancing 'cursor', make a local copy that gets advanced
 668  * instead.
 669  */
 670 void
 671 crypto_cursor_copydata_noadv(struct crypto_buffer_cursor *cc, int size,
 672     void *vdst)
 673 {
 674         struct crypto_buffer_cursor copy;
 675
 676         copy = *cc;
 677         crypto_cursor_copydata(&copy, size, vdst);
 678 }
 679
 680 /*
 681  * Apply function f to the data in an iovec list starting "off" bytes from
 682  * the beginning, continuing for "len" bytes.
 683  */
 684 static int
 685 cuio_apply(struct uio *uio, int off, int len,
 686     int (*f)(void *, const void *, u_int), void *arg)
 687 {
 688         struct iovec *iov = uio->uio_iov;
 689         int iol = uio->uio_iovcnt;
 690         unsigned count;
 691         int rval;
 692
 693         CUIO_SKIP();
 694         while (len > 0) {
 695                 KASSERT(iol >= 0, ("%s: empty", __func__));
 696                 count = min(iov->iov_len - off, len);
 697                 rval = (*f)(arg, ((caddr_t)iov->iov_base) + off, count);
 698                 if (rval)
 699                         return (rval);
 700                 len -= count;
 701                 off = 0;
 702                 iol--;
 703                 iov++;
 704         }
 705         return (0);
 706 }
 707
 708 void
 709 crypto_copyback(struct cryptop *crp, int off, int size, const void *src)
 710 {
 711         struct crypto_buffer *cb;
 712
 713         if (crp->crp_obuf.cb_type != CRYPTO_BUF_NONE)
 714                 cb = &crp->crp_obuf;
 715         else
 716                 cb = &crp->crp_buf;
 717         switch (cb->cb_type) {
 718         case CRYPTO_BUF_MBUF:
 719         case CRYPTO_BUF_SINGLE_MBUF:
 720                 m_copyback(cb->cb_mbuf, off, size, src);
 721                 break;
 722 #if CRYPTO_MAY_HAVE_VMPAGE
 723         case CRYPTO_BUF_VMPAGE:
 724                 MPASS(size <= cb->cb_vm_page_len);
 725                 MPASS(size + off <=
 726                     cb->cb_vm_page_len + cb->cb_vm_page_offset);
 727                 cvm_page_copyback(cb->cb_vm_page,
 728                     off + cb->cb_vm_page_offset, size, src);
 729                 break;
 730 #endif /* CRYPTO_MAY_HAVE_VMPAGE */
 731         case CRYPTO_BUF_UIO:
 732                 cuio_copyback(cb->cb_uio, off, size, src);
 733                 break;
 734         case CRYPTO_BUF_CONTIG:
 735                 MPASS(off + size <= cb->cb_buf_len);
 736                 bcopy(src, cb->cb_buf + off, size);
 737                 break;
 738         default:
 739 #ifdef INVARIANTS
 740                 panic("invalid crp buf type %d", cb->cb_type);
 741 #endif
 742                 break;
 743         }
 744 }
 745
 746 void
 747 crypto_copydata(struct cryptop *crp, int off, int size, void *dst)
 748 {
 749
 750         switch (crp->crp_buf.cb_type) {
 751         case CRYPTO_BUF_MBUF:
 752         case CRYPTO_BUF_SINGLE_MBUF:
 753                 m_copydata(crp->crp_buf.cb_mbuf, off, size, dst);
 754                 break;
 755 #if CRYPTO_MAY_HAVE_VMPAGE
 756         case CRYPTO_BUF_VMPAGE:
 757                 MPASS(size <= crp->crp_buf.cb_vm_page_len);
 758                 MPASS(size + off <= crp->crp_buf.cb_vm_page_len +
 759                     crp->crp_buf.cb_vm_page_offset);
 760                 cvm_page_copydata(crp->crp_buf.cb_vm_page,
 761                     off + crp->crp_buf.cb_vm_page_offset, size, dst);
 762                 break;
 763 #endif /* CRYPTO_MAY_HAVE_VMPAGE */
 764         case CRYPTO_BUF_UIO:
 765                 cuio_copydata(crp->crp_buf.cb_uio, off, size, dst);
 766                 break;
 767         case CRYPTO_BUF_CONTIG:
 768                 MPASS(off + size <= crp->crp_buf.cb_buf_len);
 769                 bcopy(crp->crp_buf.cb_buf + off, dst, size);
 770                 break;
 771         default:
 772 #ifdef INVARIANTS
 773                 panic("invalid crp buf type %d", crp->crp_buf.cb_type);
 774 #endif
 775                 break;
 776         }
 777 }
 778
 779 int
 780 crypto_apply_buf(struct crypto_buffer *cb, int off, int len,
 781     int (*f)(void *, const void *, u_int), void *arg)
 782 {
 783         int error;
 784
 785         switch (cb->cb_type) {
 786         case CRYPTO_BUF_MBUF:
 787         case CRYPTO_BUF_SINGLE_MBUF:
 788                 error = m_apply(cb->cb_mbuf, off, len,
 789                     (int (*)(void *, void *, u_int))f, arg);
 790                 break;
 791         case CRYPTO_BUF_UIO:
 792                 error = cuio_apply(cb->cb_uio, off, len, f, arg);
 793                 break;
 794 #if CRYPTO_MAY_HAVE_VMPAGE
 795         case CRYPTO_BUF_VMPAGE:
 796                 error = cvm_page_apply(cb->cb_vm_page,
 797                     off + cb->cb_vm_page_offset, len, f, arg);
 798                 break;
 799 #endif /* CRYPTO_MAY_HAVE_VMPAGE */
 800         case CRYPTO_BUF_CONTIG:
 801                 MPASS(off + len <= cb->cb_buf_len);
 802                 error = (*f)(arg, cb->cb_buf + off, len);
 803                 break;
 804         default:
 805 #ifdef INVARIANTS
 806                 panic("invalid crypto buf type %d", cb->cb_type);
 807 #endif
 808                 error = 0;
 809                 break;
 810         }
 811         return (error);
 812 }
 813
 814 int
 815 crypto_apply(struct cryptop *crp, int off, int len,
 816     int (*f)(void *, const void *, u_int), void *arg)
 817 {
 818         return (crypto_apply_buf(&crp->crp_buf, off, len, f, arg));
 819 }
 820
 821 static inline void *
 822 m_contiguous_subsegment(struct mbuf *m, size_t skip, size_t len)
 823 {
 824         int rel_off;
 825
 826         MPASS(skip <= INT_MAX);
 827
 828         m = m_getptr(m, (int)skip, &rel_off);
 829         if (m == NULL)
 830                 return (NULL);
 831
 832         MPASS(rel_off >= 0);
 833         skip = rel_off;
 834         if (skip + len > m->m_len)
 835                 return (NULL);
 836
 837         if (m->m_flags & M_EXTPG)
 838                 return (m_epg_contiguous_subsegment(m, skip, len));
 839         return (mtod(m, char*) + skip);
 840 }
 841
 842 static inline void *
 843 cuio_contiguous_segment(struct uio *uio, size_t skip, size_t len)
 844 {
 845         int rel_off, idx;
 846
 847         MPASS(skip <= INT_MAX);
 848         idx = cuio_getptr(uio, (int)skip, &rel_off);
 849         if (idx < 0)
 850                 return (NULL);
 851
 852         MPASS(rel_off >= 0);
 853         skip = rel_off;
 854         if (skip + len > uio->uio_iov[idx].iov_len)
 855                 return (NULL);
 856         return ((char *)uio->uio_iov[idx].iov_base + skip);
 857 }
 858
 859 void *
 860 crypto_buffer_contiguous_subsegment(struct crypto_buffer *cb, size_t skip,
 861     size_t len)
 862 {
 863
 864         switch (cb->cb_type) {
 865         case CRYPTO_BUF_MBUF:
 866         case CRYPTO_BUF_SINGLE_MBUF:
 867                 return (m_contiguous_subsegment(cb->cb_mbuf, skip, len));
 868         case CRYPTO_BUF_UIO:
 869                 return (cuio_contiguous_segment(cb->cb_uio, skip, len));
 870 #if CRYPTO_MAY_HAVE_VMPAGE
 871         case CRYPTO_BUF_VMPAGE:
 872                 MPASS(skip + len <= cb->cb_vm_page_len);
 873                 return (cvm_page_contiguous_segment(cb->cb_vm_page,
 874                     skip + cb->cb_vm_page_offset, len));
 875 #endif /* CRYPTO_MAY_HAVE_VMPAGE */
 876         case CRYPTO_BUF_CONTIG:
 877                 MPASS(skip + len <= cb->cb_buf_len);
 878                 return (cb->cb_buf + skip);
 879         default:
 880 #ifdef INVARIANTS
 881                 panic("invalid crp buf type %d", cb->cb_type);
 882 #endif
 883                 return (NULL);
 884         }
 885 }
 886
 887 void *
 888 crypto_contiguous_subsegment(struct cryptop *crp, size_t skip, size_t len)
 889 {
 890         return (crypto_buffer_contiguous_subsegment(&crp->crp_buf, skip, len));
 891 }