g_eli_privacy.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2005-2011 Pawel Jakub Dawidek <pawel@dawidek.net>
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD: releng/11.2/sys/geom/eli/g_eli_privacy.c 286373 2015-08-06 17:13:34Z pjd $");
   29 
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/kernel.h>
   33 #include <sys/linker.h>
   34 #include <sys/module.h>
   35 #include <sys/lock.h>
   36 #include <sys/mutex.h>
   37 #include <sys/bio.h>
   38 #include <sys/sysctl.h>
   39 #include <sys/malloc.h>
   40 #include <sys/kthread.h>
   41 #include <sys/proc.h>
   42 #include <sys/sched.h>
   43 #include <sys/smp.h>
   44 #include <sys/vnode.h>
   45 
   46 #include <vm/uma.h>
   47 
   48 #include <geom/geom.h>
   49 #include <geom/eli/g_eli.h>
   50 #include <geom/eli/pkcs5v2.h>
   51 
   52 /*
   53  * Code paths:
   54  * BIO_READ:
   55  *      g_eli_start -> g_eli_crypto_read -> g_io_request -> g_eli_read_done -> g_eli_crypto_run -> g_eli_crypto_read_done -> g_io_deliver
   56  * BIO_WRITE:
   57  *      g_eli_start -> g_eli_crypto_run -> g_eli_crypto_write_done -> g_io_request -> g_eli_write_done -> g_io_deliver
   58  */
   59 
   60 MALLOC_DECLARE(M_ELI);
   61 
   62 /*
   63  * The function is called after we read and decrypt data.
   64  *
   65  * g_eli_start -> g_eli_crypto_read -> g_io_request -> g_eli_read_done -> g_eli_crypto_run -> G_ELI_CRYPTO_READ_DONE -> g_io_deliver
   66  */
   67 static int
   68 g_eli_crypto_read_done(struct cryptop *crp)
   69 {
   70         struct g_eli_softc *sc;
   71         struct bio *bp;
   72 
   73         if (crp->crp_etype == EAGAIN) {
   74                 if (g_eli_crypto_rerun(crp) == 0)
   75                         return (0);
   76         }
   77         bp = (struct bio *)crp->crp_opaque;
   78         bp->bio_inbed++;
   79         if (crp->crp_etype == 0) {
   80                 G_ELI_DEBUG(3, "Crypto READ request done (%d/%d).",
   81                     bp->bio_inbed, bp->bio_children);
   82                 bp->bio_completed += crp->crp_olen;
   83         } else {
   84                 G_ELI_DEBUG(1, "Crypto READ request failed (%d/%d) error=%d.",
   85                     bp->bio_inbed, bp->bio_children, crp->crp_etype);
   86                 if (bp->bio_error == 0)
   87                         bp->bio_error = crp->crp_etype;
   88         }
   89         sc = bp->bio_to->geom->softc;
   90         g_eli_key_drop(sc, crp->crp_desc->crd_key);
   91         /*
   92          * Do we have all sectors already?
   93          */
   94         if (bp->bio_inbed < bp->bio_children)
   95                 return (0);
   96         free(bp->bio_driver2, M_ELI);
   97         bp->bio_driver2 = NULL;
   98         if (bp->bio_error != 0) {
   99                 G_ELI_LOGREQ(0, bp, "Crypto READ request failed (error=%d).",
  100                     bp->bio_error);
  101                 bp->bio_completed = 0;
  102         }
  103         /*
  104          * Read is finished, send it up.
  105          */
  106         g_io_deliver(bp, bp->bio_error);
  107         atomic_subtract_int(&sc->sc_inflight, 1);
  108         return (0);
  109 }
  110 
  111 /*
  112  * The function is called after data encryption.
  113  *
  114  * g_eli_start -> g_eli_crypto_run -> G_ELI_CRYPTO_WRITE_DONE -> g_io_request -> g_eli_write_done -> g_io_deliver
  115  */
  116 static int
  117 g_eli_crypto_write_done(struct cryptop *crp)
  118 {
  119         struct g_eli_softc *sc;
  120         struct g_geom *gp;
  121         struct g_consumer *cp;
  122         struct bio *bp, *cbp;
  123 
  124         if (crp->crp_etype == EAGAIN) {
  125                 if (g_eli_crypto_rerun(crp) == 0)
  126                         return (0);
  127         }
  128         bp = (struct bio *)crp->crp_opaque;
  129         bp->bio_inbed++;
  130         if (crp->crp_etype == 0) {
  131                 G_ELI_DEBUG(3, "Crypto WRITE request done (%d/%d).",
  132                     bp->bio_inbed, bp->bio_children);
  133         } else {
  134                 G_ELI_DEBUG(1, "Crypto WRITE request failed (%d/%d) error=%d.",
  135                     bp->bio_inbed, bp->bio_children, crp->crp_etype);
  136                 if (bp->bio_error == 0)
  137                         bp->bio_error = crp->crp_etype;
  138         }
  139         gp = bp->bio_to->geom;
  140         sc = gp->softc;
  141         g_eli_key_drop(sc, crp->crp_desc->crd_key);
  142         /*
  143          * All sectors are already encrypted?
  144          */
  145         if (bp->bio_inbed < bp->bio_children)
  146                 return (0);
  147         bp->bio_inbed = 0;
  148         bp->bio_children = 1;
  149         cbp = bp->bio_driver1;
  150         bp->bio_driver1 = NULL;
  151         if (bp->bio_error != 0) {
  152                 G_ELI_LOGREQ(0, bp, "Crypto WRITE request failed (error=%d).",
  153                     bp->bio_error);
  154                 free(bp->bio_driver2, M_ELI);
  155                 bp->bio_driver2 = NULL;
  156                 g_destroy_bio(cbp);
  157                 g_io_deliver(bp, bp->bio_error);
  158                 atomic_subtract_int(&sc->sc_inflight, 1);
  159                 return (0);
  160         }
  161         cbp->bio_data = bp->bio_driver2;
  162         cbp->bio_done = g_eli_write_done;
  163         cp = LIST_FIRST(&gp->consumer);
  164         cbp->bio_to = cp->provider;
  165         G_ELI_LOGREQ(2, cbp, "Sending request.");
  166         /*
  167          * Send encrypted data to the provider.
  168          */
  169         g_io_request(cbp, cp);
  170         return (0);
  171 }
  172 
  173 /*
  174  * The function is called to read encrypted data.
  175  *
  176  * g_eli_start -> G_ELI_CRYPTO_READ -> g_io_request -> g_eli_read_done -> g_eli_crypto_run -> g_eli_crypto_read_done -> g_io_deliver
  177  */
  178 void
  179 g_eli_crypto_read(struct g_eli_softc *sc, struct bio *bp, boolean_t fromworker)
  180 {
  181         struct g_consumer *cp;
  182         struct bio *cbp;
  183 
  184         if (!fromworker) {
  185                 /*
  186                  * We are not called from the worker thread, so check if
  187                  * device is suspended.
  188                  */
  189                 mtx_lock(&sc->sc_queue_mtx);
  190                 if (sc->sc_flags & G_ELI_FLAG_SUSPEND) {
  191                         /*
  192                          * If device is suspended, we place the request onto
  193                          * the queue, so it can be handled after resume.
  194                          */
  195                         G_ELI_DEBUG(0, "device suspended, move onto queue");
  196                         bioq_insert_tail(&sc->sc_queue, bp);
  197                         mtx_unlock(&sc->sc_queue_mtx);
  198                         wakeup(sc);
  199                         return;
  200                 }
  201                 atomic_add_int(&sc->sc_inflight, 1);
  202                 mtx_unlock(&sc->sc_queue_mtx);
  203         }
  204         bp->bio_pflags = 0;
  205         bp->bio_driver2 = NULL;
  206         cbp = bp->bio_driver1;
  207         cbp->bio_done = g_eli_read_done;
  208         cp = LIST_FIRST(&sc->sc_geom->consumer);
  209         cbp->bio_to = cp->provider;
  210         G_ELI_LOGREQ(2, cbp, "Sending request.");
  211         /*
  212          * Read encrypted data from provider.
  213          */
  214         g_io_request(cbp, cp);
  215 }
  216 
  217 /*
  218  * This is the main function responsible for cryptography (ie. communication
  219  * with crypto(9) subsystem).
  220  *
  221  * BIO_READ:
  222  *      g_eli_start -> g_eli_crypto_read -> g_io_request -> g_eli_read_done -> G_ELI_CRYPTO_RUN -> g_eli_crypto_read_done -> g_io_deliver
  223  * BIO_WRITE:
  224  *      g_eli_start -> G_ELI_CRYPTO_RUN -> g_eli_crypto_write_done -> g_io_request -> g_eli_write_done -> g_io_deliver
  225  */
  226 void
  227 g_eli_crypto_run(struct g_eli_worker *wr, struct bio *bp)
  228 {
  229         struct g_eli_softc *sc;
  230         struct cryptop *crp;
  231         struct cryptodesc *crd;
  232         u_int i, nsec, secsize;
  233         off_t dstoff;
  234         size_t size;
  235         u_char *p, *data;
  236         int error;
  237 
  238         G_ELI_LOGREQ(3, bp, "%s", __func__);
  239 
  240         bp->bio_pflags = wr->w_number;
  241         sc = wr->w_softc;
  242         secsize = LIST_FIRST(&sc->sc_geom->provider)->sectorsize;
  243         nsec = bp->bio_length / secsize;
  244 
  245         /*
  246          * Calculate how much memory do we need.
  247          * We need separate crypto operation for every single sector.
  248          * It is much faster to calculate total amount of needed memory here and
  249          * do the allocation once instead of allocating memory in pieces (many,
  250          * many pieces).
  251          */
  252         size = sizeof(*crp) * nsec;
  253         size += sizeof(*crd) * nsec;
  254         /*
  255          * If we write the data we cannot destroy current bio_data content,
  256          * so we need to allocate more memory for encrypted data.
  257          */
  258         if (bp->bio_cmd == BIO_WRITE)
  259                 size += bp->bio_length;
  260         p = malloc(size, M_ELI, M_WAITOK);
  261 
  262         bp->bio_inbed = 0;
  263         bp->bio_children = nsec;
  264         bp->bio_driver2 = p;
  265 
  266         if (bp->bio_cmd == BIO_READ)
  267                 data = bp->bio_data;
  268         else {
  269                 data = p;
  270                 p += bp->bio_length;
  271                 bcopy(bp->bio_data, data, bp->bio_length);
  272         }
  273 
  274         for (i = 0, dstoff = bp->bio_offset; i < nsec; i++, dstoff += secsize) {
  275                 crp = (struct cryptop *)p;      p += sizeof(*crp);
  276                 crd = (struct cryptodesc *)p;   p += sizeof(*crd);
  277 
  278                 crp->crp_sid = wr->w_sid;
  279                 crp->crp_ilen = secsize;
  280                 crp->crp_olen = secsize;
  281                 crp->crp_opaque = (void *)bp;
  282                 crp->crp_buf = (void *)data;
  283                 data += secsize;
  284                 if (bp->bio_cmd == BIO_WRITE)
  285                         crp->crp_callback = g_eli_crypto_write_done;
  286                 else /* if (bp->bio_cmd == BIO_READ) */
  287                         crp->crp_callback = g_eli_crypto_read_done;
  288                 crp->crp_flags = CRYPTO_F_CBIFSYNC;
  289                 if (g_eli_batch)
  290                         crp->crp_flags |= CRYPTO_F_BATCH;
  291                 crp->crp_desc = crd;
  292 
  293                 crd->crd_skip = 0;
  294                 crd->crd_len = secsize;
  295                 crd->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
  296                 if ((sc->sc_flags & G_ELI_FLAG_SINGLE_KEY) == 0)
  297                         crd->crd_flags |= CRD_F_KEY_EXPLICIT;
  298                 if (bp->bio_cmd == BIO_WRITE)
  299                         crd->crd_flags |= CRD_F_ENCRYPT;
  300                 crd->crd_alg = sc->sc_ealgo;
  301                 crd->crd_key = g_eli_key_hold(sc, dstoff, secsize);
  302                 crd->crd_klen = sc->sc_ekeylen;
  303                 if (sc->sc_ealgo == CRYPTO_AES_XTS)
  304                         crd->crd_klen <<= 1;
  305                 g_eli_crypto_ivgen(sc, dstoff, crd->crd_iv,
  306                     sizeof(crd->crd_iv));
  307                 crd->crd_next = NULL;
  308 
  309                 crp->crp_etype = 0;
  310                 error = crypto_dispatch(crp);
  311                 KASSERT(error == 0, ("crypto_dispatch() failed (error=%d)",
  312                     error));
  313         }
  314 }
Cache object: 5627146472bcfe0194cbc2d4e38205bf
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/geom/eli/g_eli_privacy.c

FreeBSD/Linux Kernel Cross Reference
sys/geom/eli/g_eli_privacy.c
