drivers/filesystems/btrfs/calcthread.c

   1 /* Copyright (c) Mark Harmstone 2016-17
   2  *
   3  * This file is part of WinBtrfs.
   4  *
   5  * WinBtrfs is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public Licence as published by
   7  * the Free Software Foundation, either version 3 of the Licence, or
   8  * (at your option) any later version.
   9  *
  10  * WinBtrfs is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser General Public Licence for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public Licence
  16  * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
  17
  18 #include "btrfs_drv.h"
  19 #include "xxhash.h"
  20 #include "crc32c.h"
  21
  22 void calc_thread_main(device_extension* Vcb, calc_job* cj) {
  23     while (true) {
  24         KIRQL irql;
  25         calc_job* cj2;
  26         uint8_t* src;
  27         void* dest;
  28         bool last_one = false;
  29
  30         KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
  31
  32         if (cj && cj->not_started == 0) {
  33             KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
  34             break;
  35         }
  36
  37         if (cj)
  38             cj2 = cj;
  39         else {
  40             if (IsListEmpty(&Vcb->calcthreads.job_list)) {
  41                 KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
  42                 break;
  43             }
  44
  45             cj2 = CONTAINING_RECORD(Vcb->calcthreads.job_list.Flink, calc_job, list_entry);
  46         }
  47
  48         src = cj2->in;
  49         dest = cj2->out;
  50
  51         switch (cj2->type) {
  52             case calc_thread_crc32c:
  53             case calc_thread_xxhash:
  54             case calc_thread_sha256:
  55             case calc_thread_blake2:
  56                 cj2->in = (uint8_t*)cj2->in + Vcb->superblock.sector_size;
  57                 cj2->out = (uint8_t*)cj2->out + Vcb->csum_size;
  58             break;
  59
  60             default:
  61                 break;
  62         }
  63
  64         cj2->not_started--;
  65
  66         if (cj2->not_started == 0) {
  67             RemoveEntryList(&cj2->list_entry);
  68             last_one = true;
  69         }
  70
  71         KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
  72
  73         switch (cj2->type) {
  74             case calc_thread_crc32c:
  75                 *(uint32_t*)dest = ~calc_crc32c(0xffffffff, src, Vcb->superblock.sector_size);
  76             break;
  77
  78             case calc_thread_xxhash:
  79                 *(uint64_t*)dest = XXH64(src, Vcb->superblock.sector_size, 0);
  80             break;
  81
  82             case calc_thread_sha256:
  83                 calc_sha256(dest, src, Vcb->superblock.sector_size);
  84             break;
  85
  86             case calc_thread_blake2:
  87                 blake2b(dest, BLAKE2_HASH_SIZE, src, Vcb->superblock.sector_size);
  88             break;
  89
  90             case calc_thread_decomp_zlib:
  91                 cj2->Status = zlib_decompress(src, cj2->inlen, dest, cj2->outlen);
  92
  93                 if (!NT_SUCCESS(cj2->Status))
  94                     ERR("zlib_decompress returned %08lx\n", cj2->Status);
  95             break;
  96
  97             case calc_thread_decomp_lzo:
  98                 cj2->Status = lzo_decompress(src, cj2->inlen, dest, cj2->outlen, cj2->off);
  99
 100                 if (!NT_SUCCESS(cj2->Status))
 101                     ERR("lzo_decompress returned %08lx\n", cj2->Status);
 102             break;
 103
 104             case calc_thread_decomp_zstd:
 105                 cj2->Status = zstd_decompress(src, cj2->inlen, dest, cj2->outlen);
 106
 107                 if (!NT_SUCCESS(cj2->Status))
 108                     ERR("zstd_decompress returned %08lx\n", cj2->Status);
 109             break;
 110
 111             case calc_thread_comp_zlib:
 112                 cj2->Status = zlib_compress(src, cj2->inlen, dest, cj2->outlen, Vcb->options.zlib_level, &cj2->space_left);
 113
 114                 if (!NT_SUCCESS(cj2->Status))
 115                     ERR("zlib_compress returned %08lx\n", cj2->Status);
 116             break;
 117
 118             case calc_thread_comp_lzo:
 119                 cj2->Status = lzo_compress(src, cj2->inlen, dest, cj2->outlen, &cj2->space_left);
 120
 121                 if (!NT_SUCCESS(cj2->Status))
 122                     ERR("lzo_compress returned %08lx\n", cj2->Status);
 123             break;
 124
 125             case calc_thread_comp_zstd:
 126                 cj2->Status = zstd_compress(src, cj2->inlen, dest, cj2->outlen, Vcb->options.zstd_level, &cj2->space_left);
 127
 128                 if (!NT_SUCCESS(cj2->Status))
 129                     ERR("zstd_compress returned %08lx\n", cj2->Status);
 130             break;
 131         }
 132
 133         if (InterlockedDecrement(&cj2->left) == 0)
 134             KeSetEvent(&cj2->event, 0, false);
 135
 136         if (last_one)
 137             break;
 138     }
 139 }
 140
 141 void do_calc_job(device_extension* Vcb, uint8_t* data, uint32_t sectors, void* csum) {
 142     KIRQL irql;
 143     calc_job cj;
 144
 145     cj.in = data;
 146     cj.out = csum;
 147     cj.left = cj.not_started = sectors;
 148
 149     switch (Vcb->superblock.csum_type) {
 150         case CSUM_TYPE_CRC32C:
 151             cj.type = calc_thread_crc32c;
 152         break;
 153
 154         case CSUM_TYPE_XXHASH:
 155             cj.type = calc_thread_xxhash;
 156         break;
 157
 158         case CSUM_TYPE_SHA256:
 159             cj.type = calc_thread_sha256;
 160         break;
 161
 162         case CSUM_TYPE_BLAKE2:
 163             cj.type = calc_thread_blake2;
 164         break;
 165     }
 166
 167     KeInitializeEvent(&cj.event, NotificationEvent, false);
 168
 169     KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
 170
 171     InsertTailList(&Vcb->calcthreads.job_list, &cj.list_entry);
 172
 173     KeSetEvent(&Vcb->calcthreads.event, 0, false);
 174     KeClearEvent(&Vcb->calcthreads.event);
 175
 176     KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
 177
 178     calc_thread_main(Vcb, &cj);
 179
 180     KeWaitForSingleObject(&cj.event, Executive, KernelMode, false, NULL);
 181 }
 182
 183 NTSTATUS add_calc_job_decomp(device_extension* Vcb, uint8_t compression, void* in, unsigned int inlen,
 184                              void* out, unsigned int outlen, unsigned int off, calc_job** pcj) {
 185     calc_job* cj;
 186     KIRQL irql;
 187
 188     cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
 189     if (!cj) {
 190         ERR("out of memory\n");
 191         return STATUS_INSUFFICIENT_RESOURCES;
 192     }
 193
 194     cj->in = in;
 195     cj->inlen = inlen;
 196     cj->out = out;
 197     cj->outlen = outlen;
 198     cj->off = off;
 199     cj->left = cj->not_started = 1;
 200     cj->Status = STATUS_SUCCESS;
 201
 202     switch (compression) {
 203         case BTRFS_COMPRESSION_ZLIB:
 204             cj->type = calc_thread_decomp_zlib;
 205         break;
 206
 207         case BTRFS_COMPRESSION_LZO:
 208             cj->type = calc_thread_decomp_lzo;
 209         break;
 210
 211         case BTRFS_COMPRESSION_ZSTD:
 212             cj->type = calc_thread_decomp_zstd;
 213         break;
 214
 215         default:
 216             ERR("unexpected compression type %x\n", compression);
 217             ExFreePool(cj);
 218         return STATUS_NOT_SUPPORTED;
 219     }
 220
 221     KeInitializeEvent(&cj->event, NotificationEvent, false);
 222
 223     KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
 224
 225     InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
 226
 227     KeSetEvent(&Vcb->calcthreads.event, 0, false);
 228     KeClearEvent(&Vcb->calcthreads.event);
 229
 230     KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
 231
 232     *pcj = cj;
 233
 234     return STATUS_SUCCESS;
 235 }
 236
 237 NTSTATUS add_calc_job_comp(device_extension* Vcb, uint8_t compression, void* in, unsigned int inlen,
 238                            void* out, unsigned int outlen, calc_job** pcj) {
 239     calc_job* cj;
 240     KIRQL irql;
 241
 242     cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
 243     if (!cj) {
 244         ERR("out of memory\n");
 245         return STATUS_INSUFFICIENT_RESOURCES;
 246     }
 247
 248     cj->in = in;
 249     cj->inlen = inlen;
 250     cj->out = out;
 251     cj->outlen = outlen;
 252     cj->left = cj->not_started = 1;
 253     cj->Status = STATUS_SUCCESS;
 254
 255     switch (compression) {
 256         case BTRFS_COMPRESSION_ZLIB:
 257             cj->type = calc_thread_comp_zlib;
 258         break;
 259
 260         case BTRFS_COMPRESSION_LZO:
 261             cj->type = calc_thread_comp_lzo;
 262         break;
 263
 264         case BTRFS_COMPRESSION_ZSTD:
 265             cj->type = calc_thread_comp_zstd;
 266         break;
 267
 268         default:
 269             ERR("unexpected compression type %x\n", compression);
 270             ExFreePool(cj);
 271         return STATUS_NOT_SUPPORTED;
 272     }
 273
 274     KeInitializeEvent(&cj->event, NotificationEvent, false);
 275
 276     KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
 277
 278     InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
 279
 280     KeSetEvent(&Vcb->calcthreads.event, 0, false);
 281     KeClearEvent(&Vcb->calcthreads.event);
 282
 283     KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
 284
 285     *pcj = cj;
 286
 287     return STATUS_SUCCESS;
 288 }
 289
 290 _Function_class_(KSTART_ROUTINE)
 291 void __stdcall calc_thread(void* context) {
 292     drv_calc_thread* thread = context;
 293     device_extension* Vcb = thread->DeviceObject->DeviceExtension;
 294
 295     ObReferenceObject(thread->DeviceObject);
 296
 297     KeSetSystemAffinityThread((KAFFINITY)(1 << thread->number));
 298
 299     while (true) {
 300         KeWaitForSingleObject(&Vcb->calcthreads.event, Executive, KernelMode, false, NULL);
 301
 302         calc_thread_main(Vcb, NULL);
 303
 304         if (thread->quit)
 305             break;
 306     }
 307
 308     ObDereferenceObject(thread->DeviceObject);
 309
 310     KeSetEvent(&thread->finished, 0, false);
 311
 312     PsTerminateSystemThread(STATUS_SUCCESS);
 313 }