sys/dev/dmover/swdmover.c

   1 /*      $NetBSD: swdmover.c,v 1.11 2007/07/12 14:15:55 he Exp $ */
   2
   3 /*
   4  * Copyright (c) 2002, 2003 Wasabi Systems, Inc.
   5  * All rights reserved.
   6  *
   7  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed for the NetBSD Project by
  20  *      Wasabi Systems, Inc.
  21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  22  *    or promote products derived from this software without specific prior
  23  *    written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 /*
  39  * swdmover.c: Software back-end providing the dmover functions
  40  * mentioned in dmover(9).
  41  *
  42  * This module provides a fallback for cases where no hardware
  43  * data movers are present in a system, and also serves an an
  44  * example of how to write a dmover back-end.
  45  *
  46  * Note that even through the software dmover doesn't require
  47  * interrupts to be blocked, we block them anyway to demonstrate
  48  * the locking protocol.
  49  */
  50
  51 #include <sys/cdefs.h>
  52 __KERNEL_RCSID(0, "$NetBSD: swdmover.c,v 1.11 2007/07/12 14:15:55 he Exp $");
  53
  54 #include <sys/param.h>
  55 #include <sys/kthread.h>
  56 #include <sys/systm.h>
  57 #include <sys/uio.h>
  58
  59 #include <dev/dmover/dmovervar.h>
  60
  61 struct swdmover_function {
  62         void    (*sdf_process)(struct dmover_request *);
  63 };
  64
  65 static struct dmover_backend swdmover_backend;
  66 static struct lwp *swdmover_lwp;
  67 static int swdmover_cv;
  68
  69 void    swdmoverattach(int);
  70
  71 /*
  72  * swdmover_process:
  73  *
  74  *      Dmover back-end entry point.
  75  */
  76 static void
  77 swdmover_process(struct dmover_backend *dmb)
  78 {
  79         int s;
  80
  81         /*
  82          * Just wake up the processing thread.  This will allow
  83          * requests to linger on the middle-end's queue so that
  84          * they can be cancelled, if need-be.
  85          */
  86         s = splbio();
  87         /* XXXLOCK */
  88         if (TAILQ_EMPTY(&dmb->dmb_pendreqs) == 0)
  89                 wakeup(&swdmover_cv);
  90         /* XXXUNLOCK */
  91         splx(s);
  92 }
  93
  94 /*
  95  * swdmover_thread:
  96  *
  97  *      Request processing thread.
  98  */
  99 static void
 100 swdmover_thread(void *arg)
 101 {
 102         struct dmover_backend *dmb = arg;
 103         struct dmover_request *dreq;
 104         struct swdmover_function *sdf;
 105         int s;
 106
 107         s = splbio();
 108         /* XXXLOCK */
 109
 110         for (;;) {
 111                 dreq = TAILQ_FIRST(&dmb->dmb_pendreqs);
 112                 if (dreq == NULL) {
 113                         /* XXXUNLOCK */
 114                         (void) tsleep(&swdmover_cv, PRIBIO, "swdmvr", 0);
 115                         continue;
 116                 }
 117
 118                 dmover_backend_remque(dmb, dreq);
 119                 dreq->dreq_flags |= DMOVER_REQ_RUNNING;
 120
 121                 /* XXXUNLOCK */
 122                 splx(s);
 123
 124                 sdf = dreq->dreq_assignment->das_algdesc->dad_data;
 125                 (*sdf->sdf_process)(dreq);
 126
 127                 s = splbio();
 128                 /* XXXLOCK */
 129         }
 130 }
 131
 132 /*
 133  * swdmover_func_zero_process:
 134  *
 135  *      Processing routine for the "zero" function.
 136  */
 137 static void
 138 swdmover_func_zero_process(struct dmover_request *dreq)
 139 {
 140
 141         switch (dreq->dreq_outbuf_type) {
 142         case DMOVER_BUF_LINEAR:
 143                 memset(dreq->dreq_outbuf.dmbuf_linear.l_addr, 0,
 144                     dreq->dreq_outbuf.dmbuf_linear.l_len);
 145                 break;
 146
 147         case DMOVER_BUF_UIO:
 148             {
 149                 struct uio *uio = dreq->dreq_outbuf.dmbuf_uio;
 150                 char *cp;
 151                 size_t count, buflen;
 152                 int error;
 153
 154                 if (uio->uio_rw != UIO_READ) {
 155                         /* XXXLOCK */
 156                         dreq->dreq_error = EINVAL;
 157                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 158                         /* XXXUNLOCK */
 159                         break;
 160                 }
 161
 162                 buflen = uio->uio_resid;
 163                 if (buflen > 1024)
 164                         buflen = 1024;
 165                 cp = alloca(buflen);
 166                 memset(cp, 0, buflen);
 167
 168                 while ((count = uio->uio_resid) != 0) {
 169                         if (count > buflen)
 170                                 count = buflen;
 171                         error = uiomove(cp, count, uio);
 172                         if (error) {
 173                                 /* XXXLOCK */
 174                                 dreq->dreq_error = error;
 175                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 176                                 /* XXXUNLOCK */
 177                                 break;
 178                         }
 179                 }
 180                 break;
 181             }
 182
 183         default:
 184                 /* XXXLOCK */
 185                 dreq->dreq_error = EINVAL;
 186                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 187                 /* XXXUNLOCK */
 188         }
 189
 190         dmover_done(dreq);
 191 }
 192
 193 /*
 194  * swdmover_func_fill8_process:
 195  *
 196  *      Processing routine for the "fill8" function.
 197  */
 198 static void
 199 swdmover_func_fill8_process(struct dmover_request *dreq)
 200 {
 201
 202         switch (dreq->dreq_outbuf_type) {
 203         case DMOVER_BUF_LINEAR:
 204                 memset(dreq->dreq_outbuf.dmbuf_linear.l_addr,
 205                     dreq->dreq_immediate[0],
 206                     dreq->dreq_outbuf.dmbuf_linear.l_len);
 207                 break;
 208
 209         case DMOVER_BUF_UIO:
 210             {
 211                 struct uio *uio = dreq->dreq_outbuf.dmbuf_uio;
 212                 char *cp;
 213                 size_t count, buflen;
 214                 int error;
 215
 216                 if (uio->uio_rw != UIO_READ) {
 217                         /* XXXLOCK */
 218                         dreq->dreq_error = EINVAL;
 219                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 220                         /* XXXUNLOCK */
 221                         break;
 222                 }
 223
 224                 buflen = uio->uio_resid;
 225                 if (buflen > 1024)
 226                         buflen = 1024;
 227                 cp = alloca(buflen);
 228                 memset(cp, dreq->dreq_immediate[0], buflen);
 229
 230                 while ((count = uio->uio_resid) != 0) {
 231                         if (count > buflen)
 232                                 count = buflen;
 233                         error = uiomove(cp, count, uio);
 234                         if (error) {
 235                                 /* XXXLOCK */
 236                                 dreq->dreq_error = error;
 237                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 238                                 /* XXXUNLOCK */
 239                                 break;
 240                         }
 241                 }
 242                 break;
 243             }
 244
 245         default:
 246                 /* XXXLOCK */
 247                 dreq->dreq_error = EINVAL;
 248                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 249                 /* XXXUNLOCK */
 250         }
 251
 252         dmover_done(dreq);
 253 }
 254
 255 static void
 256 xor2(uint8_t *dst, uint8_t *src1, uint8_t *src2, int cnt)
 257 {
 258
 259         while (cnt--)
 260                 *dst++ = *src1++ ^ *src2++;
 261 }
 262
 263 /*
 264  * swdmover_func_xor_process:
 265  *
 266  *      Processing routine for the "xor" function.
 267  */
 268 static void
 269 swdmover_func_xor_process(struct dmover_request *dreq)
 270 {
 271 #define INBUF_L(x)      dreq->dreq_inbuf[(x)].dmbuf_linear
 272 #define OUTBUF_L        dreq->dreq_outbuf.dmbuf_linear
 273
 274         uint32_t *dst32, *src32;
 275         uint8_t *dst8, *src8;
 276         int     i, ninputs = dreq->dreq_assignment->das_algdesc->dad_ninputs;
 277         int     aligned, len, nwords;
 278
 279         /* XXX Currently, both buffers must be of same type. */
 280         if (dreq->dreq_inbuf_type != dreq->dreq_outbuf_type) {
 281                 /* XXXLOCK */
 282                 dreq->dreq_error = EINVAL;
 283                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 284                 /* XXXUNLOCK */
 285                 goto done;
 286         }
 287
 288         switch (dreq->dreq_outbuf_type) {
 289         case DMOVER_BUF_LINEAR:
 290                 aligned = 1;
 291                 if ((ulong) OUTBUF_L.l_addr & 0x3)
 292                         aligned = 0;
 293                 len = OUTBUF_L.l_len;
 294                 for (i = 0 ; i < ninputs ; i++) {
 295                         if (len != INBUF_L(i).l_len) {
 296                                 /* XXXLOCK */
 297                                 dreq->dreq_error = EINVAL;
 298                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 299                                 /* XXXUNLOCK */
 300                                 break;
 301                         }
 302                         if ((ulong) INBUF_L(i).l_addr & 0x3)
 303                                 aligned = 0;
 304                 }
 305                 if (aligned) {
 306                         dst32 = (uint32_t *) OUTBUF_L.l_addr;
 307                         nwords = len / 4;
 308                         while (nwords--) {
 309                                 *dst32 = 0;
 310                                 for (i = 0 ; i < ninputs ; i++) {
 311                                         src32 = (uint32_t *) INBUF_L(i).l_addr;
 312                                         *dst32 ^= *src32;
 313                                 }
 314                                 dst32++;
 315                                 len -= 4;
 316                         }
 317                 }
 318                 if (len) {
 319                         dst8 = (uint8_t *) OUTBUF_L.l_addr;
 320                         while (len--) {
 321                                 *dst8 = 0;
 322                                 for (i = 0 ; i < ninputs ; i++) {
 323                                         src8 = (uint8_t *) INBUF_L(i).l_addr;
 324                                         *dst8 ^= *src8;
 325                                 }
 326                                 dst8++;
 327                         }
 328                 }
 329
 330                 break;
 331
 332         case DMOVER_BUF_UIO:
 333             {
 334                 struct uio *uio_out = dreq->dreq_outbuf.dmbuf_uio;
 335                 struct uio *uio_in = dreq->dreq_inbuf[0].dmbuf_uio;
 336                 struct uio *uio;
 337                 char *cp, *dst;
 338                 size_t count, buflen;
 339                 int error;
 340
 341                 if (uio_in->uio_rw != UIO_WRITE ||
 342                     uio_out->uio_rw != UIO_READ ||
 343                     uio_in->uio_resid != uio_out->uio_resid) {
 344                         /* XXXLOCK */
 345                         dreq->dreq_error = EINVAL;
 346                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 347                         /* XXXUNLOCK */
 348                         break;
 349                 }
 350
 351                 buflen = uio_in->uio_resid;
 352                 if (buflen > 1024)
 353                         buflen = 1024;
 354                 cp = alloca(buflen);
 355                 dst = alloca(buflen);
 356
 357                 /*
 358                  * For each block, copy first input buffer into the destination
 359                  * buffer and then read the rest, one by one, into a temporary
 360                  * buffer and xor into the destination buffer.  After all of
 361                  * the inputs have been xor'd in, move the destination buffer
 362                  * out and loop.
 363                  */
 364                 while ((count = uio_in->uio_resid) != 0) {
 365                         if (count > buflen)
 366                                 count = buflen;
 367                         error = uiomove(dst, count, uio_in);
 368                         if (error) {
 369                                 /* XXXLOCK */
 370                                 dreq->dreq_error = error;
 371                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 372                                 /* XXXUNLOCK */
 373                                 break;
 374                         }
 375                         for (i=1 ; (i < ninputs) && (error == 0) ; i++) {
 376                                 uio = dreq->dreq_inbuf[i].dmbuf_uio;
 377                                 error = uiomove(cp, count, uio);
 378                                 if (error == 0) {
 379                                         xor2(dst, dst, cp, count);
 380                                 }
 381                         }
 382                         if (error == 0) {
 383                                 error = uiomove(dst, count, uio_out);
 384                         } else {
 385                                 /* XXXLOCK */
 386                                 dreq->dreq_error = error;
 387                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 388                                 /* XXXUNLOCK */
 389                                 break;
 390                         }
 391                 }
 392                 break;
 393             }
 394
 395         default:
 396                 /* XXXLOCK */
 397                 dreq->dreq_error = EINVAL;
 398                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 399                 /* XXXUNLOCK */
 400         }
 401
 402  done:
 403         dmover_done(dreq);
 404 }
 405
 406 /*
 407  * swdmover_func_copy_process:
 408  *
 409  *      Processing routine for the "copy" function.
 410  */
 411 static void
 412 swdmover_func_copy_process(struct dmover_request *dreq)
 413 {
 414
 415         /* XXX Currently, both buffers must be of same type. */
 416         if (dreq->dreq_inbuf_type != dreq->dreq_outbuf_type) {
 417                 /* XXXLOCK */
 418                 dreq->dreq_error = EINVAL;
 419                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 420                 /* XXXUNLOCK */
 421                 goto done;
 422         }
 423
 424         switch (dreq->dreq_outbuf_type) {
 425         case DMOVER_BUF_LINEAR:
 426                 if (dreq->dreq_outbuf.dmbuf_linear.l_len !=
 427                     dreq->dreq_inbuf[0].dmbuf_linear.l_len) {
 428                         /* XXXLOCK */
 429                         dreq->dreq_error = EINVAL;
 430                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 431                         /* XXXUNLOCK */
 432                         break;
 433                 }
 434                 memcpy(dreq->dreq_outbuf.dmbuf_linear.l_addr,
 435                     dreq->dreq_inbuf[0].dmbuf_linear.l_addr,
 436                     dreq->dreq_outbuf.dmbuf_linear.l_len);
 437                 break;
 438
 439         case DMOVER_BUF_UIO:
 440             {
 441                 struct uio *uio_out = dreq->dreq_outbuf.dmbuf_uio;
 442                 struct uio *uio_in = dreq->dreq_inbuf[0].dmbuf_uio;
 443                 char *cp;
 444                 size_t count, buflen;
 445                 int error;
 446
 447                 if (uio_in->uio_rw != UIO_WRITE ||
 448                     uio_out->uio_rw != UIO_READ ||
 449                     uio_in->uio_resid != uio_out->uio_resid) {
 450                         /* XXXLOCK */
 451                         dreq->dreq_error = EINVAL;
 452                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 453                         /* XXXUNLOCK */
 454                         break;
 455                 }
 456
 457                 buflen = uio_in->uio_resid;
 458                 if (buflen > 1024)
 459                         buflen = 1024;
 460                 cp = alloca(buflen);
 461
 462                 while ((count = uio_in->uio_resid) != 0) {
 463                         if (count > buflen)
 464                                 count = buflen;
 465                         error = uiomove(cp, count, uio_in);
 466                         if (error == 0)
 467                                 error = uiomove(cp, count, uio_out);
 468                         if (error) {
 469                                 /* XXXLOCK */
 470                                 dreq->dreq_error = error;
 471                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 472                                 /* XXXUNLOCK */
 473                                 break;
 474                         }
 475                 }
 476                 break;
 477             }
 478
 479         default:
 480                 /* XXXLOCK */
 481                 dreq->dreq_error = EINVAL;
 482                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 483                 /* XXXUNLOCK */
 484         }
 485
 486  done:
 487         dmover_done(dreq);
 488 }
 489
 490 static const uint32_t iscsi_crc32c_table[256] = {
 491         0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
 492         0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
 493         0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
 494         0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
 495         0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b,
 496         0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
 497         0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54,
 498         0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
 499         0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
 500         0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
 501         0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5,
 502         0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
 503         0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45,
 504         0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
 505         0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
 506         0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
 507         0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48,
 508         0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
 509         0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687,
 510         0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
 511         0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
 512         0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
 513         0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8,
 514         0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
 515         0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096,
 516         0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
 517         0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
 518         0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
 519         0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9,
 520         0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
 521         0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36,
 522         0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
 523         0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
 524         0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
 525         0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043,
 526         0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
 527         0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3,
 528         0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
 529         0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
 530         0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
 531         0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652,
 532         0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
 533         0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d,
 534         0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
 535         0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
 536         0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
 537         0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2,
 538         0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
 539         0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530,
 540         0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
 541         0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
 542         0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
 543         0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f,
 544         0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
 545         0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90,
 546         0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
 547         0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
 548         0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
 549         0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321,
 550         0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
 551         0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81,
 552         0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
 553         0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
 554         0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
 555 };
 556
 557 static uint32_t
 558 iscsi_crc32c(const uint8_t *buf, size_t len, uint32_t last)
 559 {
 560         uint32_t crc = 0xffffffffU ^ last;
 561
 562         while (len--)
 563                 crc = iscsi_crc32c_table[(crc ^ *buf++) & 0xff] ^ (crc >> 8);
 564
 565         return (crc ^ 0xffffffffU);
 566 }
 567
 568 /*
 569  * swdmover_func_iscsi_crc32c_process:
 570  *
 571  *      Processing routine for the "iscsi-crc32c" function.
 572  */
 573 static void
 574 swdmover_func_iscsi_crc32c_process(struct dmover_request *dreq)
 575 {
 576         uint32_t result;
 577
 578         /* No output buffer; we use the immediate only. */
 579         if (dreq->dreq_outbuf_type != DMOVER_BUF_NONE) {
 580                 /* XXXLOCK */
 581                 dreq->dreq_error = EINVAL;
 582                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 583                 /* XXXUNLOCK */
 584                 goto done;
 585         }
 586
 587         memcpy(&result, dreq->dreq_immediate, sizeof(result));
 588
 589         switch (dreq->dreq_inbuf_type) {
 590         case DMOVER_BUF_LINEAR:
 591                 result = iscsi_crc32c(dreq->dreq_inbuf[0].dmbuf_linear.l_addr,
 592                     dreq->dreq_inbuf[0].dmbuf_linear.l_len, result);
 593                 break;
 594
 595         case DMOVER_BUF_UIO:
 596             {
 597                 struct uio *uio_in = dreq->dreq_inbuf[0].dmbuf_uio;
 598                 uint8_t *cp;
 599                 size_t count, buflen;
 600                 int error;
 601
 602                 if (uio_in->uio_rw != UIO_WRITE) {
 603                         /* XXXLOCK */
 604                         dreq->dreq_error = EINVAL;
 605                         dreq->dreq_flags |= DMOVER_REQ_ERROR;
 606                         /* XXXUNLOCK */
 607                         goto done;
 608                 }
 609
 610                 buflen = uio_in->uio_resid;
 611                 if (buflen > 1024)
 612                         buflen = 1024;
 613                 cp = alloca(buflen);
 614
 615                 while ((count = uio_in->uio_resid) != 0) {
 616                         if (count > buflen)
 617                                 count = buflen;
 618                         error = uiomove(cp, count, uio_in);
 619                         if (error) {
 620                                 /* XXXLOCK */
 621                                 dreq->dreq_error = error;
 622                                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 623                                 /* XXXUNLOCK */
 624                                 goto done;
 625                         } else
 626                                 result = iscsi_crc32c(cp, count, result);
 627                 }
 628                 break;
 629             }
 630
 631         default:
 632                 /* XXXLOCK */
 633                 dreq->dreq_error = EINVAL;
 634                 dreq->dreq_flags |= DMOVER_REQ_ERROR;
 635                 /* XXXUNLOCK */
 636                 goto done;
 637         }
 638
 639         memcpy(dreq->dreq_immediate, &result, sizeof(result));
 640  done:
 641         dmover_done(dreq);
 642 }
 643
 644 static struct swdmover_function swdmover_func_zero = {
 645         swdmover_func_zero_process
 646 };
 647
 648 static struct swdmover_function swdmover_func_fill8 = {
 649         swdmover_func_fill8_process
 650 };
 651
 652 static struct swdmover_function swdmover_func_copy = {
 653         swdmover_func_copy_process
 654 };
 655
 656 static struct swdmover_function swdmover_func_xor = {
 657         swdmover_func_xor_process
 658 };
 659
 660 static struct swdmover_function swdmover_func_iscsi_crc32c = {
 661         swdmover_func_iscsi_crc32c_process
 662 };
 663
 664 const struct dmover_algdesc swdmover_algdescs[] = {
 665         {
 666           DMOVER_FUNC_XOR2,
 667           &swdmover_func_xor,
 668           2
 669         },
 670         {
 671           DMOVER_FUNC_XOR3,
 672           &swdmover_func_xor,
 673           3
 674         },
 675         {
 676           DMOVER_FUNC_XOR4,
 677           &swdmover_func_xor,
 678           4
 679         },
 680         {
 681           DMOVER_FUNC_XOR5,
 682           &swdmover_func_xor,
 683           5
 684         },
 685         {
 686           DMOVER_FUNC_XOR6,
 687           &swdmover_func_xor,
 688           6
 689         },
 690         {
 691           DMOVER_FUNC_XOR7,
 692           &swdmover_func_xor,
 693           7
 694         },
 695         {
 696           DMOVER_FUNC_XOR8,
 697           &swdmover_func_xor,
 698           8
 699         },
 700         {
 701           DMOVER_FUNC_ZERO,
 702           &swdmover_func_zero,
 703           0
 704         },
 705         {
 706           DMOVER_FUNC_FILL8,
 707           &swdmover_func_fill8,
 708           0
 709         },
 710         {
 711           DMOVER_FUNC_COPY,
 712           &swdmover_func_copy,
 713           1
 714         },
 715         {
 716           DMOVER_FUNC_ISCSI_CRC32C,
 717           &swdmover_func_iscsi_crc32c,
 718           1,
 719         },
 720 };
 721 #define SWDMOVER_ALGDESC_COUNT \
 722         (sizeof(swdmover_algdescs) / sizeof(swdmover_algdescs[0]))
 723
 724 /*
 725  * swdmoverattach:
 726  *
 727  *      Pesudo-device attach routine.
 728  */
 729 void
 730 swdmoverattach(int count)
 731 {
 732         int error;
 733
 734         swdmover_backend.dmb_name = "swdmover";
 735         swdmover_backend.dmb_speed = 1;         /* XXX */
 736         swdmover_backend.dmb_cookie = NULL;
 737         swdmover_backend.dmb_algdescs = swdmover_algdescs;
 738         swdmover_backend.dmb_nalgdescs = SWDMOVER_ALGDESC_COUNT;
 739         swdmover_backend.dmb_process = swdmover_process;
 740
 741         error = kthread_create(PRI_NONE, 0, NULL, swdmover_thread,
 742             &swdmover_backend, &swdmover_lwp, "swdmover");
 743         if (error)
 744                 printf("WARNING: unable to create swdmover thread, "
 745                     "error = %d\n", error);
 746
 747         /* XXX Should only register this when kthread creation succeeds. */
 748         dmover_backend_register(&swdmover_backend);
 749 }