1 /******************************************************************************* 2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. 3 * 4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided 5 *that the following conditions are met: 6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the 7 *following disclaimer. 8 *2. Redistributions in binary form must reproduce the above copyright notice, 9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided 10 *with the distribution. 11 * 12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE 20 * 21 * 22 *******************************************************************************/ 23 /******************************************************************************* 24 ** 25 ** Version Control Information: 26 ** 27 ** $Revision: 113920 $ 28 ** $Author: mcleanda $ 29 ** $Date: 2012-05-08 11:30:44 -0700 (Tue, 08 May 2012) $ 30 ** $Id: lxencrypt.c 113920 2012-05-08 18:30:44Z mcleanda $ 31 ** 32 *******************************************************************************/ 33 34 #include <dev/pms/RefTisa/tisa/sassata/common/tdioctl.h> 35 #include <dev/pms/RefTisa/tisa/api/titypes.h> 36 37 #include <dev/pms/freebsd/driver/common/lxencrypt.h> 38 #include <sys/param.h> 39 #include <sys/queue.h> 40 #include <vm/uma.h> 41 42 43 #ifdef ENCRYPT_ENHANCE 44 static atomic_t ioerr_queue_count; 45 /****************************************************************************** 46 careful_write(): 47 48 Purpose: 49 Parameters: 50 Return: 51 Note: 52 ******************************************************************************/ 53 static int 54 careful_write(char *buf, int offset, int max, const char *fmt, ...) 55 { 56 static char s[PAGE_SIZE]; /* Assumes serialization */ 57 va_list args; 58 int i; 59 60 if(offset > max) 61 return 0; 62 s[PAGE_SIZE - 1] = '\0'; 63 64 va_start(args, fmt); 65 i = vsnprintf(s, PAGE_SIZE - 1, fmt, args); 66 if((offset + i) > max) 67 return 0; 68 memcpy(buf + offset, s, i); 69 va_end(args); 70 71 return i; 72 } 73 74 /****************************************************************************** 75 set_dek_table_entry(): 76 77 Purpose: 78 Parameters: 79 Return: 80 Note: 81 ******************************************************************************/ 82 static inline int 83 set_dek_table_entry(struct device *dev, const char *buf, size_t len, dek_table_e table) 84 { 85 int index; 86 struct Scsi_Host *shost = class_to_shost(dev); 87 struct agtiapi_softc *pCard = (struct agtiapi_softc *) shost->hostdata; 88 89 /* Check permissions */ 90 if(!capable(CAP_SYS_ADMIN)) 91 return -EACCES; 92 93 if(!pCard->encrypt) 94 return -EINVAL; 95 96 if(table != DEK_TABLE_0 && table != DEK_TABLE_1) 97 return -EINVAL; 98 99 sscanf(buf, "%d", &index); 100 if(index >= 0 && index < DEK_MAX_TABLE_ITEMS) { 101 pCard->dek_index[table] = index; 102 return strlen(buf); 103 } 104 return -EINVAL; 105 } 106 107 /****************************************************************************** 108 set_dek_table_entry0(): 109 110 Purpose: 111 Parameters: 112 Return: 113 Note: 114 ******************************************************************************/ 115 ssize_t 116 set_dek_table_entry0(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) 117 { 118 return set_dek_table_entry(dev, buf, len, DEK_TABLE_0); 119 } 120 121 /****************************************************************************** 122 set_dek_table_entry1(): 123 124 Purpose: 125 Parameters: 126 Return: 127 Note: 128 ******************************************************************************/ 129 ssize_t 130 set_dek_table_entry1(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) 131 { 132 return set_dek_table_entry(dev, buf, len, DEK_TABLE_1); 133 } 134 135 136 /****************************************************************************** 137 show_dek_table_entry(): 138 139 Purpose: 140 Parameters: 141 Return: 142 Note: 143 ******************************************************************************/ 144 static inline int 145 show_dek_table_entry(struct device *dev, char *buf, unsigned int table) 146 { 147 int i = 0, j; 148 unsigned char *p; 149 struct Scsi_Host *sh = class_to_shost(dev); 150 ag_card_t *pCard = (ag_card_t *) sh->hostdata; 151 ag_card_info_t *pCardInfo = pCard->pCardInfo; 152 ag_resource_info_t *pRscInfo = &pCardInfo->tiRscInfo; 153 tiEncryptDekBlob_t *pDekTable = NULL; 154 155 if(!pCard->encrypt) 156 return -EINVAL; 157 158 if(table == DEK_TABLE_0) 159 pDekTable = pRscInfo->tiLoLevelResource.loLevelMem.mem[DEK_MEM_INDEX_1].virtPtr; 160 else if(table == DEK_TABLE_1) 161 pDekTable = pRscInfo->tiLoLevelResource.loLevelMem.mem[DEK_MEM_INDEX_2].virtPtr; 162 if(pDekTable == NULL) 163 return -EINVAL; 164 165 if(pCard->dek_index[table] >= 0 || pCard->dek_index[table] < DEK_MAX_TABLE_ITEMS) { 166 i += careful_write(buf, i, PAGE_SIZE, "%4d: ", pCard->dek_index[table]); 167 p = (unsigned char *) &pDekTable[pCard->dek_index[table]]; 168 for(j = 0; j < sizeof(tiEncryptDekBlob_t); j++) { 169 i += careful_write(buf, i, PAGE_SIZE, "%02x", p[j]); 170 } 171 i += careful_write(buf, i, PAGE_SIZE, "\n"); 172 } else { 173 i += careful_write(buf, i, PAGE_SIZE, "Bad DEK index %d; range: 0 - %d\n", pCard->dek_index[table], DEK_MAX_TABLE_ITEMS); 174 } 175 176 /* BUG if we return more than a single page of data */ 177 //BUG_ON(i > PAGE_SIZE); 178 if (i > PAGE_SIZE) 179 i = PAGE_SIZE; 180 181 return i; 182 } 183 184 /****************************************************************************** 185 show_dek_table_entry0(): 186 187 Purpose: 188 Parameters: 189 Return: 190 Note: 191 ******************************************************************************/ 192 ssize_t 193 show_dek_table_entry0(struct device *dev, struct device_attribute *attr, char *buf) 194 { 195 return show_dek_table_entry(dev, buf, DEK_TABLE_0); 196 } 197 198 /****************************************************************************** 199 show_dek_table_entry1(): 200 201 Purpose: 202 Parameters: 203 Return: 204 Note: 205 ******************************************************************************/ 206 ssize_t 207 show_dek_table_entry1(struct device *dev, struct device_attribute *attr, char *buf) 208 { 209 return show_dek_table_entry(dev, buf, DEK_TABLE_1); 210 } 211 212 /****************************************************************************** 213 show_kek_table(): 214 215 Purpose: 216 Parameters: 217 Return: 218 Note: 219 ******************************************************************************/ 220 ssize_t 221 show_kek_table(struct device *dev, struct device_attribute *attr, char *buf) 222 { 223 int i = 0, j, kek_index; 224 unsigned char *p; 225 struct Scsi_Host *sh = class_to_shost(dev); 226 ag_card_t *pCard = (ag_card_t *) sh->hostdata; 227 228 if(!pCard->encrypt) 229 return -EINVAL; 230 231 for(kek_index = 0; kek_index < KEK_TABLE_MAX_ENTRY; kek_index++) { 232 i += careful_write(buf, i, PAGE_SIZE, " %4d: %08x ", kek_index, pCard->kek_table[kek_index].wrapperIndex); 233 p = (unsigned char *) &pCard->kek_table[kek_index].kekBlob; 234 for(j = 0; j < sizeof(tiEncryptKekBlob_t); j++) { 235 i += careful_write(buf, i, PAGE_SIZE, "%02x", p[j]); 236 } 237 i += careful_write(buf, i, PAGE_SIZE, "\n"); 238 } 239 i += careful_write(buf, i, PAGE_SIZE, "\n"); 240 241 /* BUG if we return more than a single page of data */ 242 //BUG_ON(i > PAGE_SIZE); 243 if (i > PAGE_SIZE) 244 i = PAGE_SIZE; 245 246 return i; 247 } 248 249 /****************************************************************************** 250 show_dek_kek_map(): 251 252 Purpose: 253 Parameters: 254 Return: 255 Note: 256 ******************************************************************************/ 257 static inline int 258 show_dek_kek_map(struct device *dev, char *buf, unsigned int table) 259 { 260 int i = 0, dek_index; 261 struct Scsi_Host *sh = class_to_shost(dev); 262 ag_card_t *pCard = (ag_card_t *) sh->hostdata; 263 264 if(!pCard->encrypt) 265 return -EINVAL; 266 267 if(table != DEK_TABLE_0 && table != DEK_TABLE_1) 268 return -EINVAL; 269 270 i += careful_write(buf, i, PAGE_SIZE, "Table %d\n", table); 271 i += careful_write(buf, i, PAGE_SIZE, "=======\n"); 272 for(dek_index = 0; dek_index < DEK_MAX_TABLE_ITEMS; dek_index++) { 273 i += careful_write(buf, i, PAGE_SIZE, " %4d: %08x\n", dek_index, pCard->dek_kek_map[table][dek_index].kekIndex); 274 } 275 i += sprintf(buf + i, "\n"); 276 277 /* BUG if we return more than a single page of data */ 278 //BUG_ON(i > PAGE_SIZE); 279 if (i > PAGE_SIZE) 280 i = PAGE_SIZE; 281 282 return i; 283 } 284 285 /****************************************************************************** 286 show_dek_kek_map0(): 287 288 Purpose: 289 Parameters: 290 Return: 291 Note: 292 ******************************************************************************/ 293 ssize_t 294 295 show_dek_kek_map0(struct device *dev, struct device_attribute *attr, char *buf) 296 { 297 return show_dek_kek_map(dev, buf, 0); 298 } 299 300 /****************************************************************************** 301 show_dek_kek_map1(): 302 303 Purpose: 304 Parameters: 305 Return: 306 Note: 307 ******************************************************************************/ 308 ssize_t 309 show_dek_kek_map1(struct device *dev, struct device_attribute *attr, char *buf) 310 { 311 return show_dek_kek_map(dev, buf, 1); 312 } 313 314 /****************************************************************************** 315 show_target_dek_map(): 316 317 Purpose: 318 Parameters: 319 Return: 320 Note: 321 ******************************************************************************/ 322 ssize_t 323 show_target_dek_map(struct device *dev, struct device_attribute *attr, char *buf) 324 { 325 int i = 0; 326 unsigned int chan, device, lun = 0; 327 ag_encrypt_map_t *p; 328 struct list_head *lh; 329 struct Scsi_Host *sh = class_to_shost(dev); 330 ag_card_t *pCard = (ag_card_t *) sh->hostdata; 331 332 if(!pCard->encrypt) 333 return -EINVAL; 334 335 for(chan = 0; chan <= AGTIAPI_MAX_CHANNEL_NUM; chan++) { 336 for(device = 0; device < pCard->devDiscover; device++) { 337 #ifdef REPORT_ALL_LUNS 338 for(lun = 0; lun < AGTIAPI_MAX_LUN; lun++) { 339 #endif 340 lh = MAP_TABLE_ENTRY(pCard, chan, device, lun); 341 if(lh) { 342 list_for_each_entry(p, lh, list) { 343 if(p->dekIndex != DEK_INDEX_INVALID) 344 i += careful_write(buf, i, PAGE_SIZE, " %u:%u:%u: %x %8x %8x %16lx %16lx %08x:%08x %1x\n", chan, device, lun, p->dekTable, p->dekIndex, p->kekIndex, p->lbaMin, p->lbaMax, p->keyTag[1], p->keyTag[0], p->keyTagCheck); 345 } 346 } 347 #ifdef REPORT_ALL_LUNS 348 } 349 #endif 350 } 351 } 352 353 if (i > PAGE_SIZE) 354 i = PAGE_SIZE; 355 356 return i; 357 } 358 359 360 /****************************************************************************** 361 agtiapi_AddDek(): 362 363 Purpose: 364 Parameters: 365 Return: 366 Note: 367 ******************************************************************************/ 368 static int 369 agtiapi_AddDek(ag_card_t *pCard, bit32 dek_table, bit32 dek_index, bit32 blob_format, bit32 entry_sz, tiEncryptDekBlob_t *dek_blob, U32_64 *addr) 370 { 371 ag_resource_info_t *pRscInfo = &pCard->pCardInfo->tiRscInfo; 372 tiEncryptDekBlob_t *pDekTable; 373 char *p; 374 375 if (dek_index >= DEK_MAX_TABLE_ITEMS) { 376 printf("%s: Bad dek index 0x%x (MAX: 0x%x).\n", __FUNCTION__, dek_index, DEK_MAX_TABLE_ITEMS); 377 return -E_DEK_INDEX; 378 } 379 380 switch(dek_table) { 381 case DEK_TABLE_0: 382 pDekTable = pRscInfo->tiLoLevelResource.loLevelMem.mem[DEK_MEM_INDEX_1].virtPtr; 383 break; 384 case DEK_TABLE_1: 385 pDekTable = pRscInfo->tiLoLevelResource.loLevelMem.mem[DEK_MEM_INDEX_2].virtPtr; 386 break; 387 default: 388 printf("%s: Unknown dek table %d\n", __FUNCTION__, dek_table); 389 return -E_DEK_TABLE; 390 } 391 392 #ifdef __VMKLNX__ 393 *addr = (U32_64) __pa(&pDekTable[0]); 394 #else 395 *addr = (U32_64) virt_to_phys(&pDekTable[0]); 396 #endif 397 398 p = (char *) &pDekTable[0] + (dek_index * pCard->dek_size); 399 400 printf("%s: Base: %p, Index: %08x, Virt: %p Size: %d\n", __FUNCTION__, pDekTable, dek_index, &pDekTable[dek_index], pCard->dek_size); 401 memcpy(p, dek_blob, pCard->dek_size); 402 wmb(); 403 404 /* Flush entry */ 405 ostiCacheFlush(&pCard->tiRoot, NULL, p, pCard->dek_size); 406 407 return 0; 408 } 409 410 /****************************************************************************** 411 agtiapi_MapDekKek(): 412 413 Purpose: 414 Parameters: 415 Return: 416 Note: 417 ******************************************************************************/ 418 static int 419 agtiapi_MapDekKek(ag_card_t *pCard, bit32 dek_table, bit32 dek_index, bit32 kek_index) 420 { 421 if (dek_index >= DEK_MAX_TABLE_ITEMS) { 422 printf("%s: Bad dek index 0x%x (MAX: 0x%x).\n", __FUNCTION__, dek_index, DEK_MAX_TABLE_ITEMS); 423 return -E_DEK_INDEX; 424 } 425 426 if (dek_table >= DEK_MAX_TABLES) { 427 printf("%s: Bad dek table.\n", __FUNCTION__); 428 return -E_DEK_TABLE; 429 } 430 431 if (kek_index >= KEK_TABLE_MAX_ENTRY) { 432 printf("%s: Bad kek index.\n", __FUNCTION__); 433 return -E_KEK_INDEX; 434 } 435 436 pCard->dek_kek_map[dek_table][dek_index].kekIndex = kek_index; 437 return 0; 438 } 439 440 /****************************************************************************** 441 agtiapi_AddKek(): 442 443 Purpose: 444 Parameters: 445 Return: 446 Note: 447 ******************************************************************************/ 448 static int 449 agtiapi_AddKek(ag_card_t *pCard, bit32 kek_index, bit32 wrapper_kek_index, tiEncryptKekBlob_t *kek_blob) 450 { 451 if (kek_index >= KEK_TABLE_MAX_ENTRY) { 452 printf("%s: Bad kek index.\n", __FUNCTION__); 453 return -E_KEK_INDEX; 454 } 455 if (wrapper_kek_index >= KEK_TABLE_MAX_ENTRY) { 456 printf("%s: Bad kek wrapper index.\n", __FUNCTION__); 457 return -E_KEK_INDEX; 458 } 459 pCard->kek_table[kek_index].wrapperIndex = wrapper_kek_index; 460 memcpy(&pCard->kek_table[kek_index].kekBlob, kek_blob, sizeof(tiEncryptKekBlob_t)); 461 return 0; 462 } 463 464 /****************************************************************************** 465 agtiapi_MapDek(): 466 467 Purpose: 468 Parameters: 469 Return: 470 Note: 471 ******************************************************************************/ 472 static int 473 agtiapi_MapDek(ag_card_t *pCard, EncryptDeviceDekMap_t *dek_map) 474 { 475 int found = 0; 476 bit32 chan, device, lun; 477 bit32 dek_table, dek_index, kek_index; 478 unsigned long long lba_min, lba_max; 479 ag_encrypt_map_t *p, *n; 480 struct list_head *lh; 481 482 chan = dek_map->channel; 483 device = dek_map->device; 484 lun = dek_map->lun; 485 486 lba_min = dek_map->dekMapEntry[0].startLBA; 487 lba_max = dek_map->dekMapEntry[0].endLBA; 488 489 dek_table = dek_map->dekMapEntry[0].dek.dekTable; 490 dek_index = dek_map->dekMapEntry[0].dek.dekIndex; 491 492 /* Sanity check channel, device, lun */ 493 if (chan > AGTIAPI_MAX_CHANNEL_NUM) { 494 printf("%s: Bad channel %d.\n", __FUNCTION__, chan); 495 return -E_CHANNEL_INDEX; 496 } 497 if (device >= pCard->devDiscover) { 498 printf("%s: Bad device %d.\n", __FUNCTION__, device); 499 return -E_DEVICE_INDEX; 500 } 501 if (lun >= AGTIAPI_MAX_LUN) { 502 printf("%s: Bad lun %d.\n", __FUNCTION__, lun); 503 return -E_LUN_INDEX; 504 } 505 506 /* Sanity check dek index */ 507 if (dek_index >= DEK_MAX_TABLE_ITEMS) { 508 printf("%s: Bad dek index 0x%x (MAX: 0x%x).\n", __FUNCTION__, dek_index, DEK_MAX_TABLE_ITEMS); 509 return -E_DEK_INDEX; 510 } 511 512 /* Sanity check dek table */ 513 if (dek_table >= DEK_MAX_TABLES) { 514 printf("%s: Bad dek table %d.\n", __FUNCTION__, dek_table); 515 return -E_DEK_TABLE; 516 } 517 518 /* Check that lba min and lba max are sane */ 519 if (lba_min >= lba_max) { 520 printf("%s: Bad lba min and lba max: %llx %llx.\n", __FUNCTION__, lba_min, lba_max); 521 return -E_LBA_RANGE; 522 } 523 524 /* dek_table and dek_index are valid, look up kek */ 525 kek_index = pCard->dek_kek_map[dek_table][dek_index].kekIndex; 526 527 lh = MAP_TABLE_ENTRY(pCard, chan, device, lun); 528 529 if (dek_map->dekMapEntry[0].flags & ENCRYPT_DEK_MAP_ENTRY_CLEAR) { 530 /* Delete the entry */ 531 found = 0; 532 list_for_each_entry_safe(p, n, lh, list) { 533 if (p->lbaMin == lba_min && 534 p->lbaMax == lba_max && 535 p->dekTable == dek_table && 536 p->dekIndex == dek_index && 537 p->kekIndex == kek_index) { 538 /* Entry found, unlink and reclaim it */ 539 found = 1; 540 list_del(&p->list); 541 mempool_free(p, pCard->map_mempool); 542 } 543 } 544 if (!found) { 545 printf("%s: Entry %x %x %x %llx %llx not found.\n", __FUNCTION__, dek_table, dek_index, kek_index, lba_min, lba_max); 546 return -E_NOT_FOUND; 547 } 548 } else if (dek_map->dekMapEntry[0].flags & ENCRYPT_DEK_MAP_ENTRY_VALID) { 549 /* Add the entry */ 550 551 p = (ag_encrypt_map_t *)uma_zalloc(pCard->map_cache, M_WAITOK); //Encryption 552 if (!p) { 553 printf("%s: Unable to allocate from memory pool.\n", __FUNCTION__); 554 return -E_MEMPOOL_ALLOC; 555 } 556 557 /* Populate it */ 558 p->lbaMin = lba_min; 559 p->lbaMax = lba_max; 560 p->dekTable = dek_table; 561 p->dekIndex = dek_index; 562 p->kekIndex = kek_index; 563 p->keyTagCheck = dek_map->keytag_check; 564 memcpy(&p->keyTag, &dek_map->keytag, sizeof(p->keyTag)); 565 566 /* Test to see if this new mapping overlaps an existing mapping */ 567 list_for_each_entry(n, lh, list) { 568 /* 569 * Check if the start lba falls in existing range || 570 * Check if the end lba falls in existing range || 571 * Check if the start lba of the existing range falls in the new range 572 */ 573 if (((p->lbaMin >= n->lbaMin) && (p->lbaMin <= n->lbaMax)) || 574 ((p->lbaMax >= n->lbaMin) && (p->lbaMax <= n->lbaMax)) || 575 ((n->lbaMin >= p->lbaMin) && (n->lbaMin <= p->lbaMax))) { 576 printf("%s: WARNING: New entry lba range overlap: %llx - %llx vs %llx - %llx.\n", __FUNCTION__, p->lbaMin, p->lbaMax, n->lbaMin, n->lbaMax); 577 } 578 } 579 580 /* Link it in to list at the head so it takes precedence */ 581 list_add(&p->list, lh); 582 583 /* TODO: Decide if/how to refcount each dek/kek index used by the mapping */ 584 585 } else { 586 printf("%s: Bad flags %08x\n", __FUNCTION__, dek_map->dekMapEntry[0].flags); 587 return -E_FLAGS; 588 } 589 590 return 0; 591 } 592 #endif 593 #ifdef HIALEAH_ENCRYPTION 594 /****************************************************************************** 595 agtiapi_SetupEncryption(): 596 597 Purpose: 598 Parameters: 599 Return: 600 Note: 601 ******************************************************************************/ 602 int 603 agtiapi_SetupEncryption(struct agtiapi_softc *pCard) 604 { 605 tiRoot_t *tiRoot = (tiRoot_t *) &pCard->tiRoot; 606 bit32 status = tiSuccess; 607 printf("agtiapi_SetupEncryption: HIALEAH_ENCRYPTION\n"); 608 if (pCard->encrypt == agTRUE) 609 { 610 status = tiCOMEncryptGetInfo(tiRoot); 611 printf("agtiapi_SetupEncryption: HIALEAH_ENCRYPTION tiCOMEncryptGetInfo Status 0x%x\n",status); 612 613 if(status == 1 ) 614 { 615 status = tiCOMEncryptHilSet(tiRoot ); 616 if (status) { 617 pCard->encrypt = agFALSE; 618 printf("agtiapi_SetupEncryption: HIALEAH_ENCRYPTION not set\n"); 619 } 620 } 621 } 622 return 0; 623 } 624 #ifdef ENCRYPT_ENHANCE 625 /****************************************************************************** 626 agtiapi_SetupEncryptionPools(): 627 628 Purpose: 629 Parameters: 630 Return: 631 Note: 632 ******************************************************************************/ 633 int 634 agtiapi_SetupEncryptionPools(struct agtiapi_softc *pCard) 635 { 636 /* Configure encryption memory pool */ 637 memset(pCard->map_cache_name, 0, sizeof(pCard->map_cache_name)); 638 snprintf(pCard->map_cache_name, sizeof(pCard->map_cache_name) - 1, "map_cache_%d", pCard->cardNo); 639 640 //zone allocation 641 pCard->map_cache = uma_zcreate(pCard->map_cache_name, sizeof(ag_encrypt_map_t),NULL, NULL, NULL, NULL, 0, 0); 642 if(!pCard->map_cache) { 643 /* 644 * This error may be due to an existing cache in the kernel 645 * from an earlier kmem_cache that wasn't properly freed 646 */ 647 printf("Unable to create uma_zcreate cache for encryption map mempool.\n"); 648 return -EFAULT; 649 } 650 uma_zone_set_max(pCard->map_cache, ENCRYPTION_MAP_MEMPOOL_SIZE); 651 652 653 /* Configure encryption IO error pool */ 654 INIT_LIST_HEAD(&pCard->ioerr_queue); 655 /*#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) // #### 656 pCard->ioerr_queue_lock = SPIN_LOCK_UNLOCKED; 657 #else */ 658 pCard->ioerr_queue_lock = AG_SPIN_UNLOCK(pCard->ioerr_queue_lock); 659 //#endif 660 661 662 memset(pCard->ioerr_cache_name, 0, sizeof(pCard->ioerr_cache_name)); 663 snprintf(pCard->ioerr_cache_name, sizeof(pCard->ioerr_cache_name) - 1, "ioerr_cache_%d", pCard->cardNo); 664 665 pCard->ioerr_cache = uma_zcreate(pCard->ioerr_cache_name, sizeof(ag_encrypt_ioerr_t), NULL, NULL, NULL, NULL, 0, 0); 666 if(!pCard->ioerr_cache) { 667 /* 668 * This error may be due to an existing cache in the kernel 669 * from an earlier kmem_cache that wasn't properly freed 670 */ 671 printf("Unable to create kmem cache for encryption IO error mempool.\n"); 672 return -EFAULT; 673 } 674 uma_zone_set_max(pCard->ioerr_cache, ENCRYPTION_IO_ERR_MEMPOOL_SIZE); 675 676 /* Set cipher mode to something invalid */ 677 pCard->cipher_mode = CIPHER_MODE_INVALID; 678 679 return 0; 680 } 681 #endif 682 /****************************************************************************** 683 agtiapi_CleanupEncryption(): 684 685 Purpose: 686 Parameters: 687 Return: 688 Note: 689 ******************************************************************************/ 690 void 691 agtiapi_CleanupEncryption(struct agtiapi_softc *pCard) 692 { 693 #ifdef ENCRYPT_ENHANCE 694 if(pCard->encrypt_map) { 695 int chan, device, lun; 696 struct list_head *lh; 697 ag_encrypt_map_t *p, *n; 698 699 for (chan = 0; chan < (AGTIAPI_MAX_CHANNEL_NUM + 1); chan++) { 700 for (device = 0; device < pCard->devDiscover; device++) { 701 for (lun = 0; lun < AGTIAPI_MAX_LUN; lun++) { 702 lh = MAP_TABLE_ENTRY(pCard, chan, device, lun); 703 list_for_each_entry_safe(p, n, lh, list) { 704 // mempool_free(p, pCard->map_mempool); 705 } 706 } 707 } 708 } 709 vfree(pCard->encrypt_map); 710 pCard->encrypt_map = NULL; 711 } 712 #endif 713 } 714 715 #ifdef ENCRYPT_ENHANCE 716 /****************************************************************************** 717 agtiapi_CleanupEncryptionPools(): 718 719 Purpose: 720 Parameters: 721 Return: 722 Note: 723 ******************************************************************************/ 724 void 725 agtiapi_CleanupEncryptionPools(struct agtiapi_softc *pCard) 726 { 727 ag_encrypt_ioerr_t *ioerr, *tmp; 728 atomic_set(&ioerr_queue_count); 729 730 /* 731 * TODO: check "outstanding_encrypted_io_count" for non-zero 732 * and free all mempool items prior to destroying pool 733 */ 734 735 /* Clean up memory pools */ 736 if (pCard->map_mempool) { 737 mempool_destroy(pCard->map_mempool); 738 printf("Encryption Map mempool released.\n"); 739 pCard->map_mempool = NULL; 740 } 741 742 /* Clean up kmem cache */ 743 if (pCard->map_cache) { 744 kmem_cache_destroy(pCard->map_cache); 745 printf("Kernel memory cache %s released.\n", pCard->map_cache_name); 746 pCard->map_cache = NULL; 747 } 748 749 /* Clean up memory pools */ 750 list_for_each_entry_safe(ioerr, tmp, &pCard->ioerr_queue, list) { 751 list_del_init(&ioerr->list); 752 mempool_free(ioerr, pCard->ioerr_mempool); 753 atomic_dec(&ioerr_queue_count); 754 } 755 756 if (pCard->ioerr_mempool) { 757 mempool_destroy(pCard->ioerr_mempool); 758 printf("Encryption IO Error mempool released.\n"); 759 pCard->ioerr_mempool = NULL; 760 } 761 762 /* Clean up kmem cache */ 763 if (pCard->ioerr_cache) { 764 kmem_cache_destroy(pCard->ioerr_cache); 765 printf("Kernel memory cache %s released.\n", pCard->ioerr_cache_name); 766 pCard->ioerr_cache = NULL; 767 } 768 } 769 770 /****************************************************************************** 771 agtiapi_EncryptionIoctl(): 772 773 Purpose: 774 Parameters: 775 Return: 776 Note: 777 ******************************************************************************/ 778 int 779 agtiapi_EncryptionIoctl(struct agtiapi_softc *pCard, IoctlEncrypt_t *pIoctlPayload) 780 { 781 int rv, rc = 0, skip_wait = 0; 782 tiRoot_t *tiRoot = (tiRoot_t *) &pCard->tiRoot; 783 IoctlTISAEncrypt_t *ioctl_data = &pIoctlPayload->body; 784 pIoctlPayload->hdr.Status = IOCTL_ERR_STATUS_INVALID_CODE; 785 pCard->ioctl_data = (void *) ioctl_data; 786 init_completion(&pCard->ioctl_completion); 787 788 /* Check that the system is quiesced */ 789 if (atomic_read(&outstanding_encrypted_io_count) != 0) 790 printf("%s: WARNING: Attempting encryption management update with outstanding encrypted IOs!\n", __FUNCTION__); 791 792 printf("%s: Minor %d\n", __FUNCTION__, pIoctlPayload->hdr.MinorFunction); 793 switch(pIoctlPayload->hdr.MinorFunction) { 794 case IOCTL_MN_ENCRYPTION_GET_INFO: 795 { 796 //IoctlEncryptGetInfo_t *get_info = (IoctlEncryptGetInfo_t *) &ioctl_data->request; 797 rc = tiCOMEncryptGetInfo(tiRoot); 798 } 799 break; 800 case IOCTL_MN_ENCRYPTION_SET_MODE: 801 { 802 u32 reg_val = 0, new_cipher_mode = 0; 803 IoctlEncryptSetMode_t *set_mode = (IoctlEncryptSetMode_t *) &ioctl_data->request; 804 805 printf("%s: input %08x\n", __FUNCTION__, set_mode->securityCipherMode); 806 807 /* Set security mode */ 808 if(TI_ENCRYPT_SEC_MODE_FACT_INIT) 809 if(set_mode->securityCipherMode & TI_ENCRYPT_SEC_MODE_FACT_INIT) { 810 reg_val |= TI_ENCRYPT_SEC_MODE_FACT_INIT; 811 pCard->dek_size = DEK_SIZE_PLAIN; 812 } 813 if(set_mode->securityCipherMode & TI_ENCRYPT_SEC_MODE_A) { 814 reg_val |= TI_ENCRYPT_SEC_MODE_A; 815 pCard->dek_size = DEK_SIZE_ENCRYPT; 816 } else if(set_mode->securityCipherMode & TI_ENCRYPT_SEC_MODE_B) { 817 reg_val |= TI_ENCRYPT_SEC_MODE_B; 818 pCard->dek_size = DEK_SIZE_ENCRYPT; 819 } 820 821 /* Set cipher mode */ 822 if(set_mode->securityCipherMode & TI_ENCRYPT_ATTRIB_CIPHER_XTS) { 823 reg_val |= TI_ENCRYPT_ATTRIB_CIPHER_XTS; 824 new_cipher_mode = TI_ENCRYPT_MODE_XTS_AES; 825 } 826 827 printf("%s: Setting security cipher mode to: 0x%08x\n", __FUNCTION__, reg_val); 828 pCard->cipher_mode = new_cipher_mode; 829 830 rc = tiCOMEncryptSetMode(tiRoot, reg_val); 831 } 832 break; 833 case IOCTL_MN_ENCRYPTION_KEK_ADD: 834 { 835 tiEncryptKekBlob_t kek_blob; 836 IoctlEncryptKekAdd_t *kek_add = (IoctlEncryptKekAdd_t *) &ioctl_data->request; 837 printf("%s: Add kek at index 0x%x wrapper 0x%x format 0x%x\n", __FUNCTION__, kek_add->kekIndex, kek_add->wrapperKekIndex, kek_add->blobFormat); 838 839 /* Copy kek_blob from user pointer to local buffer */ 840 if(access_ok(kek_add->EncryptKekBlob, sizeof(kek_blob))) { 841 printf("%s: Starting copy from user %p to kernel %p\n", __FUNCTION__, kek_add->EncryptKekBlob, &kek_blob); 842 if((rv = copy_from_user(&kek_blob, kek_add->EncryptKekBlob, sizeof(kek_blob))) != 0) { 843 printf("%s: Copy error, %d left\n", __FUNCTION__, rv); 844 return IOCTL_CALL_FAIL; 845 } 846 rc = tiCOMEncryptKekAdd(tiRoot, kek_add->kekIndex, kek_add->wrapperKekIndex, kek_add->blobFormat, &kek_blob); 847 848 /* Add kek to local kek table (in case of chip reset) */ 849 if(rc == tiSuccess) { 850 if(agtiapi_AddKek(pCard, kek_add->kekIndex, kek_add->wrapperKekIndex, &kek_blob) < 0) { 851 return IOCTL_CALL_FAIL; 852 } 853 } 854 } else { 855 return IOCTL_CALL_FAIL; 856 } 857 } 858 break; 859 case IOCTL_MN_ENCRYPTION_DEK_ADD: 860 { 861 tiEncryptDekBlob_t dek_blob; /* Copied in */ 862 IoctlEncryptDekAdd_t *dek_add = (IoctlEncryptDekAdd_t *) &ioctl_data->request; 863 bit32 kek_index = dek_add->kekIndex; 864 bit32 dek_index = dek_add->dekIndex; 865 bit32 dek_table = dek_add->dekTable; 866 bit32 blob_format = dek_add->dekBlobFormat; 867 bit32 entry_sz = dek_add->dekTableKeyEntrySize; 868 U32_64 addr = 0; 869 bit32 addr_table[2]; 870 memset(addr_table, 0, sizeof(addr_table)); 871 872 printf("%s: Add dek at index 0x%x, table %x, kek index %x, blob format %x, entry size %x\n", __FUNCTION__, dek_index, dek_table, kek_index, blob_format, entry_sz); 873 874 /* Copy dek_blob from user pointer to local buffer */ 875 if(access_ok(dek_add->dekBlob, sizeof(dek_blob))) { 876 printf("%s: Starting copy from user %p to kernel %p\n", __FUNCTION__, dek_add->dekBlob, &dek_blob); 877 if((rv = copy_from_user(&dek_blob, dek_add->dekBlob, sizeof(dek_blob))) != 0) { 878 printf("%s: Copy error, %d left\n", __FUNCTION__, rv); 879 return IOCTL_CALL_FAIL; 880 } 881 882 /* Add DEK to local table */ 883 if (agtiapi_AddDek(pCard, dek_table, dek_index, blob_format, entry_sz, &dek_blob, &addr) < 0) { 884 return IOCTL_CALL_FAIL; 885 } 886 memcpy(addr_table, &addr, sizeof(addr)); 887 888 /* Add DEK-KEK association in local table */ 889 if (agtiapi_MapDekKek(pCard, dek_table, dek_index, kek_index) < 0) { 890 return IOCTL_CALL_FAIL; 891 } 892 893 /* Push DEK to chip */ 894 rc = tiCOMEncryptDekAdd(tiRoot, kek_index, dek_table, addr_table[1], addr_table[0], dek_index, 1, blob_format, entry_sz); 895 } else { 896 return IOCTL_CALL_FAIL; 897 } 898 } 899 break; 900 case IOCTL_MN_ENCRYPTION_DEK_INVALID: 901 { 902 IoctlEncryptDekInvalidate_t *dek_to_invalidate = (IoctlEncryptDekInvalidate_t *) &ioctl_data->request; 903 printf("%s: Invalidating dek at index 0x%x, table %x\n", __FUNCTION__, dek_to_invalidate->dek.dekIndex, dek_to_invalidate->dek.dekTable); 904 905 rc = tiCOMEncryptDekInvalidate(tiRoot, dek_to_invalidate->dek.dekTable, dek_to_invalidate->dek.dekIndex); 906 /* TODO: What to do in local tables? Mark it? */ 907 } 908 break; 909 case IOCTL_MN_ENCRYPTION_KEK_NVRAM: 910 { 911 rc = tiError; 912 } 913 break; 914 case IOCTL_MN_ENCRYPTION_DEK_ASSIGN: 915 { 916 IoctlEncryptDekMapTable_t *p_dek_map = (IoctlEncryptDekMapTable_t *) &ioctl_data->request; 917 918 /* Fill in host */ 919 p_dek_map->dekMap[0].host = (bit32) pCard->pHost->host_no; 920 921 printf("%s: Host %u: Mapping %u:%u:%u (%llx to %llx) to dek at index 0x%x, table %x, keytag %08x:%08x\n", __FUNCTION__, p_dek_map->dekMap[0].host, p_dek_map->dekMap[0].channel, p_dek_map->dekMap[0].device, p_dek_map->dekMap[0].lun, p_dek_map->dekMap[0].dekMapEntry[0].startLBA, p_dek_map->dekMap[0].dekMapEntry[0].endLBA, p_dek_map->dekMap[0].dekMapEntry[0].dek.dekIndex, p_dek_map->dekMap[0].dekMapEntry[0].dek.dekTable, p_dek_map->dekMap[0].keytag[1], p_dek_map->dekMap[0].keytag[0]); 922 923 /* Create a mapping in local tables */ 924 if (agtiapi_MapDek(pCard, &p_dek_map->dekMap[0]) < 0) { 925 pIoctlPayload->hdr.Status = IOCTL_ERR_STATUS_INVALID_CODE; 926 return IOCTL_CALL_FAIL; 927 } 928 929 rc = tiSuccess; 930 skip_wait = 1; 931 ioctl_data->encryptFunction = encryptSetDekMap; 932 ioctl_data->status = tiSuccess; 933 ioctl_data->subEvent = 0; 934 } 935 break; 936 case IOCTL_MN_ENCRYPTION_ERROR_QUERY: 937 { 938 unsigned long flags, i, query_flag; 939 ag_encrypt_ioerr_t *ioerr, *tmp; 940 IoctlEncryptErrorQuery_t *perr = (IoctlEncryptErrorQuery_t *) &ioctl_data->request; 941 942 printf("%s: query flag %x\n", __FUNCTION__, perr->query_flag); 943 query_flag = perr->query_flag; 944 945 /* initialize */ 946 memset(perr, 0, sizeof(IoctlEncryptErrorQuery_t)); 947 948 error_query_restart: 949 /* Take spinlock */ 950 // spin_lock_irqsave(&pCard->ioerr_queue_lock, flags); 951 AG_SPIN_LOCK_IRQ(&pCard->ioerr_queue_lock, flags); 952 953 /* Walk list */ 954 i = 0; 955 list_for_each_entry_safe(ioerr, tmp, &pCard->ioerr_queue, list) { 956 if (i >= 32) 957 break; 958 959 perr->valid_mask |= (1 << i); 960 memcpy(&perr->error[i], &ioerr->ioerr, sizeof(IoctlEncryptIOError_t)); 961 list_del_init(&ioerr->list); 962 mempool_free(ioerr, pCard->ioerr_mempool); 963 i++; 964 atomic_dec(&ioerr_queue_count); 965 } 966 967 /* Release spinlock */ 968 // spin_unlock_irqrestore(&pCard->ioerr_queue_lock, flags); 969 AG_SPIN_UNLOCK_IRQ(&pCard->ioerr_queue_lock, flags); //for test 970 971 if (!perr->valid_mask) { 972 /* No encryption IO error events, check flags to see if blocking wait OK */ 973 if (query_flag == ERROR_QUERY_FLAG_BLOCK) { 974 if (wait_event_interruptible(ioerr_waitq, (atomic_read(&ioerr_queue_count)))) { 975 /* Awoken by signal */ 976 return IOCTL_CALL_FAIL; 977 } else { 978 /* Awoken by IO error */ 979 goto error_query_restart; 980 } 981 } 982 } 983 rc = tiSuccess; 984 skip_wait = 1; 985 ioctl_data->encryptFunction = encryptErrorQuery; 986 ioctl_data->status = tiSuccess; 987 ioctl_data->subEvent = 0; 988 } 989 break; 990 default: 991 printf("%s: Unrecognized Minor Function %d\n", __FUNCTION__, pIoctlPayload->hdr.MinorFunction); 992 pIoctlPayload->hdr.Status = IOCTL_ERR_STATUS_INVALID_CODE; 993 return IOCTL_CALL_FAIL; 994 break; 995 } 996 997 /* Demux rc */ 998 switch(rc) { 999 case tiSuccess: 1000 if(!skip_wait) 1001 wait_for_completion(&pCard->ioctl_completion); 1002 /* Maybe: wait_for_completion_timeout() */ 1003 pIoctlPayload->hdr.Status = ioctl_data->status; 1004 break; 1005 case tiNotSupported: 1006 pIoctlPayload->hdr.Status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 1007 break; 1008 default: 1009 printf("%s: Status: %d\n", __FUNCTION__, rc); 1010 pIoctlPayload->hdr.Status = IOCTL_ERR_STATUS_INVALID_CODE; 1011 break; 1012 } 1013 1014 printf("%s: Encryption ioctl %d successful.\n", __FUNCTION__, pIoctlPayload->hdr.MinorFunction); 1015 return IOCTL_CALL_SUCCESS; 1016 } 1017 #endif 1018 /****************************************************************************** 1019 agtiapi_SetupEncryptedIO(): 1020 1021 Purpose: 1022 Parameters: 1023 Return: 1024 Note: 1025 ******************************************************************************/ 1026 int 1027 agtiapi_SetupEncryptedIO(struct agtiapi_softc *pCard, ccb_t *pccb, unsigned long long block) 1028 { 1029 1030 pCard->cipher_mode = TI_ENCRYPT_ATTRIB_CIPHER_XTS; 1031 /* Check that cipher mode is set properly */ 1032 if (pCard->cipher_mode == CIPHER_MODE_INVALID) { 1033 printf("%s: Cipher mode not yet set.\n", __FUNCTION__); 1034 return -E_BAD_CIPHER_MODE; 1035 } 1036 1037 memset(&(pccb->tiSuperScsiRequest.Encrypt), 0, sizeof(pccb->tiSuperScsiRequest.Encrypt)); 1038 pccb->tiSuperScsiRequest.Encrypt.keyTagCheck = FALSE; 1039 pccb->tiSuperScsiRequest.Encrypt.encryptMode = pCard->cipher_mode; 1040 pccb->tiSuperScsiRequest.Encrypt.tweakVal_W0 = block; 1041 if(pccb->tiSuperScsiRequest.scsiCmnd.cdb[0] == READ_16 || 1042 pccb->tiSuperScsiRequest.scsiCmnd.cdb[0] == WRITE_16) 1043 { 1044 pccb->tiSuperScsiRequest.Encrypt.tweakVal_W0 = ((pccb->tiSuperScsiRequest.scsiCmnd.cdb[6] << 24 ) | 1045 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[7] << 16 ) | 1046 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[8] << 8 ) | 1047 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[9])); 1048 pccb->tiSuperScsiRequest.Encrypt.tweakVal_W1 = ((pccb->tiSuperScsiRequest.scsiCmnd.cdb[2] << 24 ) | 1049 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[3] << 16 ) | 1050 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[4] << 8 ) | 1051 (pccb->tiSuperScsiRequest.scsiCmnd.cdb[5])); 1052 } 1053 /* Mark IO as valid encrypted IO */ 1054 pccb->flags |= ENCRYPTED_IO; 1055 pccb->tiSuperScsiRequest.flags = TI_SCSI_INITIATOR_ENCRYPT; 1056 1057 /* Bump refcount (atomic) */ 1058 atomic_inc(&outstanding_encrypted_io_count); 1059 return 0; 1060 } 1061 1062 /****************************************************************************** 1063 agtiapi_CleanupEncryptedIO(): 1064 1065 Purpose: 1066 Parameters: 1067 Return: 1068 Note: 1069 ******************************************************************************/ 1070 void 1071 agtiapi_CleanupEncryptedIO(struct agtiapi_softc *pCard, ccb_t *pccb) 1072 { 1073 if ((pccb->flags & ENCRYPTED_IO)) { 1074 /* Decrement refcount */ 1075 atomic_dec(&outstanding_encrypted_io_count); 1076 } 1077 pccb->tiSuperScsiRequest.flags &= ~TI_SCSI_INITIATOR_ENCRYPT; 1078 pccb->flags &= ~ENCRYPTED_IO; 1079 } 1080 #ifdef ENCRYPT_ENHANCE 1081 /****************************************************************************** 1082 agtiapi_HandleEncryptedIOFailure(): 1083 1084 Purpose: 1085 Parameters: 1086 Return: 1087 Note: 1088 ******************************************************************************/ 1089 void 1090 agtiapi_HandleEncryptedIOFailure(ag_device_t *pDev, ccb_t *pccb) 1091 { 1092 unsigned long flags, qdepth; 1093 struct scsi_cmnd *cmd; 1094 ag_encrypt_ioerr_t *perr; 1095 ag_card_t *pCard; 1096 1097 cmd = pccb->cmd; 1098 if (!cmd) { 1099 printf("%s: Malformed pccb %p.\n", __FUNCTION__, pccb); 1100 return; 1101 } 1102 1103 pCard = pDev->pCard; 1104 1105 /* Sanity check */ 1106 if (!(pccb->flags & ENCRYPTED_IO)) { 1107 printf("%s: Skipping IO %lx: Not Encrypted.\n", __FUNCTION__, cmd->serial_number); 1108 return; 1109 } 1110 1111 /* Check queue depth against max */ 1112 qdepth = atomic_read(&ioerr_queue_count); 1113 if (qdepth >= IOERR_QUEUE_DEPTH_MAX) { 1114 printf("%s: Not queueing IO error due to queue full: %lu entries.\n", __FUNCTION__, qdepth); 1115 return; 1116 } 1117 1118 /* Get a container for the ag_encrypt_ioerr_t item from the mempool */ 1119 // perr = mempool_alloc(pCard->ioerr_mempool, GFP_ATOMIC); 1120 p = (ag_encrypt_map_t *)uma_zalloc(pCard->map_cache, M_WAITOK); //Encryption 1121 if (!perr) { 1122 printf("%s: Mempool allocation failure.\n", __FUNCTION__); 1123 return; 1124 } 1125 1126 /* Populate ag_encrypt_ioerr_t container */ 1127 perr->ioerr.error_id = cmd->serial_number; 1128 perr->ioerr.timestamp = cmd->jiffies_at_alloc; 1129 perr->ioerr.host = (unsigned int) cmd->device->host->host_no; 1130 perr->ioerr.channel = cmd->device->channel; 1131 perr->ioerr.device = cmd->device->id; 1132 perr->ioerr.lun = cmd->device->lun; 1133 perr->ioerr.scsi_cmd = (unsigned int) cmd->cmnd[0]; 1134 perr->ioerr.dek_index = pccb->tiSuperScsiRequest.Encrypt.dekInfo.dekIndex; 1135 perr->ioerr.dek_table = pccb->tiSuperScsiRequest.Encrypt.dekInfo.dekTable; 1136 perr->ioerr.kek_index = pccb->tiSuperScsiRequest.Encrypt.kekIndex; 1137 perr->ioerr.keytag_check = pccb->tiSuperScsiRequest.Encrypt.keyTagCheck; 1138 perr->ioerr.encrypt_mode = pccb->tiSuperScsiRequest.Encrypt.encryptMode; 1139 perr->ioerr.keytag[0] = pccb->tiSuperScsiRequest.Encrypt.keyTag_W0; 1140 perr->ioerr.keytag[1] = pccb->tiSuperScsiRequest.Encrypt.keyTag_W1; 1141 1142 switch(pccb->scsiStatus) { 1143 case tiDetailDekKeyCacheMiss: 1144 case tiDetailDekIVMismatch: 1145 perr->ioerr.error_type = pccb->scsiStatus; 1146 break; 1147 default: 1148 printf("%s: Unrecognized encrypted IO completion error status: %d\n", __FUNCTION__, pccb->scsiStatus); 1149 perr->ioerr.error_type = 0xffffffff; 1150 break; 1151 } 1152 1153 /* Link IO err into queue */ 1154 AG_SPIN_LOCK_IRQ(&pCard->ioerr_queue_lock, flags); 1155 list_add_tail(&perr->list, &pCard->ioerr_queue); 1156 AG_SPIN_UNLOCK_IRQ(&pCard->ioerr_queue_lock, flags); 1157 1158 /* Notify any wait queue waiters that an IO error has occurred */ 1159 atomic_inc(&ioerr_queue_count); 1160 wake_up_interruptible(&ioerr_waitq); 1161 1162 } 1163 #endif 1164 #endif 1165