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$"); 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 } 315