1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright IBM Corp. 2001, 2018 4 * Author(s): Robert Burroughs 5 * Eric Rossman (edrossma@us.ibm.com) 6 * Cornelia Huck <cornelia.huck@de.ibm.com> 7 * 8 * Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com) 9 * Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com> 10 * Ralph Wuerthner <rwuerthn@de.ibm.com> 11 * MSGTYPE restruct: Holger Dengler <hd@linux.vnet.ibm.com> 12 * Multiple device nodes: Harald Freudenberger <freude@linux.ibm.com> 13 */ 14 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/interrupt.h> 18 #include <linux/miscdevice.h> 19 #include <linux/fs.h> 20 #include <linux/compat.h> 21 #include <linux/slab.h> 22 #include <linux/atomic.h> 23 #include <linux/uaccess.h> 24 #include <linux/hw_random.h> 25 #include <linux/debugfs.h> 26 #include <linux/cdev.h> 27 #include <linux/ctype.h> 28 #include <linux/capability.h> 29 #include <asm/debug.h> 30 31 #define CREATE_TRACE_POINTS 32 #include <asm/trace/zcrypt.h> 33 34 #include "zcrypt_api.h" 35 #include "zcrypt_debug.h" 36 37 #include "zcrypt_msgtype6.h" 38 #include "zcrypt_msgtype50.h" 39 #include "zcrypt_ccamisc.h" 40 #include "zcrypt_ep11misc.h" 41 42 /* 43 * Module description. 44 */ 45 MODULE_AUTHOR("IBM Corporation"); 46 MODULE_DESCRIPTION("Cryptographic Coprocessor interface, " \ 47 "Copyright IBM Corp. 2001, 2012"); 48 MODULE_LICENSE("GPL"); 49 50 /* 51 * zcrypt tracepoint functions 52 */ 53 EXPORT_TRACEPOINT_SYMBOL(s390_zcrypt_req); 54 EXPORT_TRACEPOINT_SYMBOL(s390_zcrypt_rep); 55 56 DEFINE_SPINLOCK(zcrypt_list_lock); 57 LIST_HEAD(zcrypt_card_list); 58 59 static atomic_t zcrypt_open_count = ATOMIC_INIT(0); 60 static atomic_t zcrypt_rescan_count = ATOMIC_INIT(0); 61 62 atomic_t zcrypt_rescan_req = ATOMIC_INIT(0); 63 EXPORT_SYMBOL(zcrypt_rescan_req); 64 65 static LIST_HEAD(zcrypt_ops_list); 66 67 /* Zcrypt related debug feature stuff. */ 68 debug_info_t *zcrypt_dbf_info; 69 70 /* 71 * Process a rescan of the transport layer. 72 * 73 * Returns 1, if the rescan has been processed, otherwise 0. 74 */ 75 static inline int zcrypt_process_rescan(void) 76 { 77 if (atomic_read(&zcrypt_rescan_req)) { 78 atomic_set(&zcrypt_rescan_req, 0); 79 atomic_inc(&zcrypt_rescan_count); 80 ap_bus_force_rescan(); 81 ZCRYPT_DBF_INFO("%s rescan count=%07d\n", __func__, 82 atomic_inc_return(&zcrypt_rescan_count)); 83 return 1; 84 } 85 return 0; 86 } 87 88 void zcrypt_msgtype_register(struct zcrypt_ops *zops) 89 { 90 list_add_tail(&zops->list, &zcrypt_ops_list); 91 } 92 93 void zcrypt_msgtype_unregister(struct zcrypt_ops *zops) 94 { 95 list_del_init(&zops->list); 96 } 97 98 struct zcrypt_ops *zcrypt_msgtype(unsigned char *name, int variant) 99 { 100 struct zcrypt_ops *zops; 101 102 list_for_each_entry(zops, &zcrypt_ops_list, list) 103 if (zops->variant == variant && 104 (!strncmp(zops->name, name, sizeof(zops->name)))) 105 return zops; 106 return NULL; 107 } 108 EXPORT_SYMBOL(zcrypt_msgtype); 109 110 /* 111 * Multi device nodes extension functions. 112 */ 113 114 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 115 116 struct zcdn_device; 117 118 static struct class *zcrypt_class; 119 static dev_t zcrypt_devt; 120 static struct cdev zcrypt_cdev; 121 122 struct zcdn_device { 123 struct device device; 124 struct ap_perms perms; 125 }; 126 127 #define to_zcdn_dev(x) container_of((x), struct zcdn_device, device) 128 129 #define ZCDN_MAX_NAME 32 130 131 static int zcdn_create(const char *name); 132 static int zcdn_destroy(const char *name); 133 134 /* 135 * Find zcdn device by name. 136 * Returns reference to the zcdn device which needs to be released 137 * with put_device() after use. 138 */ 139 static inline struct zcdn_device *find_zcdndev_by_name(const char *name) 140 { 141 struct device *dev = class_find_device_by_name(zcrypt_class, name); 142 143 return dev ? to_zcdn_dev(dev) : NULL; 144 } 145 146 /* 147 * Find zcdn device by devt value. 148 * Returns reference to the zcdn device which needs to be released 149 * with put_device() after use. 150 */ 151 static inline struct zcdn_device *find_zcdndev_by_devt(dev_t devt) 152 { 153 struct device *dev = class_find_device_by_devt(zcrypt_class, devt); 154 155 return dev ? to_zcdn_dev(dev) : NULL; 156 } 157 158 static ssize_t ioctlmask_show(struct device *dev, 159 struct device_attribute *attr, 160 char *buf) 161 { 162 int i, rc; 163 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 164 165 if (mutex_lock_interruptible(&ap_perms_mutex)) 166 return -ERESTARTSYS; 167 168 buf[0] = '0'; 169 buf[1] = 'x'; 170 for (i = 0; i < sizeof(zcdndev->perms.ioctlm) / sizeof(long); i++) 171 snprintf(buf + 2 + 2 * i * sizeof(long), 172 PAGE_SIZE - 2 - 2 * i * sizeof(long), 173 "%016lx", zcdndev->perms.ioctlm[i]); 174 buf[2 + 2 * i * sizeof(long)] = '\n'; 175 buf[2 + 2 * i * sizeof(long) + 1] = '\0'; 176 rc = 2 + 2 * i * sizeof(long) + 1; 177 178 mutex_unlock(&ap_perms_mutex); 179 180 return rc; 181 } 182 183 static ssize_t ioctlmask_store(struct device *dev, 184 struct device_attribute *attr, 185 const char *buf, size_t count) 186 { 187 int rc; 188 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 189 190 rc = ap_parse_mask_str(buf, zcdndev->perms.ioctlm, 191 AP_IOCTLS, &ap_perms_mutex); 192 if (rc) 193 return rc; 194 195 return count; 196 } 197 198 static DEVICE_ATTR_RW(ioctlmask); 199 200 static ssize_t apmask_show(struct device *dev, 201 struct device_attribute *attr, 202 char *buf) 203 { 204 int i, rc; 205 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 206 207 if (mutex_lock_interruptible(&ap_perms_mutex)) 208 return -ERESTARTSYS; 209 210 buf[0] = '0'; 211 buf[1] = 'x'; 212 for (i = 0; i < sizeof(zcdndev->perms.apm) / sizeof(long); i++) 213 snprintf(buf + 2 + 2 * i * sizeof(long), 214 PAGE_SIZE - 2 - 2 * i * sizeof(long), 215 "%016lx", zcdndev->perms.apm[i]); 216 buf[2 + 2 * i * sizeof(long)] = '\n'; 217 buf[2 + 2 * i * sizeof(long) + 1] = '\0'; 218 rc = 2 + 2 * i * sizeof(long) + 1; 219 220 mutex_unlock(&ap_perms_mutex); 221 222 return rc; 223 } 224 225 static ssize_t apmask_store(struct device *dev, 226 struct device_attribute *attr, 227 const char *buf, size_t count) 228 { 229 int rc; 230 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 231 232 rc = ap_parse_mask_str(buf, zcdndev->perms.apm, 233 AP_DEVICES, &ap_perms_mutex); 234 if (rc) 235 return rc; 236 237 return count; 238 } 239 240 static DEVICE_ATTR_RW(apmask); 241 242 static ssize_t aqmask_show(struct device *dev, 243 struct device_attribute *attr, 244 char *buf) 245 { 246 int i, rc; 247 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 248 249 if (mutex_lock_interruptible(&ap_perms_mutex)) 250 return -ERESTARTSYS; 251 252 buf[0] = '0'; 253 buf[1] = 'x'; 254 for (i = 0; i < sizeof(zcdndev->perms.aqm) / sizeof(long); i++) 255 snprintf(buf + 2 + 2 * i * sizeof(long), 256 PAGE_SIZE - 2 - 2 * i * sizeof(long), 257 "%016lx", zcdndev->perms.aqm[i]); 258 buf[2 + 2 * i * sizeof(long)] = '\n'; 259 buf[2 + 2 * i * sizeof(long) + 1] = '\0'; 260 rc = 2 + 2 * i * sizeof(long) + 1; 261 262 mutex_unlock(&ap_perms_mutex); 263 264 return rc; 265 } 266 267 static ssize_t aqmask_store(struct device *dev, 268 struct device_attribute *attr, 269 const char *buf, size_t count) 270 { 271 int rc; 272 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 273 274 rc = ap_parse_mask_str(buf, zcdndev->perms.aqm, 275 AP_DOMAINS, &ap_perms_mutex); 276 if (rc) 277 return rc; 278 279 return count; 280 } 281 282 static DEVICE_ATTR_RW(aqmask); 283 284 static ssize_t admask_show(struct device *dev, 285 struct device_attribute *attr, 286 char *buf) 287 { 288 int i, rc; 289 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 290 291 if (mutex_lock_interruptible(&ap_perms_mutex)) 292 return -ERESTARTSYS; 293 294 buf[0] = '0'; 295 buf[1] = 'x'; 296 for (i = 0; i < sizeof(zcdndev->perms.adm) / sizeof(long); i++) 297 snprintf(buf + 2 + 2 * i * sizeof(long), 298 PAGE_SIZE - 2 - 2 * i * sizeof(long), 299 "%016lx", zcdndev->perms.adm[i]); 300 buf[2 + 2 * i * sizeof(long)] = '\n'; 301 buf[2 + 2 * i * sizeof(long) + 1] = '\0'; 302 rc = 2 + 2 * i * sizeof(long) + 1; 303 304 mutex_unlock(&ap_perms_mutex); 305 306 return rc; 307 } 308 309 static ssize_t admask_store(struct device *dev, 310 struct device_attribute *attr, 311 const char *buf, size_t count) 312 { 313 int rc; 314 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 315 316 rc = ap_parse_mask_str(buf, zcdndev->perms.adm, 317 AP_DOMAINS, &ap_perms_mutex); 318 if (rc) 319 return rc; 320 321 return count; 322 } 323 324 static DEVICE_ATTR_RW(admask); 325 326 static struct attribute *zcdn_dev_attrs[] = { 327 &dev_attr_ioctlmask.attr, 328 &dev_attr_apmask.attr, 329 &dev_attr_aqmask.attr, 330 &dev_attr_admask.attr, 331 NULL 332 }; 333 334 static struct attribute_group zcdn_dev_attr_group = { 335 .attrs = zcdn_dev_attrs 336 }; 337 338 static const struct attribute_group *zcdn_dev_attr_groups[] = { 339 &zcdn_dev_attr_group, 340 NULL 341 }; 342 343 static ssize_t zcdn_create_store(struct class *class, 344 struct class_attribute *attr, 345 const char *buf, size_t count) 346 { 347 int rc; 348 char name[ZCDN_MAX_NAME]; 349 350 strncpy(name, skip_spaces(buf), sizeof(name)); 351 name[sizeof(name) - 1] = '\0'; 352 353 rc = zcdn_create(strim(name)); 354 355 return rc ? rc : count; 356 } 357 358 static const struct class_attribute class_attr_zcdn_create = 359 __ATTR(create, 0600, NULL, zcdn_create_store); 360 361 static ssize_t zcdn_destroy_store(struct class *class, 362 struct class_attribute *attr, 363 const char *buf, size_t count) 364 { 365 int rc; 366 char name[ZCDN_MAX_NAME]; 367 368 strncpy(name, skip_spaces(buf), sizeof(name)); 369 name[sizeof(name) - 1] = '\0'; 370 371 rc = zcdn_destroy(strim(name)); 372 373 return rc ? rc : count; 374 } 375 376 static const struct class_attribute class_attr_zcdn_destroy = 377 __ATTR(destroy, 0600, NULL, zcdn_destroy_store); 378 379 static void zcdn_device_release(struct device *dev) 380 { 381 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 382 383 ZCRYPT_DBF_INFO("%s releasing zcdn device %d:%d\n", 384 __func__, MAJOR(dev->devt), MINOR(dev->devt)); 385 386 kfree(zcdndev); 387 } 388 389 static int zcdn_create(const char *name) 390 { 391 dev_t devt; 392 int i, rc = 0; 393 char nodename[ZCDN_MAX_NAME]; 394 struct zcdn_device *zcdndev; 395 396 if (mutex_lock_interruptible(&ap_perms_mutex)) 397 return -ERESTARTSYS; 398 399 /* check if device node with this name already exists */ 400 if (name[0]) { 401 zcdndev = find_zcdndev_by_name(name); 402 if (zcdndev) { 403 put_device(&zcdndev->device); 404 rc = -EEXIST; 405 goto unlockout; 406 } 407 } 408 409 /* find an unused minor number */ 410 for (i = 0; i < ZCRYPT_MAX_MINOR_NODES; i++) { 411 devt = MKDEV(MAJOR(zcrypt_devt), MINOR(zcrypt_devt) + i); 412 zcdndev = find_zcdndev_by_devt(devt); 413 if (zcdndev) 414 put_device(&zcdndev->device); 415 else 416 break; 417 } 418 if (i == ZCRYPT_MAX_MINOR_NODES) { 419 rc = -ENOSPC; 420 goto unlockout; 421 } 422 423 /* alloc and prepare a new zcdn device */ 424 zcdndev = kzalloc(sizeof(*zcdndev), GFP_KERNEL); 425 if (!zcdndev) { 426 rc = -ENOMEM; 427 goto unlockout; 428 } 429 zcdndev->device.release = zcdn_device_release; 430 zcdndev->device.class = zcrypt_class; 431 zcdndev->device.devt = devt; 432 zcdndev->device.groups = zcdn_dev_attr_groups; 433 if (name[0]) 434 strncpy(nodename, name, sizeof(nodename)); 435 else 436 snprintf(nodename, sizeof(nodename), 437 ZCRYPT_NAME "_%d", (int)MINOR(devt)); 438 nodename[sizeof(nodename) - 1] = '\0'; 439 if (dev_set_name(&zcdndev->device, nodename)) { 440 rc = -EINVAL; 441 goto unlockout; 442 } 443 rc = device_register(&zcdndev->device); 444 if (rc) { 445 put_device(&zcdndev->device); 446 goto unlockout; 447 } 448 449 ZCRYPT_DBF_INFO("%s created zcdn device %d:%d\n", 450 __func__, MAJOR(devt), MINOR(devt)); 451 452 unlockout: 453 mutex_unlock(&ap_perms_mutex); 454 return rc; 455 } 456 457 static int zcdn_destroy(const char *name) 458 { 459 int rc = 0; 460 struct zcdn_device *zcdndev; 461 462 if (mutex_lock_interruptible(&ap_perms_mutex)) 463 return -ERESTARTSYS; 464 465 /* try to find this zcdn device */ 466 zcdndev = find_zcdndev_by_name(name); 467 if (!zcdndev) { 468 rc = -ENOENT; 469 goto unlockout; 470 } 471 472 /* 473 * The zcdn device is not hard destroyed. It is subject to 474 * reference counting and thus just needs to be unregistered. 475 */ 476 put_device(&zcdndev->device); 477 device_unregister(&zcdndev->device); 478 479 unlockout: 480 mutex_unlock(&ap_perms_mutex); 481 return rc; 482 } 483 484 static void zcdn_destroy_all(void) 485 { 486 int i; 487 dev_t devt; 488 struct zcdn_device *zcdndev; 489 490 mutex_lock(&ap_perms_mutex); 491 for (i = 0; i < ZCRYPT_MAX_MINOR_NODES; i++) { 492 devt = MKDEV(MAJOR(zcrypt_devt), MINOR(zcrypt_devt) + i); 493 zcdndev = find_zcdndev_by_devt(devt); 494 if (zcdndev) { 495 put_device(&zcdndev->device); 496 device_unregister(&zcdndev->device); 497 } 498 } 499 mutex_unlock(&ap_perms_mutex); 500 } 501 502 #endif 503 504 /* 505 * zcrypt_read (): Not supported beyond zcrypt 1.3.1. 506 * 507 * This function is not supported beyond zcrypt 1.3.1. 508 */ 509 static ssize_t zcrypt_read(struct file *filp, char __user *buf, 510 size_t count, loff_t *f_pos) 511 { 512 return -EPERM; 513 } 514 515 /* 516 * zcrypt_write(): Not allowed. 517 * 518 * Write is not allowed 519 */ 520 static ssize_t zcrypt_write(struct file *filp, const char __user *buf, 521 size_t count, loff_t *f_pos) 522 { 523 return -EPERM; 524 } 525 526 /* 527 * zcrypt_open(): Count number of users. 528 * 529 * Device open function to count number of users. 530 */ 531 static int zcrypt_open(struct inode *inode, struct file *filp) 532 { 533 struct ap_perms *perms = &ap_perms; 534 535 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 536 if (filp->f_inode->i_cdev == &zcrypt_cdev) { 537 struct zcdn_device *zcdndev; 538 539 if (mutex_lock_interruptible(&ap_perms_mutex)) 540 return -ERESTARTSYS; 541 zcdndev = find_zcdndev_by_devt(filp->f_inode->i_rdev); 542 /* find returns a reference, no get_device() needed */ 543 mutex_unlock(&ap_perms_mutex); 544 if (zcdndev) 545 perms = &zcdndev->perms; 546 } 547 #endif 548 filp->private_data = (void *)perms; 549 550 atomic_inc(&zcrypt_open_count); 551 return stream_open(inode, filp); 552 } 553 554 /* 555 * zcrypt_release(): Count number of users. 556 * 557 * Device close function to count number of users. 558 */ 559 static int zcrypt_release(struct inode *inode, struct file *filp) 560 { 561 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 562 if (filp->f_inode->i_cdev == &zcrypt_cdev) { 563 struct zcdn_device *zcdndev; 564 565 mutex_lock(&ap_perms_mutex); 566 zcdndev = find_zcdndev_by_devt(filp->f_inode->i_rdev); 567 mutex_unlock(&ap_perms_mutex); 568 if (zcdndev) { 569 /* 2 puts here: one for find, one for open */ 570 put_device(&zcdndev->device); 571 put_device(&zcdndev->device); 572 } 573 } 574 #endif 575 576 atomic_dec(&zcrypt_open_count); 577 return 0; 578 } 579 580 static inline int zcrypt_check_ioctl(struct ap_perms *perms, 581 unsigned int cmd) 582 { 583 int rc = -EPERM; 584 int ioctlnr = (cmd & _IOC_NRMASK) >> _IOC_NRSHIFT; 585 586 if (ioctlnr > 0 && ioctlnr < AP_IOCTLS) { 587 if (test_bit_inv(ioctlnr, perms->ioctlm)) 588 rc = 0; 589 } 590 591 if (rc) 592 ZCRYPT_DBF_WARN("%s ioctl check failed: ioctlnr=0x%04x rc=%d\n", 593 __func__, ioctlnr, rc); 594 595 return rc; 596 } 597 598 static inline bool zcrypt_check_card(struct ap_perms *perms, int card) 599 { 600 return test_bit_inv(card, perms->apm) ? true : false; 601 } 602 603 static inline bool zcrypt_check_queue(struct ap_perms *perms, int queue) 604 { 605 return test_bit_inv(queue, perms->aqm) ? true : false; 606 } 607 608 static inline struct zcrypt_queue *zcrypt_pick_queue(struct zcrypt_card *zc, 609 struct zcrypt_queue *zq, 610 struct module **pmod, 611 unsigned int weight) 612 { 613 if (!zq || !try_module_get(zq->queue->ap_dev.device.driver->owner)) 614 return NULL; 615 zcrypt_queue_get(zq); 616 get_device(&zq->queue->ap_dev.device); 617 atomic_add(weight, &zc->load); 618 atomic_add(weight, &zq->load); 619 zq->request_count++; 620 *pmod = zq->queue->ap_dev.device.driver->owner; 621 return zq; 622 } 623 624 static inline void zcrypt_drop_queue(struct zcrypt_card *zc, 625 struct zcrypt_queue *zq, 626 struct module *mod, 627 unsigned int weight) 628 { 629 zq->request_count--; 630 atomic_sub(weight, &zc->load); 631 atomic_sub(weight, &zq->load); 632 put_device(&zq->queue->ap_dev.device); 633 zcrypt_queue_put(zq); 634 module_put(mod); 635 } 636 637 static inline bool zcrypt_card_compare(struct zcrypt_card *zc, 638 struct zcrypt_card *pref_zc, 639 unsigned int weight, 640 unsigned int pref_weight) 641 { 642 if (!pref_zc) 643 return true; 644 weight += atomic_read(&zc->load); 645 pref_weight += atomic_read(&pref_zc->load); 646 if (weight == pref_weight) 647 return atomic64_read(&zc->card->total_request_count) < 648 atomic64_read(&pref_zc->card->total_request_count); 649 return weight < pref_weight; 650 } 651 652 static inline bool zcrypt_queue_compare(struct zcrypt_queue *zq, 653 struct zcrypt_queue *pref_zq, 654 unsigned int weight, 655 unsigned int pref_weight) 656 { 657 if (!pref_zq) 658 return true; 659 weight += atomic_read(&zq->load); 660 pref_weight += atomic_read(&pref_zq->load); 661 if (weight == pref_weight) 662 return zq->queue->total_request_count < 663 pref_zq->queue->total_request_count; 664 return weight < pref_weight; 665 } 666 667 /* 668 * zcrypt ioctls. 669 */ 670 static long zcrypt_rsa_modexpo(struct ap_perms *perms, 671 struct zcrypt_track *tr, 672 struct ica_rsa_modexpo *mex) 673 { 674 struct zcrypt_card *zc, *pref_zc; 675 struct zcrypt_queue *zq, *pref_zq; 676 struct ap_message ap_msg; 677 unsigned int wgt = 0, pref_wgt = 0; 678 unsigned int func_code; 679 int cpen, qpen, qid = 0, rc = -ENODEV; 680 struct module *mod; 681 682 trace_s390_zcrypt_req(mex, TP_ICARSAMODEXPO); 683 684 ap_init_message(&ap_msg); 685 686 #ifdef CONFIG_ZCRYPT_DEBUG 687 if (tr && tr->fi.cmd) 688 ap_msg.fi.cmd = tr->fi.cmd; 689 #endif 690 691 if (mex->outputdatalength < mex->inputdatalength) { 692 func_code = 0; 693 rc = -EINVAL; 694 goto out; 695 } 696 697 /* 698 * As long as outputdatalength is big enough, we can set the 699 * outputdatalength equal to the inputdatalength, since that is the 700 * number of bytes we will copy in any case 701 */ 702 mex->outputdatalength = mex->inputdatalength; 703 704 rc = get_rsa_modex_fc(mex, &func_code); 705 if (rc) 706 goto out; 707 708 pref_zc = NULL; 709 pref_zq = NULL; 710 spin_lock(&zcrypt_list_lock); 711 for_each_zcrypt_card(zc) { 712 /* Check for usable accelarator or CCA card */ 713 if (!zc->online || !zc->card->config || zc->card->chkstop || 714 !(zc->card->functions & 0x18000000)) 715 continue; 716 /* Check for size limits */ 717 if (zc->min_mod_size > mex->inputdatalength || 718 zc->max_mod_size < mex->inputdatalength) 719 continue; 720 /* check if device node has admission for this card */ 721 if (!zcrypt_check_card(perms, zc->card->id)) 722 continue; 723 /* get weight index of the card device */ 724 wgt = zc->speed_rating[func_code]; 725 /* penalty if this msg was previously sent via this card */ 726 cpen = (tr && tr->again_counter && tr->last_qid && 727 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 728 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 729 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 730 continue; 731 for_each_zcrypt_queue(zq, zc) { 732 /* check if device is usable and eligible */ 733 if (!zq->online || !zq->ops->rsa_modexpo || 734 !zq->queue->config || zq->queue->chkstop) 735 continue; 736 /* check if device node has admission for this queue */ 737 if (!zcrypt_check_queue(perms, 738 AP_QID_QUEUE(zq->queue->qid))) 739 continue; 740 /* penalty if the msg was previously sent at this qid */ 741 qpen = (tr && tr->again_counter && tr->last_qid && 742 tr->last_qid == zq->queue->qid) ? 743 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 744 if (!zcrypt_queue_compare(zq, pref_zq, 745 wgt + cpen + qpen, pref_wgt)) 746 continue; 747 pref_zc = zc; 748 pref_zq = zq; 749 pref_wgt = wgt + cpen + qpen; 750 } 751 } 752 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 753 spin_unlock(&zcrypt_list_lock); 754 755 if (!pref_zq) { 756 ZCRYPT_DBF_DBG("%s no matching queue found => ENODEV\n", 757 __func__); 758 rc = -ENODEV; 759 goto out; 760 } 761 762 qid = pref_zq->queue->qid; 763 rc = pref_zq->ops->rsa_modexpo(pref_zq, mex, &ap_msg); 764 765 spin_lock(&zcrypt_list_lock); 766 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 767 spin_unlock(&zcrypt_list_lock); 768 769 out: 770 ap_release_message(&ap_msg); 771 if (tr) { 772 tr->last_rc = rc; 773 tr->last_qid = qid; 774 } 775 trace_s390_zcrypt_rep(mex, func_code, rc, 776 AP_QID_CARD(qid), AP_QID_QUEUE(qid)); 777 return rc; 778 } 779 780 static long zcrypt_rsa_crt(struct ap_perms *perms, 781 struct zcrypt_track *tr, 782 struct ica_rsa_modexpo_crt *crt) 783 { 784 struct zcrypt_card *zc, *pref_zc; 785 struct zcrypt_queue *zq, *pref_zq; 786 struct ap_message ap_msg; 787 unsigned int wgt = 0, pref_wgt = 0; 788 unsigned int func_code; 789 int cpen, qpen, qid = 0, rc = -ENODEV; 790 struct module *mod; 791 792 trace_s390_zcrypt_req(crt, TP_ICARSACRT); 793 794 ap_init_message(&ap_msg); 795 796 #ifdef CONFIG_ZCRYPT_DEBUG 797 if (tr && tr->fi.cmd) 798 ap_msg.fi.cmd = tr->fi.cmd; 799 #endif 800 801 if (crt->outputdatalength < crt->inputdatalength) { 802 func_code = 0; 803 rc = -EINVAL; 804 goto out; 805 } 806 807 /* 808 * As long as outputdatalength is big enough, we can set the 809 * outputdatalength equal to the inputdatalength, since that is the 810 * number of bytes we will copy in any case 811 */ 812 crt->outputdatalength = crt->inputdatalength; 813 814 rc = get_rsa_crt_fc(crt, &func_code); 815 if (rc) 816 goto out; 817 818 pref_zc = NULL; 819 pref_zq = NULL; 820 spin_lock(&zcrypt_list_lock); 821 for_each_zcrypt_card(zc) { 822 /* Check for usable accelarator or CCA card */ 823 if (!zc->online || !zc->card->config || zc->card->chkstop || 824 !(zc->card->functions & 0x18000000)) 825 continue; 826 /* Check for size limits */ 827 if (zc->min_mod_size > crt->inputdatalength || 828 zc->max_mod_size < crt->inputdatalength) 829 continue; 830 /* check if device node has admission for this card */ 831 if (!zcrypt_check_card(perms, zc->card->id)) 832 continue; 833 /* get weight index of the card device */ 834 wgt = zc->speed_rating[func_code]; 835 /* penalty if this msg was previously sent via this card */ 836 cpen = (tr && tr->again_counter && tr->last_qid && 837 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 838 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 839 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 840 continue; 841 for_each_zcrypt_queue(zq, zc) { 842 /* check if device is usable and eligible */ 843 if (!zq->online || !zq->ops->rsa_modexpo_crt || 844 !zq->queue->config || zq->queue->chkstop) 845 continue; 846 /* check if device node has admission for this queue */ 847 if (!zcrypt_check_queue(perms, 848 AP_QID_QUEUE(zq->queue->qid))) 849 continue; 850 /* penalty if the msg was previously sent at this qid */ 851 qpen = (tr && tr->again_counter && tr->last_qid && 852 tr->last_qid == zq->queue->qid) ? 853 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 854 if (!zcrypt_queue_compare(zq, pref_zq, 855 wgt + cpen + qpen, pref_wgt)) 856 continue; 857 pref_zc = zc; 858 pref_zq = zq; 859 pref_wgt = wgt + cpen + qpen; 860 } 861 } 862 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 863 spin_unlock(&zcrypt_list_lock); 864 865 if (!pref_zq) { 866 ZCRYPT_DBF_DBG("%s no matching queue found => ENODEV\n", 867 __func__); 868 rc = -ENODEV; 869 goto out; 870 } 871 872 qid = pref_zq->queue->qid; 873 rc = pref_zq->ops->rsa_modexpo_crt(pref_zq, crt, &ap_msg); 874 875 spin_lock(&zcrypt_list_lock); 876 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 877 spin_unlock(&zcrypt_list_lock); 878 879 out: 880 ap_release_message(&ap_msg); 881 if (tr) { 882 tr->last_rc = rc; 883 tr->last_qid = qid; 884 } 885 trace_s390_zcrypt_rep(crt, func_code, rc, 886 AP_QID_CARD(qid), AP_QID_QUEUE(qid)); 887 return rc; 888 } 889 890 static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms, 891 struct zcrypt_track *tr, 892 struct ica_xcRB *xcrb) 893 { 894 struct zcrypt_card *zc, *pref_zc; 895 struct zcrypt_queue *zq, *pref_zq; 896 struct ap_message ap_msg; 897 unsigned int wgt = 0, pref_wgt = 0; 898 unsigned int func_code; 899 unsigned short *domain, tdom; 900 int cpen, qpen, qid = 0, rc = -ENODEV; 901 struct module *mod; 902 903 trace_s390_zcrypt_req(xcrb, TB_ZSECSENDCPRB); 904 905 xcrb->status = 0; 906 ap_init_message(&ap_msg); 907 908 #ifdef CONFIG_ZCRYPT_DEBUG 909 if (tr && tr->fi.cmd) 910 ap_msg.fi.cmd = tr->fi.cmd; 911 if (tr && tr->fi.action == AP_FI_ACTION_CCA_AGENT_FF) { 912 ZCRYPT_DBF_WARN("%s fi cmd 0x%04x: forcing invalid agent_ID 'FF'\n", 913 __func__, tr->fi.cmd); 914 xcrb->agent_ID = 0x4646; 915 } 916 #endif 917 918 rc = prep_cca_ap_msg(userspace, xcrb, &ap_msg, &func_code, &domain); 919 if (rc) 920 goto out; 921 922 tdom = *domain; 923 if (perms != &ap_perms && tdom < AP_DOMAINS) { 924 if (ap_msg.flags & AP_MSG_FLAG_ADMIN) { 925 if (!test_bit_inv(tdom, perms->adm)) { 926 rc = -ENODEV; 927 goto out; 928 } 929 } else if ((ap_msg.flags & AP_MSG_FLAG_USAGE) == 0) { 930 rc = -EOPNOTSUPP; 931 goto out; 932 } 933 } 934 /* 935 * If a valid target domain is set and this domain is NOT a usage 936 * domain but a control only domain, autoselect target domain. 937 */ 938 if (tdom < AP_DOMAINS && 939 !ap_test_config_usage_domain(tdom) && 940 ap_test_config_ctrl_domain(tdom)) 941 tdom = AUTOSEL_DOM; 942 943 pref_zc = NULL; 944 pref_zq = NULL; 945 spin_lock(&zcrypt_list_lock); 946 for_each_zcrypt_card(zc) { 947 /* Check for usable CCA card */ 948 if (!zc->online || !zc->card->config || zc->card->chkstop || 949 !(zc->card->functions & 0x10000000)) 950 continue; 951 /* Check for user selected CCA card */ 952 if (xcrb->user_defined != AUTOSELECT && 953 xcrb->user_defined != zc->card->id) 954 continue; 955 /* check if request size exceeds card max msg size */ 956 if (ap_msg.len > zc->card->maxmsgsize) 957 continue; 958 /* check if device node has admission for this card */ 959 if (!zcrypt_check_card(perms, zc->card->id)) 960 continue; 961 /* get weight index of the card device */ 962 wgt = speed_idx_cca(func_code) * zc->speed_rating[SECKEY]; 963 /* penalty if this msg was previously sent via this card */ 964 cpen = (tr && tr->again_counter && tr->last_qid && 965 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 966 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 967 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 968 continue; 969 for_each_zcrypt_queue(zq, zc) { 970 /* check for device usable and eligible */ 971 if (!zq->online || !zq->ops->send_cprb || 972 !zq->queue->config || zq->queue->chkstop || 973 (tdom != AUTOSEL_DOM && 974 tdom != AP_QID_QUEUE(zq->queue->qid))) 975 continue; 976 /* check if device node has admission for this queue */ 977 if (!zcrypt_check_queue(perms, 978 AP_QID_QUEUE(zq->queue->qid))) 979 continue; 980 /* penalty if the msg was previously sent at this qid */ 981 qpen = (tr && tr->again_counter && tr->last_qid && 982 tr->last_qid == zq->queue->qid) ? 983 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 984 if (!zcrypt_queue_compare(zq, pref_zq, 985 wgt + cpen + qpen, pref_wgt)) 986 continue; 987 pref_zc = zc; 988 pref_zq = zq; 989 pref_wgt = wgt + cpen + qpen; 990 } 991 } 992 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 993 spin_unlock(&zcrypt_list_lock); 994 995 if (!pref_zq) { 996 ZCRYPT_DBF_DBG("%s no match for address %02x.%04x => ENODEV\n", 997 __func__, xcrb->user_defined, *domain); 998 rc = -ENODEV; 999 goto out; 1000 } 1001 1002 /* in case of auto select, provide the correct domain */ 1003 qid = pref_zq->queue->qid; 1004 if (*domain == AUTOSEL_DOM) 1005 *domain = AP_QID_QUEUE(qid); 1006 1007 #ifdef CONFIG_ZCRYPT_DEBUG 1008 if (tr && tr->fi.action == AP_FI_ACTION_CCA_DOM_INVAL) { 1009 ZCRYPT_DBF_WARN("%s fi cmd 0x%04x: forcing invalid domain\n", 1010 __func__, tr->fi.cmd); 1011 *domain = 99; 1012 } 1013 #endif 1014 1015 rc = pref_zq->ops->send_cprb(userspace, pref_zq, xcrb, &ap_msg); 1016 1017 spin_lock(&zcrypt_list_lock); 1018 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 1019 spin_unlock(&zcrypt_list_lock); 1020 1021 out: 1022 ap_release_message(&ap_msg); 1023 if (tr) { 1024 tr->last_rc = rc; 1025 tr->last_qid = qid; 1026 } 1027 trace_s390_zcrypt_rep(xcrb, func_code, rc, 1028 AP_QID_CARD(qid), AP_QID_QUEUE(qid)); 1029 return rc; 1030 } 1031 1032 long zcrypt_send_cprb(struct ica_xcRB *xcrb) 1033 { 1034 return _zcrypt_send_cprb(false, &ap_perms, NULL, xcrb); 1035 } 1036 EXPORT_SYMBOL(zcrypt_send_cprb); 1037 1038 static bool is_desired_ep11_card(unsigned int dev_id, 1039 unsigned short target_num, 1040 struct ep11_target_dev *targets) 1041 { 1042 while (target_num-- > 0) { 1043 if (targets->ap_id == dev_id || targets->ap_id == AUTOSEL_AP) 1044 return true; 1045 targets++; 1046 } 1047 return false; 1048 } 1049 1050 static bool is_desired_ep11_queue(unsigned int dev_qid, 1051 unsigned short target_num, 1052 struct ep11_target_dev *targets) 1053 { 1054 int card = AP_QID_CARD(dev_qid), dom = AP_QID_QUEUE(dev_qid); 1055 1056 while (target_num-- > 0) { 1057 if ((targets->ap_id == card || targets->ap_id == AUTOSEL_AP) && 1058 (targets->dom_id == dom || targets->dom_id == AUTOSEL_DOM)) 1059 return true; 1060 targets++; 1061 } 1062 return false; 1063 } 1064 1065 static long _zcrypt_send_ep11_cprb(bool userspace, struct ap_perms *perms, 1066 struct zcrypt_track *tr, 1067 struct ep11_urb *xcrb) 1068 { 1069 struct zcrypt_card *zc, *pref_zc; 1070 struct zcrypt_queue *zq, *pref_zq; 1071 struct ep11_target_dev *targets; 1072 unsigned short target_num; 1073 unsigned int wgt = 0, pref_wgt = 0; 1074 unsigned int func_code, domain; 1075 struct ap_message ap_msg; 1076 int cpen, qpen, qid = 0, rc = -ENODEV; 1077 struct module *mod; 1078 1079 trace_s390_zcrypt_req(xcrb, TP_ZSENDEP11CPRB); 1080 1081 ap_init_message(&ap_msg); 1082 1083 #ifdef CONFIG_ZCRYPT_DEBUG 1084 if (tr && tr->fi.cmd) 1085 ap_msg.fi.cmd = tr->fi.cmd; 1086 #endif 1087 1088 target_num = (unsigned short)xcrb->targets_num; 1089 1090 /* empty list indicates autoselect (all available targets) */ 1091 targets = NULL; 1092 if (target_num != 0) { 1093 struct ep11_target_dev __user *uptr; 1094 1095 targets = kcalloc(target_num, sizeof(*targets), GFP_KERNEL); 1096 if (!targets) { 1097 func_code = 0; 1098 rc = -ENOMEM; 1099 goto out; 1100 } 1101 1102 uptr = (struct ep11_target_dev __force __user *)xcrb->targets; 1103 if (z_copy_from_user(userspace, targets, uptr, 1104 target_num * sizeof(*targets))) { 1105 func_code = 0; 1106 rc = -EFAULT; 1107 goto out_free; 1108 } 1109 } 1110 1111 rc = prep_ep11_ap_msg(userspace, xcrb, &ap_msg, &func_code, &domain); 1112 if (rc) 1113 goto out_free; 1114 1115 if (perms != &ap_perms && domain < AUTOSEL_DOM) { 1116 if (ap_msg.flags & AP_MSG_FLAG_ADMIN) { 1117 if (!test_bit_inv(domain, perms->adm)) { 1118 rc = -ENODEV; 1119 goto out_free; 1120 } 1121 } else if ((ap_msg.flags & AP_MSG_FLAG_USAGE) == 0) { 1122 rc = -EOPNOTSUPP; 1123 goto out_free; 1124 } 1125 } 1126 1127 pref_zc = NULL; 1128 pref_zq = NULL; 1129 spin_lock(&zcrypt_list_lock); 1130 for_each_zcrypt_card(zc) { 1131 /* Check for usable EP11 card */ 1132 if (!zc->online || !zc->card->config || zc->card->chkstop || 1133 !(zc->card->functions & 0x04000000)) 1134 continue; 1135 /* Check for user selected EP11 card */ 1136 if (targets && 1137 !is_desired_ep11_card(zc->card->id, target_num, targets)) 1138 continue; 1139 /* check if request size exceeds card max msg size */ 1140 if (ap_msg.len > zc->card->maxmsgsize) 1141 continue; 1142 /* check if device node has admission for this card */ 1143 if (!zcrypt_check_card(perms, zc->card->id)) 1144 continue; 1145 /* get weight index of the card device */ 1146 wgt = speed_idx_ep11(func_code) * zc->speed_rating[SECKEY]; 1147 /* penalty if this msg was previously sent via this card */ 1148 cpen = (tr && tr->again_counter && tr->last_qid && 1149 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 1150 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 1151 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 1152 continue; 1153 for_each_zcrypt_queue(zq, zc) { 1154 /* check if device is usable and eligible */ 1155 if (!zq->online || !zq->ops->send_ep11_cprb || 1156 !zq->queue->config || zq->queue->chkstop || 1157 (targets && 1158 !is_desired_ep11_queue(zq->queue->qid, 1159 target_num, targets))) 1160 continue; 1161 /* check if device node has admission for this queue */ 1162 if (!zcrypt_check_queue(perms, 1163 AP_QID_QUEUE(zq->queue->qid))) 1164 continue; 1165 /* penalty if the msg was previously sent at this qid */ 1166 qpen = (tr && tr->again_counter && tr->last_qid && 1167 tr->last_qid == zq->queue->qid) ? 1168 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 1169 if (!zcrypt_queue_compare(zq, pref_zq, 1170 wgt + cpen + qpen, pref_wgt)) 1171 continue; 1172 pref_zc = zc; 1173 pref_zq = zq; 1174 pref_wgt = wgt + cpen + qpen; 1175 } 1176 } 1177 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 1178 spin_unlock(&zcrypt_list_lock); 1179 1180 if (!pref_zq) { 1181 if (targets && target_num == 1) { 1182 ZCRYPT_DBF_DBG("%s no match for address %02x.%04x => ENODEV\n", 1183 __func__, (int)targets->ap_id, 1184 (int)targets->dom_id); 1185 } else if (targets) { 1186 ZCRYPT_DBF_DBG("%s no match for %d target addrs => ENODEV\n", 1187 __func__, (int)target_num); 1188 } else { 1189 ZCRYPT_DBF_DBG("%s no match for address ff.ffff => ENODEV\n", 1190 __func__); 1191 } 1192 rc = -ENODEV; 1193 goto out_free; 1194 } 1195 1196 qid = pref_zq->queue->qid; 1197 rc = pref_zq->ops->send_ep11_cprb(userspace, pref_zq, xcrb, &ap_msg); 1198 1199 spin_lock(&zcrypt_list_lock); 1200 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 1201 spin_unlock(&zcrypt_list_lock); 1202 1203 out_free: 1204 kfree(targets); 1205 out: 1206 ap_release_message(&ap_msg); 1207 if (tr) { 1208 tr->last_rc = rc; 1209 tr->last_qid = qid; 1210 } 1211 trace_s390_zcrypt_rep(xcrb, func_code, rc, 1212 AP_QID_CARD(qid), AP_QID_QUEUE(qid)); 1213 return rc; 1214 } 1215 1216 long zcrypt_send_ep11_cprb(struct ep11_urb *xcrb) 1217 { 1218 return _zcrypt_send_ep11_cprb(false, &ap_perms, NULL, xcrb); 1219 } 1220 EXPORT_SYMBOL(zcrypt_send_ep11_cprb); 1221 1222 static long zcrypt_rng(char *buffer) 1223 { 1224 struct zcrypt_card *zc, *pref_zc; 1225 struct zcrypt_queue *zq, *pref_zq; 1226 unsigned int wgt = 0, pref_wgt = 0; 1227 unsigned int func_code; 1228 struct ap_message ap_msg; 1229 unsigned int domain; 1230 int qid = 0, rc = -ENODEV; 1231 struct module *mod; 1232 1233 trace_s390_zcrypt_req(buffer, TP_HWRNGCPRB); 1234 1235 ap_init_message(&ap_msg); 1236 rc = prep_rng_ap_msg(&ap_msg, &func_code, &domain); 1237 if (rc) 1238 goto out; 1239 1240 pref_zc = NULL; 1241 pref_zq = NULL; 1242 spin_lock(&zcrypt_list_lock); 1243 for_each_zcrypt_card(zc) { 1244 /* Check for usable CCA card */ 1245 if (!zc->online || !zc->card->config || zc->card->chkstop || 1246 !(zc->card->functions & 0x10000000)) 1247 continue; 1248 /* get weight index of the card device */ 1249 wgt = zc->speed_rating[func_code]; 1250 if (!zcrypt_card_compare(zc, pref_zc, wgt, pref_wgt)) 1251 continue; 1252 for_each_zcrypt_queue(zq, zc) { 1253 /* check if device is usable and eligible */ 1254 if (!zq->online || !zq->ops->rng || 1255 !zq->queue->config || zq->queue->chkstop) 1256 continue; 1257 if (!zcrypt_queue_compare(zq, pref_zq, wgt, pref_wgt)) 1258 continue; 1259 pref_zc = zc; 1260 pref_zq = zq; 1261 pref_wgt = wgt; 1262 } 1263 } 1264 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 1265 spin_unlock(&zcrypt_list_lock); 1266 1267 if (!pref_zq) { 1268 ZCRYPT_DBF_DBG("%s no matching queue found => ENODEV\n", 1269 __func__); 1270 rc = -ENODEV; 1271 goto out; 1272 } 1273 1274 qid = pref_zq->queue->qid; 1275 rc = pref_zq->ops->rng(pref_zq, buffer, &ap_msg); 1276 1277 spin_lock(&zcrypt_list_lock); 1278 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 1279 spin_unlock(&zcrypt_list_lock); 1280 1281 out: 1282 ap_release_message(&ap_msg); 1283 trace_s390_zcrypt_rep(buffer, func_code, rc, 1284 AP_QID_CARD(qid), AP_QID_QUEUE(qid)); 1285 return rc; 1286 } 1287 1288 static void zcrypt_device_status_mask(struct zcrypt_device_status *devstatus) 1289 { 1290 struct zcrypt_card *zc; 1291 struct zcrypt_queue *zq; 1292 struct zcrypt_device_status *stat; 1293 int card, queue; 1294 1295 memset(devstatus, 0, MAX_ZDEV_ENTRIES 1296 * sizeof(struct zcrypt_device_status)); 1297 1298 spin_lock(&zcrypt_list_lock); 1299 for_each_zcrypt_card(zc) { 1300 for_each_zcrypt_queue(zq, zc) { 1301 card = AP_QID_CARD(zq->queue->qid); 1302 if (card >= MAX_ZDEV_CARDIDS) 1303 continue; 1304 queue = AP_QID_QUEUE(zq->queue->qid); 1305 stat = &devstatus[card * AP_DOMAINS + queue]; 1306 stat->hwtype = zc->card->ap_dev.device_type; 1307 stat->functions = zc->card->functions >> 26; 1308 stat->qid = zq->queue->qid; 1309 stat->online = zq->online ? 0x01 : 0x00; 1310 } 1311 } 1312 spin_unlock(&zcrypt_list_lock); 1313 } 1314 1315 void zcrypt_device_status_mask_ext(struct zcrypt_device_status_ext *devstatus) 1316 { 1317 struct zcrypt_card *zc; 1318 struct zcrypt_queue *zq; 1319 struct zcrypt_device_status_ext *stat; 1320 int card, queue; 1321 1322 memset(devstatus, 0, MAX_ZDEV_ENTRIES_EXT 1323 * sizeof(struct zcrypt_device_status_ext)); 1324 1325 spin_lock(&zcrypt_list_lock); 1326 for_each_zcrypt_card(zc) { 1327 for_each_zcrypt_queue(zq, zc) { 1328 card = AP_QID_CARD(zq->queue->qid); 1329 queue = AP_QID_QUEUE(zq->queue->qid); 1330 stat = &devstatus[card * AP_DOMAINS + queue]; 1331 stat->hwtype = zc->card->ap_dev.device_type; 1332 stat->functions = zc->card->functions >> 26; 1333 stat->qid = zq->queue->qid; 1334 stat->online = zq->online ? 0x01 : 0x00; 1335 } 1336 } 1337 spin_unlock(&zcrypt_list_lock); 1338 } 1339 EXPORT_SYMBOL(zcrypt_device_status_mask_ext); 1340 1341 int zcrypt_device_status_ext(int card, int queue, 1342 struct zcrypt_device_status_ext *devstat) 1343 { 1344 struct zcrypt_card *zc; 1345 struct zcrypt_queue *zq; 1346 1347 memset(devstat, 0, sizeof(*devstat)); 1348 1349 spin_lock(&zcrypt_list_lock); 1350 for_each_zcrypt_card(zc) { 1351 for_each_zcrypt_queue(zq, zc) { 1352 if (card == AP_QID_CARD(zq->queue->qid) && 1353 queue == AP_QID_QUEUE(zq->queue->qid)) { 1354 devstat->hwtype = zc->card->ap_dev.device_type; 1355 devstat->functions = zc->card->functions >> 26; 1356 devstat->qid = zq->queue->qid; 1357 devstat->online = zq->online ? 0x01 : 0x00; 1358 spin_unlock(&zcrypt_list_lock); 1359 return 0; 1360 } 1361 } 1362 } 1363 spin_unlock(&zcrypt_list_lock); 1364 1365 return -ENODEV; 1366 } 1367 EXPORT_SYMBOL(zcrypt_device_status_ext); 1368 1369 static void zcrypt_status_mask(char status[], size_t max_adapters) 1370 { 1371 struct zcrypt_card *zc; 1372 struct zcrypt_queue *zq; 1373 int card; 1374 1375 memset(status, 0, max_adapters); 1376 spin_lock(&zcrypt_list_lock); 1377 for_each_zcrypt_card(zc) { 1378 for_each_zcrypt_queue(zq, zc) { 1379 card = AP_QID_CARD(zq->queue->qid); 1380 if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index || 1381 card >= max_adapters) 1382 continue; 1383 status[card] = zc->online ? zc->user_space_type : 0x0d; 1384 } 1385 } 1386 spin_unlock(&zcrypt_list_lock); 1387 } 1388 1389 static void zcrypt_qdepth_mask(char qdepth[], size_t max_adapters) 1390 { 1391 struct zcrypt_card *zc; 1392 struct zcrypt_queue *zq; 1393 int card; 1394 1395 memset(qdepth, 0, max_adapters); 1396 spin_lock(&zcrypt_list_lock); 1397 local_bh_disable(); 1398 for_each_zcrypt_card(zc) { 1399 for_each_zcrypt_queue(zq, zc) { 1400 card = AP_QID_CARD(zq->queue->qid); 1401 if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index || 1402 card >= max_adapters) 1403 continue; 1404 spin_lock(&zq->queue->lock); 1405 qdepth[card] = 1406 zq->queue->pendingq_count + 1407 zq->queue->requestq_count; 1408 spin_unlock(&zq->queue->lock); 1409 } 1410 } 1411 local_bh_enable(); 1412 spin_unlock(&zcrypt_list_lock); 1413 } 1414 1415 static void zcrypt_perdev_reqcnt(u32 reqcnt[], size_t max_adapters) 1416 { 1417 struct zcrypt_card *zc; 1418 struct zcrypt_queue *zq; 1419 int card; 1420 u64 cnt; 1421 1422 memset(reqcnt, 0, sizeof(int) * max_adapters); 1423 spin_lock(&zcrypt_list_lock); 1424 local_bh_disable(); 1425 for_each_zcrypt_card(zc) { 1426 for_each_zcrypt_queue(zq, zc) { 1427 card = AP_QID_CARD(zq->queue->qid); 1428 if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index || 1429 card >= max_adapters) 1430 continue; 1431 spin_lock(&zq->queue->lock); 1432 cnt = zq->queue->total_request_count; 1433 spin_unlock(&zq->queue->lock); 1434 reqcnt[card] = (cnt < UINT_MAX) ? (u32)cnt : UINT_MAX; 1435 } 1436 } 1437 local_bh_enable(); 1438 spin_unlock(&zcrypt_list_lock); 1439 } 1440 1441 static int zcrypt_pendingq_count(void) 1442 { 1443 struct zcrypt_card *zc; 1444 struct zcrypt_queue *zq; 1445 int pendingq_count; 1446 1447 pendingq_count = 0; 1448 spin_lock(&zcrypt_list_lock); 1449 local_bh_disable(); 1450 for_each_zcrypt_card(zc) { 1451 for_each_zcrypt_queue(zq, zc) { 1452 if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index) 1453 continue; 1454 spin_lock(&zq->queue->lock); 1455 pendingq_count += zq->queue->pendingq_count; 1456 spin_unlock(&zq->queue->lock); 1457 } 1458 } 1459 local_bh_enable(); 1460 spin_unlock(&zcrypt_list_lock); 1461 return pendingq_count; 1462 } 1463 1464 static int zcrypt_requestq_count(void) 1465 { 1466 struct zcrypt_card *zc; 1467 struct zcrypt_queue *zq; 1468 int requestq_count; 1469 1470 requestq_count = 0; 1471 spin_lock(&zcrypt_list_lock); 1472 local_bh_disable(); 1473 for_each_zcrypt_card(zc) { 1474 for_each_zcrypt_queue(zq, zc) { 1475 if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index) 1476 continue; 1477 spin_lock(&zq->queue->lock); 1478 requestq_count += zq->queue->requestq_count; 1479 spin_unlock(&zq->queue->lock); 1480 } 1481 } 1482 local_bh_enable(); 1483 spin_unlock(&zcrypt_list_lock); 1484 return requestq_count; 1485 } 1486 1487 static int icarsamodexpo_ioctl(struct ap_perms *perms, unsigned long arg) 1488 { 1489 int rc; 1490 struct zcrypt_track tr; 1491 struct ica_rsa_modexpo mex; 1492 struct ica_rsa_modexpo __user *umex = (void __user *)arg; 1493 1494 memset(&tr, 0, sizeof(tr)); 1495 if (copy_from_user(&mex, umex, sizeof(mex))) 1496 return -EFAULT; 1497 1498 #ifdef CONFIG_ZCRYPT_DEBUG 1499 if (mex.inputdatalength & (1U << 31)) { 1500 if (!capable(CAP_SYS_ADMIN)) 1501 return -EPERM; 1502 tr.fi.cmd = (u16)(mex.inputdatalength >> 16); 1503 } 1504 mex.inputdatalength &= 0x0000FFFF; 1505 #endif 1506 1507 do { 1508 rc = zcrypt_rsa_modexpo(perms, &tr, &mex); 1509 if (rc == -EAGAIN) 1510 tr.again_counter++; 1511 #ifdef CONFIG_ZCRYPT_DEBUG 1512 if (rc == -EAGAIN && (tr.fi.flags & AP_FI_FLAG_NO_RETRY)) 1513 break; 1514 #endif 1515 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1516 /* on failure: retry once again after a requested rescan */ 1517 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1518 do { 1519 rc = zcrypt_rsa_modexpo(perms, &tr, &mex); 1520 if (rc == -EAGAIN) 1521 tr.again_counter++; 1522 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1523 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1524 rc = -EIO; 1525 if (rc) { 1526 ZCRYPT_DBF_DBG("ioctl ICARSAMODEXPO rc=%d\n", rc); 1527 return rc; 1528 } 1529 return put_user(mex.outputdatalength, &umex->outputdatalength); 1530 } 1531 1532 static int icarsacrt_ioctl(struct ap_perms *perms, unsigned long arg) 1533 { 1534 int rc; 1535 struct zcrypt_track tr; 1536 struct ica_rsa_modexpo_crt crt; 1537 struct ica_rsa_modexpo_crt __user *ucrt = (void __user *)arg; 1538 1539 memset(&tr, 0, sizeof(tr)); 1540 if (copy_from_user(&crt, ucrt, sizeof(crt))) 1541 return -EFAULT; 1542 1543 #ifdef CONFIG_ZCRYPT_DEBUG 1544 if (crt.inputdatalength & (1U << 31)) { 1545 if (!capable(CAP_SYS_ADMIN)) 1546 return -EPERM; 1547 tr.fi.cmd = (u16)(crt.inputdatalength >> 16); 1548 } 1549 crt.inputdatalength &= 0x0000FFFF; 1550 #endif 1551 1552 do { 1553 rc = zcrypt_rsa_crt(perms, &tr, &crt); 1554 if (rc == -EAGAIN) 1555 tr.again_counter++; 1556 #ifdef CONFIG_ZCRYPT_DEBUG 1557 if (rc == -EAGAIN && (tr.fi.flags & AP_FI_FLAG_NO_RETRY)) 1558 break; 1559 #endif 1560 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1561 /* on failure: retry once again after a requested rescan */ 1562 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1563 do { 1564 rc = zcrypt_rsa_crt(perms, &tr, &crt); 1565 if (rc == -EAGAIN) 1566 tr.again_counter++; 1567 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1568 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1569 rc = -EIO; 1570 if (rc) { 1571 ZCRYPT_DBF_DBG("ioctl ICARSACRT rc=%d\n", rc); 1572 return rc; 1573 } 1574 return put_user(crt.outputdatalength, &ucrt->outputdatalength); 1575 } 1576 1577 static int zsecsendcprb_ioctl(struct ap_perms *perms, unsigned long arg) 1578 { 1579 int rc; 1580 struct ica_xcRB xcrb; 1581 struct zcrypt_track tr; 1582 struct ica_xcRB __user *uxcrb = (void __user *)arg; 1583 1584 memset(&tr, 0, sizeof(tr)); 1585 if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb))) 1586 return -EFAULT; 1587 1588 #ifdef CONFIG_ZCRYPT_DEBUG 1589 if ((xcrb.status & 0x8000FFFF) == 0x80004649 /* 'FI' */) { 1590 if (!capable(CAP_SYS_ADMIN)) 1591 return -EPERM; 1592 tr.fi.cmd = (u16)(xcrb.status >> 16); 1593 } 1594 xcrb.status = 0; 1595 #endif 1596 1597 do { 1598 rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb); 1599 if (rc == -EAGAIN) 1600 tr.again_counter++; 1601 #ifdef CONFIG_ZCRYPT_DEBUG 1602 if (rc == -EAGAIN && (tr.fi.flags & AP_FI_FLAG_NO_RETRY)) 1603 break; 1604 #endif 1605 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1606 /* on failure: retry once again after a requested rescan */ 1607 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1608 do { 1609 rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb); 1610 if (rc == -EAGAIN) 1611 tr.again_counter++; 1612 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1613 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1614 rc = -EIO; 1615 if (rc) 1616 ZCRYPT_DBF_DBG("ioctl ZSENDCPRB rc=%d status=0x%x\n", 1617 rc, xcrb.status); 1618 if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb))) 1619 return -EFAULT; 1620 return rc; 1621 } 1622 1623 static int zsendep11cprb_ioctl(struct ap_perms *perms, unsigned long arg) 1624 { 1625 int rc; 1626 struct ep11_urb xcrb; 1627 struct zcrypt_track tr; 1628 struct ep11_urb __user *uxcrb = (void __user *)arg; 1629 1630 memset(&tr, 0, sizeof(tr)); 1631 if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb))) 1632 return -EFAULT; 1633 1634 #ifdef CONFIG_ZCRYPT_DEBUG 1635 if (xcrb.req_len & (1ULL << 63)) { 1636 if (!capable(CAP_SYS_ADMIN)) 1637 return -EPERM; 1638 tr.fi.cmd = (u16)(xcrb.req_len >> 48); 1639 } 1640 xcrb.req_len &= 0x0000FFFFFFFFFFFFULL; 1641 #endif 1642 1643 do { 1644 rc = _zcrypt_send_ep11_cprb(true, perms, &tr, &xcrb); 1645 if (rc == -EAGAIN) 1646 tr.again_counter++; 1647 #ifdef CONFIG_ZCRYPT_DEBUG 1648 if (rc == -EAGAIN && (tr.fi.flags & AP_FI_FLAG_NO_RETRY)) 1649 break; 1650 #endif 1651 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1652 /* on failure: retry once again after a requested rescan */ 1653 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1654 do { 1655 rc = _zcrypt_send_ep11_cprb(true, perms, &tr, &xcrb); 1656 if (rc == -EAGAIN) 1657 tr.again_counter++; 1658 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1659 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1660 rc = -EIO; 1661 if (rc) 1662 ZCRYPT_DBF_DBG("ioctl ZSENDEP11CPRB rc=%d\n", rc); 1663 if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb))) 1664 return -EFAULT; 1665 return rc; 1666 } 1667 1668 static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd, 1669 unsigned long arg) 1670 { 1671 int rc; 1672 struct ap_perms *perms = 1673 (struct ap_perms *)filp->private_data; 1674 1675 rc = zcrypt_check_ioctl(perms, cmd); 1676 if (rc) 1677 return rc; 1678 1679 switch (cmd) { 1680 case ICARSAMODEXPO: 1681 return icarsamodexpo_ioctl(perms, arg); 1682 case ICARSACRT: 1683 return icarsacrt_ioctl(perms, arg); 1684 case ZSECSENDCPRB: 1685 return zsecsendcprb_ioctl(perms, arg); 1686 case ZSENDEP11CPRB: 1687 return zsendep11cprb_ioctl(perms, arg); 1688 case ZCRYPT_DEVICE_STATUS: { 1689 struct zcrypt_device_status_ext *device_status; 1690 size_t total_size = MAX_ZDEV_ENTRIES_EXT 1691 * sizeof(struct zcrypt_device_status_ext); 1692 1693 device_status = kzalloc(total_size, GFP_KERNEL); 1694 if (!device_status) 1695 return -ENOMEM; 1696 zcrypt_device_status_mask_ext(device_status); 1697 if (copy_to_user((char __user *)arg, device_status, 1698 total_size)) 1699 rc = -EFAULT; 1700 kfree(device_status); 1701 return rc; 1702 } 1703 case ZCRYPT_STATUS_MASK: { 1704 char status[AP_DEVICES]; 1705 1706 zcrypt_status_mask(status, AP_DEVICES); 1707 if (copy_to_user((char __user *)arg, status, sizeof(status))) 1708 return -EFAULT; 1709 return 0; 1710 } 1711 case ZCRYPT_QDEPTH_MASK: { 1712 char qdepth[AP_DEVICES]; 1713 1714 zcrypt_qdepth_mask(qdepth, AP_DEVICES); 1715 if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth))) 1716 return -EFAULT; 1717 return 0; 1718 } 1719 case ZCRYPT_PERDEV_REQCNT: { 1720 u32 *reqcnt; 1721 1722 reqcnt = kcalloc(AP_DEVICES, sizeof(u32), GFP_KERNEL); 1723 if (!reqcnt) 1724 return -ENOMEM; 1725 zcrypt_perdev_reqcnt(reqcnt, AP_DEVICES); 1726 if (copy_to_user((int __user *)arg, reqcnt, 1727 sizeof(u32) * AP_DEVICES)) 1728 rc = -EFAULT; 1729 kfree(reqcnt); 1730 return rc; 1731 } 1732 case Z90STAT_REQUESTQ_COUNT: 1733 return put_user(zcrypt_requestq_count(), (int __user *)arg); 1734 case Z90STAT_PENDINGQ_COUNT: 1735 return put_user(zcrypt_pendingq_count(), (int __user *)arg); 1736 case Z90STAT_TOTALOPEN_COUNT: 1737 return put_user(atomic_read(&zcrypt_open_count), 1738 (int __user *)arg); 1739 case Z90STAT_DOMAIN_INDEX: 1740 return put_user(ap_domain_index, (int __user *)arg); 1741 /* 1742 * Deprecated ioctls 1743 */ 1744 case ZDEVICESTATUS: { 1745 /* the old ioctl supports only 64 adapters */ 1746 struct zcrypt_device_status *device_status; 1747 size_t total_size = MAX_ZDEV_ENTRIES 1748 * sizeof(struct zcrypt_device_status); 1749 1750 device_status = kzalloc(total_size, GFP_KERNEL); 1751 if (!device_status) 1752 return -ENOMEM; 1753 zcrypt_device_status_mask(device_status); 1754 if (copy_to_user((char __user *)arg, device_status, 1755 total_size)) 1756 rc = -EFAULT; 1757 kfree(device_status); 1758 return rc; 1759 } 1760 case Z90STAT_STATUS_MASK: { 1761 /* the old ioctl supports only 64 adapters */ 1762 char status[MAX_ZDEV_CARDIDS]; 1763 1764 zcrypt_status_mask(status, MAX_ZDEV_CARDIDS); 1765 if (copy_to_user((char __user *)arg, status, sizeof(status))) 1766 return -EFAULT; 1767 return 0; 1768 } 1769 case Z90STAT_QDEPTH_MASK: { 1770 /* the old ioctl supports only 64 adapters */ 1771 char qdepth[MAX_ZDEV_CARDIDS]; 1772 1773 zcrypt_qdepth_mask(qdepth, MAX_ZDEV_CARDIDS); 1774 if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth))) 1775 return -EFAULT; 1776 return 0; 1777 } 1778 case Z90STAT_PERDEV_REQCNT: { 1779 /* the old ioctl supports only 64 adapters */ 1780 u32 reqcnt[MAX_ZDEV_CARDIDS]; 1781 1782 zcrypt_perdev_reqcnt(reqcnt, MAX_ZDEV_CARDIDS); 1783 if (copy_to_user((int __user *)arg, reqcnt, sizeof(reqcnt))) 1784 return -EFAULT; 1785 return 0; 1786 } 1787 /* unknown ioctl number */ 1788 default: 1789 ZCRYPT_DBF_DBG("unknown ioctl 0x%08x\n", cmd); 1790 return -ENOIOCTLCMD; 1791 } 1792 } 1793 1794 #ifdef CONFIG_COMPAT 1795 /* 1796 * ioctl32 conversion routines 1797 */ 1798 struct compat_ica_rsa_modexpo { 1799 compat_uptr_t inputdata; 1800 unsigned int inputdatalength; 1801 compat_uptr_t outputdata; 1802 unsigned int outputdatalength; 1803 compat_uptr_t b_key; 1804 compat_uptr_t n_modulus; 1805 }; 1806 1807 static long trans_modexpo32(struct ap_perms *perms, struct file *filp, 1808 unsigned int cmd, unsigned long arg) 1809 { 1810 struct compat_ica_rsa_modexpo __user *umex32 = compat_ptr(arg); 1811 struct compat_ica_rsa_modexpo mex32; 1812 struct ica_rsa_modexpo mex64; 1813 struct zcrypt_track tr; 1814 long rc; 1815 1816 memset(&tr, 0, sizeof(tr)); 1817 if (copy_from_user(&mex32, umex32, sizeof(mex32))) 1818 return -EFAULT; 1819 mex64.inputdata = compat_ptr(mex32.inputdata); 1820 mex64.inputdatalength = mex32.inputdatalength; 1821 mex64.outputdata = compat_ptr(mex32.outputdata); 1822 mex64.outputdatalength = mex32.outputdatalength; 1823 mex64.b_key = compat_ptr(mex32.b_key); 1824 mex64.n_modulus = compat_ptr(mex32.n_modulus); 1825 do { 1826 rc = zcrypt_rsa_modexpo(perms, &tr, &mex64); 1827 if (rc == -EAGAIN) 1828 tr.again_counter++; 1829 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1830 /* on failure: retry once again after a requested rescan */ 1831 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1832 do { 1833 rc = zcrypt_rsa_modexpo(perms, &tr, &mex64); 1834 if (rc == -EAGAIN) 1835 tr.again_counter++; 1836 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1837 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1838 rc = -EIO; 1839 if (rc) 1840 return rc; 1841 return put_user(mex64.outputdatalength, 1842 &umex32->outputdatalength); 1843 } 1844 1845 struct compat_ica_rsa_modexpo_crt { 1846 compat_uptr_t inputdata; 1847 unsigned int inputdatalength; 1848 compat_uptr_t outputdata; 1849 unsigned int outputdatalength; 1850 compat_uptr_t bp_key; 1851 compat_uptr_t bq_key; 1852 compat_uptr_t np_prime; 1853 compat_uptr_t nq_prime; 1854 compat_uptr_t u_mult_inv; 1855 }; 1856 1857 static long trans_modexpo_crt32(struct ap_perms *perms, struct file *filp, 1858 unsigned int cmd, unsigned long arg) 1859 { 1860 struct compat_ica_rsa_modexpo_crt __user *ucrt32 = compat_ptr(arg); 1861 struct compat_ica_rsa_modexpo_crt crt32; 1862 struct ica_rsa_modexpo_crt crt64; 1863 struct zcrypt_track tr; 1864 long rc; 1865 1866 memset(&tr, 0, sizeof(tr)); 1867 if (copy_from_user(&crt32, ucrt32, sizeof(crt32))) 1868 return -EFAULT; 1869 crt64.inputdata = compat_ptr(crt32.inputdata); 1870 crt64.inputdatalength = crt32.inputdatalength; 1871 crt64.outputdata = compat_ptr(crt32.outputdata); 1872 crt64.outputdatalength = crt32.outputdatalength; 1873 crt64.bp_key = compat_ptr(crt32.bp_key); 1874 crt64.bq_key = compat_ptr(crt32.bq_key); 1875 crt64.np_prime = compat_ptr(crt32.np_prime); 1876 crt64.nq_prime = compat_ptr(crt32.nq_prime); 1877 crt64.u_mult_inv = compat_ptr(crt32.u_mult_inv); 1878 do { 1879 rc = zcrypt_rsa_crt(perms, &tr, &crt64); 1880 if (rc == -EAGAIN) 1881 tr.again_counter++; 1882 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1883 /* on failure: retry once again after a requested rescan */ 1884 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1885 do { 1886 rc = zcrypt_rsa_crt(perms, &tr, &crt64); 1887 if (rc == -EAGAIN) 1888 tr.again_counter++; 1889 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1890 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1891 rc = -EIO; 1892 if (rc) 1893 return rc; 1894 return put_user(crt64.outputdatalength, 1895 &ucrt32->outputdatalength); 1896 } 1897 1898 struct compat_ica_xcrb { 1899 unsigned short agent_ID; 1900 unsigned int user_defined; 1901 unsigned short request_ID; 1902 unsigned int request_control_blk_length; 1903 unsigned char padding1[16 - sizeof(compat_uptr_t)]; 1904 compat_uptr_t request_control_blk_addr; 1905 unsigned int request_data_length; 1906 char padding2[16 - sizeof(compat_uptr_t)]; 1907 compat_uptr_t request_data_address; 1908 unsigned int reply_control_blk_length; 1909 char padding3[16 - sizeof(compat_uptr_t)]; 1910 compat_uptr_t reply_control_blk_addr; 1911 unsigned int reply_data_length; 1912 char padding4[16 - sizeof(compat_uptr_t)]; 1913 compat_uptr_t reply_data_addr; 1914 unsigned short priority_window; 1915 unsigned int status; 1916 } __packed; 1917 1918 static long trans_xcrb32(struct ap_perms *perms, struct file *filp, 1919 unsigned int cmd, unsigned long arg) 1920 { 1921 struct compat_ica_xcrb __user *uxcrb32 = compat_ptr(arg); 1922 struct compat_ica_xcrb xcrb32; 1923 struct zcrypt_track tr; 1924 struct ica_xcRB xcrb64; 1925 long rc; 1926 1927 memset(&tr, 0, sizeof(tr)); 1928 if (copy_from_user(&xcrb32, uxcrb32, sizeof(xcrb32))) 1929 return -EFAULT; 1930 xcrb64.agent_ID = xcrb32.agent_ID; 1931 xcrb64.user_defined = xcrb32.user_defined; 1932 xcrb64.request_ID = xcrb32.request_ID; 1933 xcrb64.request_control_blk_length = 1934 xcrb32.request_control_blk_length; 1935 xcrb64.request_control_blk_addr = 1936 compat_ptr(xcrb32.request_control_blk_addr); 1937 xcrb64.request_data_length = 1938 xcrb32.request_data_length; 1939 xcrb64.request_data_address = 1940 compat_ptr(xcrb32.request_data_address); 1941 xcrb64.reply_control_blk_length = 1942 xcrb32.reply_control_blk_length; 1943 xcrb64.reply_control_blk_addr = 1944 compat_ptr(xcrb32.reply_control_blk_addr); 1945 xcrb64.reply_data_length = xcrb32.reply_data_length; 1946 xcrb64.reply_data_addr = 1947 compat_ptr(xcrb32.reply_data_addr); 1948 xcrb64.priority_window = xcrb32.priority_window; 1949 xcrb64.status = xcrb32.status; 1950 do { 1951 rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb64); 1952 if (rc == -EAGAIN) 1953 tr.again_counter++; 1954 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1955 /* on failure: retry once again after a requested rescan */ 1956 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 1957 do { 1958 rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb64); 1959 if (rc == -EAGAIN) 1960 tr.again_counter++; 1961 } while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX); 1962 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1963 rc = -EIO; 1964 xcrb32.reply_control_blk_length = xcrb64.reply_control_blk_length; 1965 xcrb32.reply_data_length = xcrb64.reply_data_length; 1966 xcrb32.status = xcrb64.status; 1967 if (copy_to_user(uxcrb32, &xcrb32, sizeof(xcrb32))) 1968 return -EFAULT; 1969 return rc; 1970 } 1971 1972 static long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd, 1973 unsigned long arg) 1974 { 1975 int rc; 1976 struct ap_perms *perms = 1977 (struct ap_perms *)filp->private_data; 1978 1979 rc = zcrypt_check_ioctl(perms, cmd); 1980 if (rc) 1981 return rc; 1982 1983 if (cmd == ICARSAMODEXPO) 1984 return trans_modexpo32(perms, filp, cmd, arg); 1985 if (cmd == ICARSACRT) 1986 return trans_modexpo_crt32(perms, filp, cmd, arg); 1987 if (cmd == ZSECSENDCPRB) 1988 return trans_xcrb32(perms, filp, cmd, arg); 1989 return zcrypt_unlocked_ioctl(filp, cmd, arg); 1990 } 1991 #endif 1992 1993 /* 1994 * Misc device file operations. 1995 */ 1996 static const struct file_operations zcrypt_fops = { 1997 .owner = THIS_MODULE, 1998 .read = zcrypt_read, 1999 .write = zcrypt_write, 2000 .unlocked_ioctl = zcrypt_unlocked_ioctl, 2001 #ifdef CONFIG_COMPAT 2002 .compat_ioctl = zcrypt_compat_ioctl, 2003 #endif 2004 .open = zcrypt_open, 2005 .release = zcrypt_release, 2006 .llseek = no_llseek, 2007 }; 2008 2009 /* 2010 * Misc device. 2011 */ 2012 static struct miscdevice zcrypt_misc_device = { 2013 .minor = MISC_DYNAMIC_MINOR, 2014 .name = "z90crypt", 2015 .fops = &zcrypt_fops, 2016 }; 2017 2018 static int zcrypt_rng_device_count; 2019 static u32 *zcrypt_rng_buffer; 2020 static int zcrypt_rng_buffer_index; 2021 static DEFINE_MUTEX(zcrypt_rng_mutex); 2022 2023 static int zcrypt_rng_data_read(struct hwrng *rng, u32 *data) 2024 { 2025 int rc; 2026 2027 /* 2028 * We don't need locking here because the RNG API guarantees serialized 2029 * read method calls. 2030 */ 2031 if (zcrypt_rng_buffer_index == 0) { 2032 rc = zcrypt_rng((char *)zcrypt_rng_buffer); 2033 /* on failure: retry once again after a requested rescan */ 2034 if ((rc == -ENODEV) && (zcrypt_process_rescan())) 2035 rc = zcrypt_rng((char *)zcrypt_rng_buffer); 2036 if (rc < 0) 2037 return -EIO; 2038 zcrypt_rng_buffer_index = rc / sizeof(*data); 2039 } 2040 *data = zcrypt_rng_buffer[--zcrypt_rng_buffer_index]; 2041 return sizeof(*data); 2042 } 2043 2044 static struct hwrng zcrypt_rng_dev = { 2045 .name = "zcrypt", 2046 .data_read = zcrypt_rng_data_read, 2047 .quality = 990, 2048 }; 2049 2050 int zcrypt_rng_device_add(void) 2051 { 2052 int rc = 0; 2053 2054 mutex_lock(&zcrypt_rng_mutex); 2055 if (zcrypt_rng_device_count == 0) { 2056 zcrypt_rng_buffer = (u32 *)get_zeroed_page(GFP_KERNEL); 2057 if (!zcrypt_rng_buffer) { 2058 rc = -ENOMEM; 2059 goto out; 2060 } 2061 zcrypt_rng_buffer_index = 0; 2062 rc = hwrng_register(&zcrypt_rng_dev); 2063 if (rc) 2064 goto out_free; 2065 zcrypt_rng_device_count = 1; 2066 } else { 2067 zcrypt_rng_device_count++; 2068 } 2069 mutex_unlock(&zcrypt_rng_mutex); 2070 return 0; 2071 2072 out_free: 2073 free_page((unsigned long)zcrypt_rng_buffer); 2074 out: 2075 mutex_unlock(&zcrypt_rng_mutex); 2076 return rc; 2077 } 2078 2079 void zcrypt_rng_device_remove(void) 2080 { 2081 mutex_lock(&zcrypt_rng_mutex); 2082 zcrypt_rng_device_count--; 2083 if (zcrypt_rng_device_count == 0) { 2084 hwrng_unregister(&zcrypt_rng_dev); 2085 free_page((unsigned long)zcrypt_rng_buffer); 2086 } 2087 mutex_unlock(&zcrypt_rng_mutex); 2088 } 2089 2090 /* 2091 * Wait until the zcrypt api is operational. 2092 * The AP bus scan and the binding of ap devices to device drivers is 2093 * an asynchronous job. This function waits until these initial jobs 2094 * are done and so the zcrypt api should be ready to serve crypto 2095 * requests - if there are resources available. The function uses an 2096 * internal timeout of 60s. The very first caller will either wait for 2097 * ap bus bindings complete or the timeout happens. This state will be 2098 * remembered for further callers which will only be blocked until a 2099 * decision is made (timeout or bindings complete). 2100 * On timeout -ETIME is returned, on success the return value is 0. 2101 */ 2102 int zcrypt_wait_api_operational(void) 2103 { 2104 static DEFINE_MUTEX(zcrypt_wait_api_lock); 2105 static int zcrypt_wait_api_state; 2106 int rc; 2107 2108 rc = mutex_lock_interruptible(&zcrypt_wait_api_lock); 2109 if (rc) 2110 return rc; 2111 2112 switch (zcrypt_wait_api_state) { 2113 case 0: 2114 /* initial state, invoke wait for the ap bus complete */ 2115 rc = ap_wait_init_apqn_bindings_complete( 2116 msecs_to_jiffies(60 * 1000)); 2117 switch (rc) { 2118 case 0: 2119 /* ap bus bindings are complete */ 2120 zcrypt_wait_api_state = 1; 2121 break; 2122 case -EINTR: 2123 /* interrupted, go back to caller */ 2124 break; 2125 case -ETIME: 2126 /* timeout */ 2127 ZCRYPT_DBF_WARN("%s ap_wait_init_apqn_bindings_complete()=ETIME\n", 2128 __func__); 2129 zcrypt_wait_api_state = -ETIME; 2130 break; 2131 default: 2132 /* other failure */ 2133 ZCRYPT_DBF_DBG("%s ap_wait_init_apqn_bindings_complete()=%d\n", 2134 __func__, rc); 2135 break; 2136 } 2137 break; 2138 case 1: 2139 /* a previous caller already found ap bus bindings complete */ 2140 rc = 0; 2141 break; 2142 default: 2143 /* a previous caller had timeout or other failure */ 2144 rc = zcrypt_wait_api_state; 2145 break; 2146 } 2147 2148 mutex_unlock(&zcrypt_wait_api_lock); 2149 2150 return rc; 2151 } 2152 EXPORT_SYMBOL(zcrypt_wait_api_operational); 2153 2154 int __init zcrypt_debug_init(void) 2155 { 2156 zcrypt_dbf_info = debug_register("zcrypt", 2, 1, 2157 DBF_MAX_SPRINTF_ARGS * sizeof(long)); 2158 debug_register_view(zcrypt_dbf_info, &debug_sprintf_view); 2159 debug_set_level(zcrypt_dbf_info, DBF_ERR); 2160 2161 return 0; 2162 } 2163 2164 void zcrypt_debug_exit(void) 2165 { 2166 debug_unregister(zcrypt_dbf_info); 2167 } 2168 2169 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 2170 2171 static int __init zcdn_init(void) 2172 { 2173 int rc; 2174 2175 /* create a new class 'zcrypt' */ 2176 zcrypt_class = class_create(THIS_MODULE, ZCRYPT_NAME); 2177 if (IS_ERR(zcrypt_class)) { 2178 rc = PTR_ERR(zcrypt_class); 2179 goto out_class_create_failed; 2180 } 2181 zcrypt_class->dev_release = zcdn_device_release; 2182 2183 /* alloc device minor range */ 2184 rc = alloc_chrdev_region(&zcrypt_devt, 2185 0, ZCRYPT_MAX_MINOR_NODES, 2186 ZCRYPT_NAME); 2187 if (rc) 2188 goto out_alloc_chrdev_failed; 2189 2190 cdev_init(&zcrypt_cdev, &zcrypt_fops); 2191 zcrypt_cdev.owner = THIS_MODULE; 2192 rc = cdev_add(&zcrypt_cdev, zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 2193 if (rc) 2194 goto out_cdev_add_failed; 2195 2196 /* need some class specific sysfs attributes */ 2197 rc = class_create_file(zcrypt_class, &class_attr_zcdn_create); 2198 if (rc) 2199 goto out_class_create_file_1_failed; 2200 rc = class_create_file(zcrypt_class, &class_attr_zcdn_destroy); 2201 if (rc) 2202 goto out_class_create_file_2_failed; 2203 2204 return 0; 2205 2206 out_class_create_file_2_failed: 2207 class_remove_file(zcrypt_class, &class_attr_zcdn_create); 2208 out_class_create_file_1_failed: 2209 cdev_del(&zcrypt_cdev); 2210 out_cdev_add_failed: 2211 unregister_chrdev_region(zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 2212 out_alloc_chrdev_failed: 2213 class_destroy(zcrypt_class); 2214 out_class_create_failed: 2215 return rc; 2216 } 2217 2218 static void zcdn_exit(void) 2219 { 2220 class_remove_file(zcrypt_class, &class_attr_zcdn_create); 2221 class_remove_file(zcrypt_class, &class_attr_zcdn_destroy); 2222 zcdn_destroy_all(); 2223 cdev_del(&zcrypt_cdev); 2224 unregister_chrdev_region(zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 2225 class_destroy(zcrypt_class); 2226 } 2227 2228 #endif 2229 2230 /* 2231 * zcrypt_api_init(): Module initialization. 2232 * 2233 * The module initialization code. 2234 */ 2235 int __init zcrypt_api_init(void) 2236 { 2237 int rc; 2238 2239 rc = zcrypt_debug_init(); 2240 if (rc) 2241 goto out; 2242 2243 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 2244 rc = zcdn_init(); 2245 if (rc) 2246 goto out; 2247 #endif 2248 2249 /* Register the request sprayer. */ 2250 rc = misc_register(&zcrypt_misc_device); 2251 if (rc < 0) 2252 goto out_misc_register_failed; 2253 2254 zcrypt_msgtype6_init(); 2255 zcrypt_msgtype50_init(); 2256 2257 return 0; 2258 2259 out_misc_register_failed: 2260 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 2261 zcdn_exit(); 2262 #endif 2263 zcrypt_debug_exit(); 2264 out: 2265 return rc; 2266 } 2267 2268 /* 2269 * zcrypt_api_exit(): Module termination. 2270 * 2271 * The module termination code. 2272 */ 2273 void __exit zcrypt_api_exit(void) 2274 { 2275 #ifdef CONFIG_ZCRYPT_MULTIDEVNODES 2276 zcdn_exit(); 2277 #endif 2278 misc_deregister(&zcrypt_misc_device); 2279 zcrypt_msgtype6_exit(); 2280 zcrypt_msgtype50_exit(); 2281 zcrypt_ccamisc_exit(); 2282 zcrypt_ep11misc_exit(); 2283 zcrypt_debug_exit(); 2284 } 2285 2286 module_init(zcrypt_api_init); 2287 module_exit(zcrypt_api_exit); 2288