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 #define KMSG_COMPONENT "zcrypt" 16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 17 18 #include <linux/export.h> 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/interrupt.h> 22 #include <linux/miscdevice.h> 23 #include <linux/fs.h> 24 #include <linux/slab.h> 25 #include <linux/atomic.h> 26 #include <linux/uaccess.h> 27 #include <linux/hw_random.h> 28 #include <linux/debugfs.h> 29 #include <linux/cdev.h> 30 #include <linux/ctype.h> 31 #include <linux/capability.h> 32 #include <asm/debug.h> 33 34 #define CREATE_TRACE_POINTS 35 #include <asm/trace/zcrypt.h> 36 37 #include "zcrypt_api.h" 38 #include "zcrypt_debug.h" 39 40 #include "zcrypt_msgtype6.h" 41 #include "zcrypt_msgtype50.h" 42 #include "zcrypt_ccamisc.h" 43 #include "zcrypt_ep11misc.h" 44 45 /* 46 * Module description. 47 */ 48 MODULE_AUTHOR("IBM Corporation"); 49 MODULE_DESCRIPTION("Cryptographic Coprocessor interface, " \ 50 "Copyright IBM Corp. 2001, 2012"); 51 MODULE_LICENSE("GPL"); 52 53 unsigned int zcrypt_mempool_threshold = 5; 54 module_param_named(mempool_threshold, zcrypt_mempool_threshold, uint, 0440); 55 MODULE_PARM_DESC(mempool_threshold, "CCA and EP11 request/reply mempool minimal items (min: 1)"); 56 57 /* 58 * zcrypt tracepoint functions 59 */ 60 EXPORT_TRACEPOINT_SYMBOL(s390_zcrypt_req); 61 EXPORT_TRACEPOINT_SYMBOL(s390_zcrypt_rep); 62 63 DEFINE_SPINLOCK(zcrypt_list_lock); 64 LIST_HEAD(zcrypt_card_list); 65 66 static atomic_t zcrypt_open_count = ATOMIC_INIT(0); 67 68 static LIST_HEAD(zcrypt_ops_list); 69 70 /* Zcrypt related debug feature stuff. */ 71 debug_info_t *zcrypt_dbf_info; 72 73 /* 74 * Process a rescan of the transport layer. 75 * Runs a synchronous AP bus rescan. 76 * Returns true if something has changed (for example the 77 * bus scan has found and build up new devices) and it is 78 * worth to do a retry. Otherwise false is returned meaning 79 * no changes on the AP bus level. 80 */ 81 static inline bool zcrypt_process_rescan(void) 82 { 83 return ap_bus_force_rescan(); 84 } 85 86 void zcrypt_msgtype_register(struct zcrypt_ops *zops) 87 { 88 list_add_tail(&zops->list, &zcrypt_ops_list); 89 } 90 91 void zcrypt_msgtype_unregister(struct zcrypt_ops *zops) 92 { 93 list_del_init(&zops->list); 94 } 95 96 struct zcrypt_ops *zcrypt_msgtype(unsigned char *name, int variant) 97 { 98 struct zcrypt_ops *zops; 99 100 list_for_each_entry(zops, &zcrypt_ops_list, list) 101 if (zops->variant == variant && 102 (!strncmp(zops->name, name, sizeof(zops->name)))) 103 return zops; 104 return NULL; 105 } 106 EXPORT_SYMBOL(zcrypt_msgtype); 107 108 /* 109 * Multi device nodes extension functions. 110 */ 111 112 struct zcdn_device; 113 114 static void zcdn_device_release(struct device *dev); 115 static const struct class zcrypt_class = { 116 .name = ZCRYPT_NAME, 117 .dev_release = zcdn_device_release, 118 }; 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 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 163 int i, n; 164 165 if (mutex_lock_interruptible(&ap_perms_mutex)) 166 return -ERESTARTSYS; 167 168 n = sysfs_emit(buf, "0x"); 169 for (i = 0; i < sizeof(zcdndev->perms.ioctlm) / sizeof(long); i++) 170 n += sysfs_emit_at(buf, n, "%016lx", zcdndev->perms.ioctlm[i]); 171 n += sysfs_emit_at(buf, n, "\n"); 172 173 mutex_unlock(&ap_perms_mutex); 174 175 return n; 176 } 177 178 static ssize_t ioctlmask_store(struct device *dev, 179 struct device_attribute *attr, 180 const char *buf, size_t count) 181 { 182 int rc; 183 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 184 185 rc = ap_parse_mask_str(buf, zcdndev->perms.ioctlm, 186 AP_IOCTLS, &ap_perms_mutex); 187 if (rc) 188 return rc; 189 190 return count; 191 } 192 193 static DEVICE_ATTR_RW(ioctlmask); 194 195 static ssize_t apmask_show(struct device *dev, 196 struct device_attribute *attr, 197 char *buf) 198 { 199 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 200 int i, n; 201 202 if (mutex_lock_interruptible(&ap_perms_mutex)) 203 return -ERESTARTSYS; 204 205 n = sysfs_emit(buf, "0x"); 206 for (i = 0; i < sizeof(zcdndev->perms.apm) / sizeof(long); i++) 207 n += sysfs_emit_at(buf, n, "%016lx", zcdndev->perms.apm[i]); 208 n += sysfs_emit_at(buf, n, "\n"); 209 210 mutex_unlock(&ap_perms_mutex); 211 212 return n; 213 } 214 215 static ssize_t apmask_store(struct device *dev, 216 struct device_attribute *attr, 217 const char *buf, size_t count) 218 { 219 int rc; 220 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 221 222 rc = ap_parse_mask_str(buf, zcdndev->perms.apm, 223 AP_DEVICES, &ap_perms_mutex); 224 if (rc) 225 return rc; 226 227 return count; 228 } 229 230 static DEVICE_ATTR_RW(apmask); 231 232 static ssize_t aqmask_show(struct device *dev, 233 struct device_attribute *attr, 234 char *buf) 235 { 236 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 237 int i, n; 238 239 if (mutex_lock_interruptible(&ap_perms_mutex)) 240 return -ERESTARTSYS; 241 242 n = sysfs_emit(buf, "0x"); 243 for (i = 0; i < sizeof(zcdndev->perms.aqm) / sizeof(long); i++) 244 n += sysfs_emit_at(buf, n, "%016lx", zcdndev->perms.aqm[i]); 245 n += sysfs_emit_at(buf, n, "\n"); 246 247 mutex_unlock(&ap_perms_mutex); 248 249 return n; 250 } 251 252 static ssize_t aqmask_store(struct device *dev, 253 struct device_attribute *attr, 254 const char *buf, size_t count) 255 { 256 int rc; 257 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 258 259 rc = ap_parse_mask_str(buf, zcdndev->perms.aqm, 260 AP_DOMAINS, &ap_perms_mutex); 261 if (rc) 262 return rc; 263 264 return count; 265 } 266 267 static DEVICE_ATTR_RW(aqmask); 268 269 static ssize_t admask_show(struct device *dev, 270 struct device_attribute *attr, 271 char *buf) 272 { 273 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 274 int i, n; 275 276 if (mutex_lock_interruptible(&ap_perms_mutex)) 277 return -ERESTARTSYS; 278 279 n = sysfs_emit(buf, "0x"); 280 for (i = 0; i < sizeof(zcdndev->perms.adm) / sizeof(long); i++) 281 n += sysfs_emit_at(buf, n, "%016lx", zcdndev->perms.adm[i]); 282 n += sysfs_emit_at(buf, n, "\n"); 283 284 mutex_unlock(&ap_perms_mutex); 285 286 return n; 287 } 288 289 static ssize_t admask_store(struct device *dev, 290 struct device_attribute *attr, 291 const char *buf, size_t count) 292 { 293 int rc; 294 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 295 296 rc = ap_parse_mask_str(buf, zcdndev->perms.adm, 297 AP_DOMAINS, &ap_perms_mutex); 298 if (rc) 299 return rc; 300 301 return count; 302 } 303 304 static DEVICE_ATTR_RW(admask); 305 306 static struct attribute *zcdn_dev_attrs[] = { 307 &dev_attr_ioctlmask.attr, 308 &dev_attr_apmask.attr, 309 &dev_attr_aqmask.attr, 310 &dev_attr_admask.attr, 311 NULL 312 }; 313 314 static struct attribute_group zcdn_dev_attr_group = { 315 .attrs = zcdn_dev_attrs 316 }; 317 318 static const struct attribute_group *zcdn_dev_attr_groups[] = { 319 &zcdn_dev_attr_group, 320 NULL 321 }; 322 323 static ssize_t zcdn_create_store(const struct class *class, 324 const struct class_attribute *attr, 325 const char *buf, size_t count) 326 { 327 int rc; 328 char name[ZCDN_MAX_NAME]; 329 330 strscpy(name, skip_spaces(buf), sizeof(name)); 331 332 rc = zcdn_create(strim(name)); 333 334 return rc ? rc : count; 335 } 336 337 static const struct class_attribute class_attr_zcdn_create = 338 __ATTR(create, 0600, NULL, zcdn_create_store); 339 340 static ssize_t zcdn_destroy_store(const struct class *class, 341 const struct class_attribute *attr, 342 const char *buf, size_t count) 343 { 344 int rc; 345 char name[ZCDN_MAX_NAME]; 346 347 strscpy(name, skip_spaces(buf), sizeof(name)); 348 349 rc = zcdn_destroy(strim(name)); 350 351 return rc ? rc : count; 352 } 353 354 static const struct class_attribute class_attr_zcdn_destroy = 355 __ATTR(destroy, 0600, NULL, zcdn_destroy_store); 356 357 static void zcdn_device_release(struct device *dev) 358 { 359 struct zcdn_device *zcdndev = to_zcdn_dev(dev); 360 361 ZCRYPT_DBF_INFO("%s releasing zcdn device %d:%d\n", 362 __func__, MAJOR(dev->devt), MINOR(dev->devt)); 363 364 kfree(zcdndev); 365 } 366 367 static int zcdn_create(const char *name) 368 { 369 dev_t devt; 370 int i, rc = 0; 371 struct zcdn_device *zcdndev; 372 373 if (mutex_lock_interruptible(&ap_perms_mutex)) 374 return -ERESTARTSYS; 375 376 /* check if device node with this name already exists */ 377 if (name[0]) { 378 zcdndev = find_zcdndev_by_name(name); 379 if (zcdndev) { 380 put_device(&zcdndev->device); 381 rc = -EEXIST; 382 goto unlockout; 383 } 384 } 385 386 /* find an unused minor number */ 387 for (i = 0; i < ZCRYPT_MAX_MINOR_NODES; i++) { 388 devt = MKDEV(MAJOR(zcrypt_devt), MINOR(zcrypt_devt) + i); 389 zcdndev = find_zcdndev_by_devt(devt); 390 if (zcdndev) 391 put_device(&zcdndev->device); 392 else 393 break; 394 } 395 if (i == ZCRYPT_MAX_MINOR_NODES) { 396 rc = -ENOSPC; 397 goto unlockout; 398 } 399 400 /* alloc and prepare a new zcdn device */ 401 zcdndev = kzalloc(sizeof(*zcdndev), GFP_KERNEL); 402 if (!zcdndev) { 403 rc = -ENOMEM; 404 goto unlockout; 405 } 406 zcdndev->device.release = zcdn_device_release; 407 zcdndev->device.class = &zcrypt_class; 408 zcdndev->device.devt = devt; 409 zcdndev->device.groups = zcdn_dev_attr_groups; 410 if (name[0]) 411 rc = dev_set_name(&zcdndev->device, "%s", name); 412 else 413 rc = dev_set_name(&zcdndev->device, ZCRYPT_NAME "_%d", (int)MINOR(devt)); 414 if (rc) { 415 kfree(zcdndev); 416 goto unlockout; 417 } 418 rc = device_register(&zcdndev->device); 419 if (rc) { 420 put_device(&zcdndev->device); 421 goto unlockout; 422 } 423 424 ZCRYPT_DBF_INFO("%s created zcdn device %d:%d\n", 425 __func__, MAJOR(devt), MINOR(devt)); 426 427 unlockout: 428 mutex_unlock(&ap_perms_mutex); 429 return rc; 430 } 431 432 static int zcdn_destroy(const char *name) 433 { 434 int rc = 0; 435 struct zcdn_device *zcdndev; 436 437 if (mutex_lock_interruptible(&ap_perms_mutex)) 438 return -ERESTARTSYS; 439 440 /* try to find this zcdn device */ 441 zcdndev = find_zcdndev_by_name(name); 442 if (!zcdndev) { 443 rc = -ENOENT; 444 goto unlockout; 445 } 446 447 /* 448 * The zcdn device is not hard destroyed. It is subject to 449 * reference counting and thus just needs to be unregistered. 450 */ 451 put_device(&zcdndev->device); 452 device_unregister(&zcdndev->device); 453 454 unlockout: 455 mutex_unlock(&ap_perms_mutex); 456 return rc; 457 } 458 459 static void zcdn_destroy_all(void) 460 { 461 int i; 462 dev_t devt; 463 struct zcdn_device *zcdndev; 464 465 mutex_lock(&ap_perms_mutex); 466 for (i = 0; i < ZCRYPT_MAX_MINOR_NODES; i++) { 467 devt = MKDEV(MAJOR(zcrypt_devt), MINOR(zcrypt_devt) + i); 468 zcdndev = find_zcdndev_by_devt(devt); 469 if (zcdndev) { 470 put_device(&zcdndev->device); 471 device_unregister(&zcdndev->device); 472 } 473 } 474 mutex_unlock(&ap_perms_mutex); 475 } 476 477 /* 478 * zcrypt_read (): Not supported beyond zcrypt 1.3.1. 479 * 480 * This function is not supported beyond zcrypt 1.3.1. 481 */ 482 static ssize_t zcrypt_read(struct file *filp, char __user *buf, 483 size_t count, loff_t *f_pos) 484 { 485 return -EPERM; 486 } 487 488 /* 489 * zcrypt_write(): Not allowed. 490 * 491 * Write is not allowed 492 */ 493 static ssize_t zcrypt_write(struct file *filp, const char __user *buf, 494 size_t count, loff_t *f_pos) 495 { 496 return -EPERM; 497 } 498 499 /* 500 * zcrypt_open(): Count number of users. 501 * 502 * Device open function to count number of users. 503 */ 504 static int zcrypt_open(struct inode *inode, struct file *filp) 505 { 506 struct ap_perms *perms = &ap_perms; 507 508 if (filp->f_inode->i_cdev == &zcrypt_cdev) { 509 struct zcdn_device *zcdndev; 510 511 if (mutex_lock_interruptible(&ap_perms_mutex)) 512 return -ERESTARTSYS; 513 zcdndev = find_zcdndev_by_devt(filp->f_inode->i_rdev); 514 /* find returns a reference, no get_device() needed */ 515 mutex_unlock(&ap_perms_mutex); 516 if (zcdndev) 517 perms = &zcdndev->perms; 518 } 519 filp->private_data = (void *)perms; 520 521 atomic_inc(&zcrypt_open_count); 522 return stream_open(inode, filp); 523 } 524 525 /* 526 * zcrypt_release(): Count number of users. 527 * 528 * Device close function to count number of users. 529 */ 530 static int zcrypt_release(struct inode *inode, struct file *filp) 531 { 532 if (filp->f_inode->i_cdev == &zcrypt_cdev) { 533 struct zcdn_device *zcdndev; 534 535 mutex_lock(&ap_perms_mutex); 536 zcdndev = find_zcdndev_by_devt(filp->f_inode->i_rdev); 537 mutex_unlock(&ap_perms_mutex); 538 if (zcdndev) { 539 /* 2 puts here: one for find, one for open */ 540 put_device(&zcdndev->device); 541 put_device(&zcdndev->device); 542 } 543 } 544 545 atomic_dec(&zcrypt_open_count); 546 return 0; 547 } 548 549 static inline int zcrypt_check_ioctl(struct ap_perms *perms, 550 unsigned int cmd) 551 { 552 int rc = -EPERM; 553 int ioctlnr = (cmd & _IOC_NRMASK) >> _IOC_NRSHIFT; 554 555 if (ioctlnr > 0 && ioctlnr < AP_IOCTLS) { 556 if (test_bit_inv(ioctlnr, perms->ioctlm)) 557 rc = 0; 558 } 559 560 if (rc) 561 ZCRYPT_DBF_WARN("%s ioctl check failed: ioctlnr=0x%04x rc=%d\n", 562 __func__, ioctlnr, rc); 563 564 return rc; 565 } 566 567 static inline bool zcrypt_check_card(struct ap_perms *perms, int card) 568 { 569 return test_bit_inv(card, perms->apm) ? true : false; 570 } 571 572 static inline bool zcrypt_check_queue(struct ap_perms *perms, int queue) 573 { 574 return test_bit_inv(queue, perms->aqm) ? true : false; 575 } 576 577 static inline struct zcrypt_queue *zcrypt_pick_queue(struct zcrypt_card *zc, 578 struct zcrypt_queue *zq, 579 struct module **pmod, 580 unsigned int weight) 581 { 582 if (!zq || !try_module_get(zq->queue->ap_dev.device.driver->owner)) 583 return NULL; 584 zcrypt_card_get(zc); 585 zcrypt_queue_get(zq); 586 get_device(&zq->queue->ap_dev.device); 587 atomic_add(weight, &zc->load); 588 atomic_add(weight, &zq->load); 589 zq->request_count++; 590 *pmod = zq->queue->ap_dev.device.driver->owner; 591 return zq; 592 } 593 594 static inline void zcrypt_drop_queue(struct zcrypt_card *zc, 595 struct zcrypt_queue *zq, 596 struct module *mod, 597 unsigned int weight) 598 { 599 zq->request_count--; 600 atomic_sub(weight, &zc->load); 601 atomic_sub(weight, &zq->load); 602 put_device(&zq->queue->ap_dev.device); 603 zcrypt_queue_put(zq); 604 zcrypt_card_put(zc); 605 module_put(mod); 606 } 607 608 static inline bool zcrypt_card_compare(struct zcrypt_card *zc, 609 struct zcrypt_card *pref_zc, 610 unsigned int weight, 611 unsigned int pref_weight) 612 { 613 if (!pref_zc) 614 return true; 615 weight += atomic_read(&zc->load); 616 pref_weight += atomic_read(&pref_zc->load); 617 if (weight == pref_weight) 618 return atomic64_read(&zc->card->total_request_count) < 619 atomic64_read(&pref_zc->card->total_request_count); 620 return weight < pref_weight; 621 } 622 623 static inline bool zcrypt_queue_compare(struct zcrypt_queue *zq, 624 struct zcrypt_queue *pref_zq, 625 unsigned int weight, 626 unsigned int pref_weight) 627 { 628 if (!pref_zq) 629 return true; 630 weight += atomic_read(&zq->load); 631 pref_weight += atomic_read(&pref_zq->load); 632 if (weight == pref_weight) 633 return zq->queue->total_request_count < 634 pref_zq->queue->total_request_count; 635 return weight < pref_weight; 636 } 637 638 /* 639 * zcrypt ioctls. 640 */ 641 static long zcrypt_rsa_modexpo(struct ap_perms *perms, 642 struct zcrypt_track *tr, 643 struct ica_rsa_modexpo *mex) 644 { 645 struct zcrypt_card *zc, *pref_zc; 646 struct zcrypt_queue *zq, *pref_zq; 647 struct ap_message ap_msg; 648 unsigned int wgt = 0, pref_wgt = 0; 649 unsigned int func_code = 0; 650 int cpen, qpen, qid = 0, rc; 651 struct module *mod; 652 653 trace_s390_zcrypt_req(mex, TP_ICARSAMODEXPO); 654 655 rc = ap_init_apmsg(&ap_msg, 0); 656 if (rc) 657 goto out; 658 659 if (mex->outputdatalength < mex->inputdatalength) { 660 rc = -EINVAL; 661 goto out; 662 } 663 664 /* 665 * As long as outputdatalength is big enough, we can set the 666 * outputdatalength equal to the inputdatalength, since that is the 667 * number of bytes we will copy in any case 668 */ 669 mex->outputdatalength = mex->inputdatalength; 670 671 rc = get_rsa_modex_fc(mex, &func_code); 672 if (rc) 673 goto out; 674 675 pref_zc = NULL; 676 pref_zq = NULL; 677 spin_lock(&zcrypt_list_lock); 678 for_each_zcrypt_card(zc) { 679 /* Check for usable accelerator or CCA card */ 680 if (!zc->online || !zc->card->config || zc->card->chkstop || 681 !(zc->card->hwinfo.accel || zc->card->hwinfo.cca)) 682 continue; 683 /* Check for size limits */ 684 if (zc->min_mod_size > mex->inputdatalength || 685 zc->max_mod_size < mex->inputdatalength) 686 continue; 687 /* check if device node has admission for this card */ 688 if (!zcrypt_check_card(perms, zc->card->id)) 689 continue; 690 /* get weight index of the card device */ 691 wgt = zc->speed_rating[func_code]; 692 /* penalty if this msg was previously sent via this card */ 693 cpen = (tr && tr->again_counter && tr->last_qid && 694 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 695 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 696 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 697 continue; 698 for_each_zcrypt_queue(zq, zc) { 699 /* check if device is usable and eligible */ 700 if (!zq->online || !zq->ops->rsa_modexpo || 701 !ap_queue_usable(zq->queue)) 702 continue; 703 /* check if device node has admission for this queue */ 704 if (!zcrypt_check_queue(perms, 705 AP_QID_QUEUE(zq->queue->qid))) 706 continue; 707 /* penalty if the msg was previously sent at this qid */ 708 qpen = (tr && tr->again_counter && tr->last_qid && 709 tr->last_qid == zq->queue->qid) ? 710 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 711 if (!zcrypt_queue_compare(zq, pref_zq, 712 wgt + cpen + qpen, pref_wgt)) 713 continue; 714 pref_zc = zc; 715 pref_zq = zq; 716 pref_wgt = wgt + cpen + qpen; 717 } 718 } 719 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 720 spin_unlock(&zcrypt_list_lock); 721 722 if (!pref_zq) { 723 pr_debug("no matching queue found => ENODEV\n"); 724 rc = -ENODEV; 725 goto out; 726 } 727 728 qid = pref_zq->queue->qid; 729 rc = pref_zq->ops->rsa_modexpo(pref_zq, mex, &ap_msg); 730 731 spin_lock(&zcrypt_list_lock); 732 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 733 spin_unlock(&zcrypt_list_lock); 734 735 out: 736 ap_release_apmsg(&ap_msg); 737 if (tr) { 738 tr->last_rc = rc; 739 tr->last_qid = qid; 740 } 741 trace_s390_zcrypt_rep(mex, func_code, rc, 742 AP_QID_CARD(qid), AP_QID_QUEUE(qid), 743 ap_msg.psmid); 744 return rc; 745 } 746 747 static long zcrypt_rsa_crt(struct ap_perms *perms, 748 struct zcrypt_track *tr, 749 struct ica_rsa_modexpo_crt *crt) 750 { 751 struct zcrypt_card *zc, *pref_zc; 752 struct zcrypt_queue *zq, *pref_zq; 753 struct ap_message ap_msg; 754 unsigned int wgt = 0, pref_wgt = 0; 755 unsigned int func_code = 0; 756 int cpen, qpen, qid = 0, rc; 757 struct module *mod; 758 759 trace_s390_zcrypt_req(crt, TP_ICARSACRT); 760 761 rc = ap_init_apmsg(&ap_msg, 0); 762 if (rc) 763 goto out; 764 765 if (crt->outputdatalength < crt->inputdatalength) { 766 rc = -EINVAL; 767 goto out; 768 } 769 770 /* 771 * As long as outputdatalength is big enough, we can set the 772 * outputdatalength equal to the inputdatalength, since that is the 773 * number of bytes we will copy in any case 774 */ 775 crt->outputdatalength = crt->inputdatalength; 776 777 rc = get_rsa_crt_fc(crt, &func_code); 778 if (rc) 779 goto out; 780 781 pref_zc = NULL; 782 pref_zq = NULL; 783 spin_lock(&zcrypt_list_lock); 784 for_each_zcrypt_card(zc) { 785 /* Check for usable accelerator or CCA card */ 786 if (!zc->online || !zc->card->config || zc->card->chkstop || 787 !(zc->card->hwinfo.accel || zc->card->hwinfo.cca)) 788 continue; 789 /* Check for size limits */ 790 if (zc->min_mod_size > crt->inputdatalength || 791 zc->max_mod_size < crt->inputdatalength) 792 continue; 793 /* check if device node has admission for this card */ 794 if (!zcrypt_check_card(perms, zc->card->id)) 795 continue; 796 /* get weight index of the card device */ 797 wgt = zc->speed_rating[func_code]; 798 /* penalty if this msg was previously sent via this card */ 799 cpen = (tr && tr->again_counter && tr->last_qid && 800 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 801 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 802 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 803 continue; 804 for_each_zcrypt_queue(zq, zc) { 805 /* check if device is usable and eligible */ 806 if (!zq->online || !zq->ops->rsa_modexpo_crt || 807 !ap_queue_usable(zq->queue)) 808 continue; 809 /* check if device node has admission for this queue */ 810 if (!zcrypt_check_queue(perms, 811 AP_QID_QUEUE(zq->queue->qid))) 812 continue; 813 /* penalty if the msg was previously sent at this qid */ 814 qpen = (tr && tr->again_counter && tr->last_qid && 815 tr->last_qid == zq->queue->qid) ? 816 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 817 if (!zcrypt_queue_compare(zq, pref_zq, 818 wgt + cpen + qpen, pref_wgt)) 819 continue; 820 pref_zc = zc; 821 pref_zq = zq; 822 pref_wgt = wgt + cpen + qpen; 823 } 824 } 825 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 826 spin_unlock(&zcrypt_list_lock); 827 828 if (!pref_zq) { 829 pr_debug("no matching queue found => ENODEV\n"); 830 rc = -ENODEV; 831 goto out; 832 } 833 834 qid = pref_zq->queue->qid; 835 rc = pref_zq->ops->rsa_modexpo_crt(pref_zq, crt, &ap_msg); 836 837 spin_lock(&zcrypt_list_lock); 838 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 839 spin_unlock(&zcrypt_list_lock); 840 841 out: 842 ap_release_apmsg(&ap_msg); 843 if (tr) { 844 tr->last_rc = rc; 845 tr->last_qid = qid; 846 } 847 trace_s390_zcrypt_rep(crt, func_code, rc, 848 AP_QID_CARD(qid), AP_QID_QUEUE(qid), 849 ap_msg.psmid); 850 return rc; 851 } 852 853 static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms, 854 struct zcrypt_track *tr, 855 struct ica_xcRB *xcrb) 856 { 857 bool userspace = xflags & ZCRYPT_XFLAG_USERSPACE; 858 struct zcrypt_card *zc, *pref_zc; 859 struct zcrypt_queue *zq, *pref_zq; 860 struct ap_message ap_msg; 861 unsigned int wgt = 0, pref_wgt = 0; 862 unsigned int func_code = 0; 863 unsigned short *domain, tdom; 864 int cpen, qpen, qid = 0, rc; 865 struct module *mod; 866 867 trace_s390_zcrypt_req(xcrb, TB_ZSECSENDCPRB); 868 869 xcrb->status = 0; 870 871 rc = ap_init_apmsg(&ap_msg, xflags & ZCRYPT_XFLAG_NOMEMALLOC ? 872 AP_MSG_FLAG_MEMPOOL : 0); 873 if (rc) 874 goto out; 875 876 rc = prep_cca_ap_msg(userspace, xcrb, &ap_msg, &func_code, &domain); 877 if (rc) 878 goto out; 879 print_hex_dump_debug("ccareq: ", DUMP_PREFIX_ADDRESS, 16, 1, 880 ap_msg.msg, ap_msg.len, false); 881 882 tdom = *domain; 883 if (perms != &ap_perms && tdom < AP_DOMAINS) { 884 if (ap_msg.flags & AP_MSG_FLAG_ADMIN) { 885 if (!test_bit_inv(tdom, perms->adm)) { 886 rc = -ENODEV; 887 goto out; 888 } 889 } else if ((ap_msg.flags & AP_MSG_FLAG_USAGE) == 0) { 890 rc = -EOPNOTSUPP; 891 goto out; 892 } 893 } 894 /* 895 * If a valid target domain is set and this domain is NOT a usage 896 * domain but a control only domain, autoselect target domain. 897 */ 898 if (tdom < AP_DOMAINS && 899 !ap_test_config_usage_domain(tdom) && 900 ap_test_config_ctrl_domain(tdom)) 901 tdom = AUTOSEL_DOM; 902 903 pref_zc = NULL; 904 pref_zq = NULL; 905 spin_lock(&zcrypt_list_lock); 906 for_each_zcrypt_card(zc) { 907 /* Check for usable CCA card */ 908 if (!zc->online || !zc->card->config || zc->card->chkstop || 909 !zc->card->hwinfo.cca) 910 continue; 911 /* Check for user selected CCA card */ 912 if (xcrb->user_defined != AUTOSELECT && 913 xcrb->user_defined != zc->card->id) 914 continue; 915 /* check if request size exceeds card max msg size */ 916 if (ap_msg.len > zc->card->maxmsgsize) 917 continue; 918 /* check if device node has admission for this card */ 919 if (!zcrypt_check_card(perms, zc->card->id)) 920 continue; 921 /* get weight index of the card device */ 922 wgt = speed_idx_cca(func_code) * zc->speed_rating[SECKEY]; 923 /* penalty if this msg was previously sent via this card */ 924 cpen = (tr && tr->again_counter && tr->last_qid && 925 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 926 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 927 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 928 continue; 929 for_each_zcrypt_queue(zq, zc) { 930 /* check for device usable and eligible */ 931 if (!zq->online || !zq->ops->send_cprb || 932 !ap_queue_usable(zq->queue) || 933 (tdom != AUTOSEL_DOM && 934 tdom != AP_QID_QUEUE(zq->queue->qid))) 935 continue; 936 /* check if device node has admission for this queue */ 937 if (!zcrypt_check_queue(perms, 938 AP_QID_QUEUE(zq->queue->qid))) 939 continue; 940 /* penalty if the msg was previously sent at this qid */ 941 qpen = (tr && tr->again_counter && tr->last_qid && 942 tr->last_qid == zq->queue->qid) ? 943 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 944 if (!zcrypt_queue_compare(zq, pref_zq, 945 wgt + cpen + qpen, pref_wgt)) 946 continue; 947 pref_zc = zc; 948 pref_zq = zq; 949 pref_wgt = wgt + cpen + qpen; 950 } 951 } 952 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 953 spin_unlock(&zcrypt_list_lock); 954 955 if (!pref_zq) { 956 pr_debug("no match for address %02x.%04x => ENODEV\n", 957 xcrb->user_defined, *domain); 958 rc = -ENODEV; 959 goto out; 960 } 961 962 /* in case of auto select, provide the correct domain */ 963 qid = pref_zq->queue->qid; 964 if (*domain == AUTOSEL_DOM) 965 *domain = AP_QID_QUEUE(qid); 966 967 rc = pref_zq->ops->send_cprb(userspace, pref_zq, xcrb, &ap_msg); 968 if (!rc) { 969 print_hex_dump_debug("ccarpl: ", DUMP_PREFIX_ADDRESS, 16, 1, 970 ap_msg.msg, ap_msg.len, false); 971 } 972 973 spin_lock(&zcrypt_list_lock); 974 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 975 spin_unlock(&zcrypt_list_lock); 976 977 out: 978 ap_release_apmsg(&ap_msg); 979 if (tr) { 980 tr->last_rc = rc; 981 tr->last_qid = qid; 982 } 983 trace_s390_zcrypt_rep(xcrb, func_code, rc, 984 AP_QID_CARD(qid), AP_QID_QUEUE(qid), 985 ap_msg.psmid); 986 return rc; 987 } 988 989 long zcrypt_send_cprb(struct ica_xcRB *xcrb, u32 xflags) 990 { 991 struct zcrypt_track tr; 992 int rc; 993 994 memset(&tr, 0, sizeof(tr)); 995 996 do { 997 rc = _zcrypt_send_cprb(xflags, &ap_perms, &tr, xcrb); 998 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 999 1000 /* on ENODEV failure: retry once again after a requested rescan */ 1001 if (rc == -ENODEV && zcrypt_process_rescan()) 1002 do { 1003 rc = _zcrypt_send_cprb(xflags, &ap_perms, &tr, xcrb); 1004 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1005 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1006 rc = -EIO; 1007 if (rc) 1008 pr_debug("rc=%d\n", rc); 1009 1010 return rc; 1011 } 1012 EXPORT_SYMBOL(zcrypt_send_cprb); 1013 1014 static bool is_desired_ep11_card(unsigned int dev_id, 1015 unsigned short target_num, 1016 struct ep11_target_dev *targets) 1017 { 1018 while (target_num-- > 0) { 1019 if (targets->ap_id == dev_id || targets->ap_id == AUTOSEL_AP) 1020 return true; 1021 targets++; 1022 } 1023 return false; 1024 } 1025 1026 static bool is_desired_ep11_queue(unsigned int dev_qid, 1027 unsigned short target_num, 1028 struct ep11_target_dev *targets) 1029 { 1030 int card = AP_QID_CARD(dev_qid), dom = AP_QID_QUEUE(dev_qid); 1031 1032 while (target_num-- > 0) { 1033 if ((targets->ap_id == card || targets->ap_id == AUTOSEL_AP) && 1034 (targets->dom_id == dom || targets->dom_id == AUTOSEL_DOM)) 1035 return true; 1036 targets++; 1037 } 1038 return false; 1039 } 1040 1041 static long _zcrypt_send_ep11_cprb(u32 xflags, struct ap_perms *perms, 1042 struct zcrypt_track *tr, 1043 struct ep11_urb *xcrb) 1044 { 1045 bool userspace = xflags & ZCRYPT_XFLAG_USERSPACE; 1046 struct zcrypt_card *zc, *pref_zc; 1047 struct zcrypt_queue *zq, *pref_zq; 1048 struct ep11_target_dev *targets = NULL; 1049 unsigned short target_num; 1050 unsigned int wgt = 0, pref_wgt = 0; 1051 unsigned int func_code = 0, domain; 1052 struct ap_message ap_msg; 1053 int cpen, qpen, qid = 0, rc; 1054 struct module *mod; 1055 1056 trace_s390_zcrypt_req(xcrb, TP_ZSENDEP11CPRB); 1057 1058 rc = ap_init_apmsg(&ap_msg, xflags & ZCRYPT_XFLAG_NOMEMALLOC ? 1059 AP_MSG_FLAG_MEMPOOL : 0); 1060 if (rc) 1061 goto out; 1062 1063 target_num = (unsigned short)xcrb->targets_num; 1064 1065 /* empty list indicates autoselect (all available targets) */ 1066 rc = -ENOMEM; 1067 if (target_num != 0) { 1068 if (userspace) { 1069 targets = kcalloc(target_num, sizeof(*targets), GFP_KERNEL); 1070 if (!targets) 1071 goto out; 1072 if (copy_from_user(targets, xcrb->targets, 1073 target_num * sizeof(*targets))) { 1074 rc = -EFAULT; 1075 goto out; 1076 } 1077 } else { 1078 targets = (struct ep11_target_dev __force __kernel *)xcrb->targets; 1079 } 1080 } 1081 1082 rc = prep_ep11_ap_msg(userspace, xcrb, &ap_msg, &func_code, &domain); 1083 if (rc) 1084 goto out; 1085 print_hex_dump_debug("ep11req: ", DUMP_PREFIX_ADDRESS, 16, 1, 1086 ap_msg.msg, ap_msg.len, false); 1087 1088 if (perms != &ap_perms && domain < AUTOSEL_DOM) { 1089 if (ap_msg.flags & AP_MSG_FLAG_ADMIN) { 1090 if (!test_bit_inv(domain, perms->adm)) { 1091 rc = -ENODEV; 1092 goto out; 1093 } 1094 } else if ((ap_msg.flags & AP_MSG_FLAG_USAGE) == 0) { 1095 rc = -EOPNOTSUPP; 1096 goto out; 1097 } 1098 } 1099 1100 pref_zc = NULL; 1101 pref_zq = NULL; 1102 spin_lock(&zcrypt_list_lock); 1103 for_each_zcrypt_card(zc) { 1104 /* Check for usable EP11 card */ 1105 if (!zc->online || !zc->card->config || zc->card->chkstop || 1106 !zc->card->hwinfo.ep11) 1107 continue; 1108 /* Check for user selected EP11 card */ 1109 if (targets && 1110 !is_desired_ep11_card(zc->card->id, target_num, targets)) 1111 continue; 1112 /* check if request size exceeds card max msg size */ 1113 if (ap_msg.len > zc->card->maxmsgsize) 1114 continue; 1115 /* check if device node has admission for this card */ 1116 if (!zcrypt_check_card(perms, zc->card->id)) 1117 continue; 1118 /* get weight index of the card device */ 1119 wgt = speed_idx_ep11(func_code) * zc->speed_rating[SECKEY]; 1120 /* penalty if this msg was previously sent via this card */ 1121 cpen = (tr && tr->again_counter && tr->last_qid && 1122 AP_QID_CARD(tr->last_qid) == zc->card->id) ? 1123 TRACK_AGAIN_CARD_WEIGHT_PENALTY : 0; 1124 if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt)) 1125 continue; 1126 for_each_zcrypt_queue(zq, zc) { 1127 /* check if device is usable and eligible */ 1128 if (!zq->online || !zq->ops->send_ep11_cprb || 1129 !ap_queue_usable(zq->queue) || 1130 (targets && 1131 !is_desired_ep11_queue(zq->queue->qid, 1132 target_num, targets))) 1133 continue; 1134 /* check if device node has admission for this queue */ 1135 if (!zcrypt_check_queue(perms, 1136 AP_QID_QUEUE(zq->queue->qid))) 1137 continue; 1138 /* penalty if the msg was previously sent at this qid */ 1139 qpen = (tr && tr->again_counter && tr->last_qid && 1140 tr->last_qid == zq->queue->qid) ? 1141 TRACK_AGAIN_QUEUE_WEIGHT_PENALTY : 0; 1142 if (!zcrypt_queue_compare(zq, pref_zq, 1143 wgt + cpen + qpen, pref_wgt)) 1144 continue; 1145 pref_zc = zc; 1146 pref_zq = zq; 1147 pref_wgt = wgt + cpen + qpen; 1148 } 1149 } 1150 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 1151 spin_unlock(&zcrypt_list_lock); 1152 1153 if (!pref_zq) { 1154 if (targets && target_num == 1) { 1155 pr_debug("no match for address %02x.%04x => ENODEV\n", 1156 (int)targets->ap_id, (int)targets->dom_id); 1157 } else if (targets) { 1158 pr_debug("no match for %d target addrs => ENODEV\n", 1159 (int)target_num); 1160 } else { 1161 pr_debug("no match for address ff.ffff => ENODEV\n"); 1162 } 1163 rc = -ENODEV; 1164 goto out; 1165 } 1166 1167 qid = pref_zq->queue->qid; 1168 rc = pref_zq->ops->send_ep11_cprb(userspace, pref_zq, xcrb, &ap_msg); 1169 if (!rc) { 1170 print_hex_dump_debug("ep11rpl: ", DUMP_PREFIX_ADDRESS, 16, 1, 1171 ap_msg.msg, ap_msg.len, false); 1172 } 1173 1174 spin_lock(&zcrypt_list_lock); 1175 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 1176 spin_unlock(&zcrypt_list_lock); 1177 1178 out: 1179 if (userspace) 1180 kfree(targets); 1181 ap_release_apmsg(&ap_msg); 1182 if (tr) { 1183 tr->last_rc = rc; 1184 tr->last_qid = qid; 1185 } 1186 trace_s390_zcrypt_rep(xcrb, func_code, rc, 1187 AP_QID_CARD(qid), AP_QID_QUEUE(qid), 1188 ap_msg.psmid); 1189 return rc; 1190 } 1191 1192 long zcrypt_send_ep11_cprb(struct ep11_urb *xcrb, u32 xflags) 1193 { 1194 struct zcrypt_track tr; 1195 int rc; 1196 1197 memset(&tr, 0, sizeof(tr)); 1198 1199 do { 1200 rc = _zcrypt_send_ep11_cprb(xflags, &ap_perms, &tr, xcrb); 1201 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1202 1203 /* on ENODEV failure: retry once again after a requested rescan */ 1204 if (rc == -ENODEV && zcrypt_process_rescan()) 1205 do { 1206 rc = _zcrypt_send_ep11_cprb(xflags, &ap_perms, &tr, xcrb); 1207 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1208 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1209 rc = -EIO; 1210 if (rc) 1211 pr_debug("rc=%d\n", rc); 1212 1213 return rc; 1214 } 1215 EXPORT_SYMBOL(zcrypt_send_ep11_cprb); 1216 1217 static long zcrypt_rng(char *buffer) 1218 { 1219 struct zcrypt_card *zc, *pref_zc; 1220 struct zcrypt_queue *zq, *pref_zq; 1221 unsigned int wgt = 0, pref_wgt = 0; 1222 unsigned int func_code = 0; 1223 struct ap_message ap_msg; 1224 unsigned int domain; 1225 int qid = 0, rc = -ENODEV; 1226 struct module *mod; 1227 1228 trace_s390_zcrypt_req(buffer, TP_HWRNGCPRB); 1229 1230 rc = ap_init_apmsg(&ap_msg, 0); 1231 if (rc) 1232 goto out; 1233 rc = prep_rng_ap_msg(&ap_msg, &func_code, &domain); 1234 if (rc) 1235 goto out; 1236 1237 pref_zc = NULL; 1238 pref_zq = NULL; 1239 spin_lock(&zcrypt_list_lock); 1240 for_each_zcrypt_card(zc) { 1241 /* Check for usable CCA card */ 1242 if (!zc->online || !zc->card->config || zc->card->chkstop || 1243 !zc->card->hwinfo.cca) 1244 continue; 1245 /* get weight index of the card device */ 1246 wgt = zc->speed_rating[func_code]; 1247 if (!zcrypt_card_compare(zc, pref_zc, wgt, pref_wgt)) 1248 continue; 1249 for_each_zcrypt_queue(zq, zc) { 1250 /* check if device is usable and eligible */ 1251 if (!zq->online || !zq->ops->rng || 1252 !ap_queue_usable(zq->queue)) 1253 continue; 1254 if (!zcrypt_queue_compare(zq, pref_zq, wgt, pref_wgt)) 1255 continue; 1256 pref_zc = zc; 1257 pref_zq = zq; 1258 pref_wgt = wgt; 1259 } 1260 } 1261 pref_zq = zcrypt_pick_queue(pref_zc, pref_zq, &mod, wgt); 1262 spin_unlock(&zcrypt_list_lock); 1263 1264 if (!pref_zq) { 1265 pr_debug("no matching queue found => ENODEV\n"); 1266 rc = -ENODEV; 1267 goto out; 1268 } 1269 1270 qid = pref_zq->queue->qid; 1271 rc = pref_zq->ops->rng(pref_zq, buffer, &ap_msg); 1272 1273 spin_lock(&zcrypt_list_lock); 1274 zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt); 1275 spin_unlock(&zcrypt_list_lock); 1276 1277 out: 1278 ap_release_apmsg(&ap_msg); 1279 trace_s390_zcrypt_rep(buffer, func_code, rc, 1280 AP_QID_CARD(qid), AP_QID_QUEUE(qid), 1281 ap_msg.psmid); 1282 return rc; 1283 } 1284 1285 static void zcrypt_device_status_mask(struct zcrypt_device_status *devstatus) 1286 { 1287 struct zcrypt_card *zc; 1288 struct zcrypt_queue *zq; 1289 struct zcrypt_device_status *stat; 1290 int card, queue; 1291 1292 memset(devstatus, 0, MAX_ZDEV_ENTRIES 1293 * sizeof(struct zcrypt_device_status)); 1294 1295 spin_lock(&zcrypt_list_lock); 1296 for_each_zcrypt_card(zc) { 1297 for_each_zcrypt_queue(zq, zc) { 1298 card = AP_QID_CARD(zq->queue->qid); 1299 if (card >= MAX_ZDEV_CARDIDS) 1300 continue; 1301 queue = AP_QID_QUEUE(zq->queue->qid); 1302 stat = &devstatus[card * AP_DOMAINS + queue]; 1303 stat->hwtype = zc->card->ap_dev.device_type; 1304 stat->functions = zc->card->hwinfo.fac >> 26; 1305 stat->qid = zq->queue->qid; 1306 stat->online = zq->online ? 0x01 : 0x00; 1307 } 1308 } 1309 spin_unlock(&zcrypt_list_lock); 1310 } 1311 1312 void zcrypt_device_status_mask_ext(struct zcrypt_device_status_ext *devstatus, 1313 int maxcard, int maxqueue) 1314 { 1315 struct zcrypt_card *zc; 1316 struct zcrypt_queue *zq; 1317 struct zcrypt_device_status_ext *stat; 1318 int card, queue; 1319 1320 maxcard = min_t(int, maxcard, MAX_ZDEV_CARDIDS_EXT); 1321 maxqueue = min_t(int, maxqueue, MAX_ZDEV_DOMAINS_EXT); 1322 1323 spin_lock(&zcrypt_list_lock); 1324 for_each_zcrypt_card(zc) { 1325 for_each_zcrypt_queue(zq, zc) { 1326 card = AP_QID_CARD(zq->queue->qid); 1327 queue = AP_QID_QUEUE(zq->queue->qid); 1328 if (card >= maxcard || queue >= maxqueue) 1329 continue; 1330 stat = &devstatus[card * maxqueue + queue]; 1331 stat->hwtype = zc->card->ap_dev.device_type; 1332 stat->functions = zc->card->hwinfo.fac >> 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->hwinfo.fac >> 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 do { 1499 rc = zcrypt_rsa_modexpo(perms, &tr, &mex); 1500 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1501 1502 /* on ENODEV failure: retry once again after a requested rescan */ 1503 if (rc == -ENODEV && zcrypt_process_rescan()) 1504 do { 1505 rc = zcrypt_rsa_modexpo(perms, &tr, &mex); 1506 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1507 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1508 rc = -EIO; 1509 if (rc) { 1510 pr_debug("ioctl ICARSAMODEXPO rc=%d\n", rc); 1511 return rc; 1512 } 1513 return put_user(mex.outputdatalength, &umex->outputdatalength); 1514 } 1515 1516 static int icarsacrt_ioctl(struct ap_perms *perms, unsigned long arg) 1517 { 1518 int rc; 1519 struct zcrypt_track tr; 1520 struct ica_rsa_modexpo_crt crt; 1521 struct ica_rsa_modexpo_crt __user *ucrt = (void __user *)arg; 1522 1523 memset(&tr, 0, sizeof(tr)); 1524 if (copy_from_user(&crt, ucrt, sizeof(crt))) 1525 return -EFAULT; 1526 1527 do { 1528 rc = zcrypt_rsa_crt(perms, &tr, &crt); 1529 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1530 1531 /* on ENODEV failure: retry once again after a requested rescan */ 1532 if (rc == -ENODEV && zcrypt_process_rescan()) 1533 do { 1534 rc = zcrypt_rsa_crt(perms, &tr, &crt); 1535 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1536 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1537 rc = -EIO; 1538 if (rc) { 1539 pr_debug("ioctl ICARSACRT rc=%d\n", rc); 1540 return rc; 1541 } 1542 return put_user(crt.outputdatalength, &ucrt->outputdatalength); 1543 } 1544 1545 static int zsecsendcprb_ioctl(struct ap_perms *perms, unsigned long arg) 1546 { 1547 int rc; 1548 struct ica_xcRB xcrb; 1549 struct zcrypt_track tr; 1550 u32 xflags = ZCRYPT_XFLAG_USERSPACE; 1551 struct ica_xcRB __user *uxcrb = (void __user *)arg; 1552 1553 memset(&tr, 0, sizeof(tr)); 1554 if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb))) 1555 return -EFAULT; 1556 1557 do { 1558 rc = _zcrypt_send_cprb(xflags, perms, &tr, &xcrb); 1559 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1560 1561 /* on ENODEV failure: retry once again after a requested rescan */ 1562 if (rc == -ENODEV && zcrypt_process_rescan()) 1563 do { 1564 rc = _zcrypt_send_cprb(xflags, perms, &tr, &xcrb); 1565 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1566 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1567 rc = -EIO; 1568 if (rc) 1569 pr_debug("ioctl ZSENDCPRB rc=%d status=0x%x\n", 1570 rc, xcrb.status); 1571 if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb))) 1572 return -EFAULT; 1573 return rc; 1574 } 1575 1576 static int zsendep11cprb_ioctl(struct ap_perms *perms, unsigned long arg) 1577 { 1578 int rc; 1579 struct ep11_urb xcrb; 1580 struct zcrypt_track tr; 1581 u32 xflags = ZCRYPT_XFLAG_USERSPACE; 1582 struct ep11_urb __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 do { 1589 rc = _zcrypt_send_ep11_cprb(xflags, perms, &tr, &xcrb); 1590 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1591 1592 /* on ENODEV failure: retry once again after a requested rescan */ 1593 if (rc == -ENODEV && zcrypt_process_rescan()) 1594 do { 1595 rc = _zcrypt_send_ep11_cprb(xflags, perms, &tr, &xcrb); 1596 } while (rc == -EAGAIN && ++tr.again_counter < TRACK_AGAIN_MAX); 1597 if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX) 1598 rc = -EIO; 1599 if (rc) 1600 pr_debug("ioctl ZSENDEP11CPRB rc=%d\n", rc); 1601 if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb))) 1602 return -EFAULT; 1603 return rc; 1604 } 1605 1606 static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd, 1607 unsigned long arg) 1608 { 1609 int rc; 1610 struct ap_perms *perms = 1611 (struct ap_perms *)filp->private_data; 1612 1613 rc = zcrypt_check_ioctl(perms, cmd); 1614 if (rc) 1615 return rc; 1616 1617 switch (cmd) { 1618 case ICARSAMODEXPO: 1619 return icarsamodexpo_ioctl(perms, arg); 1620 case ICARSACRT: 1621 return icarsacrt_ioctl(perms, arg); 1622 case ZSECSENDCPRB: 1623 return zsecsendcprb_ioctl(perms, arg); 1624 case ZSENDEP11CPRB: 1625 return zsendep11cprb_ioctl(perms, arg); 1626 case ZCRYPT_DEVICE_STATUS: { 1627 struct zcrypt_device_status_ext *device_status; 1628 size_t total_size = MAX_ZDEV_ENTRIES_EXT 1629 * sizeof(struct zcrypt_device_status_ext); 1630 1631 device_status = kvcalloc(MAX_ZDEV_ENTRIES_EXT, 1632 sizeof(struct zcrypt_device_status_ext), 1633 GFP_KERNEL); 1634 if (!device_status) 1635 return -ENOMEM; 1636 zcrypt_device_status_mask_ext(device_status, 1637 MAX_ZDEV_CARDIDS_EXT, 1638 MAX_ZDEV_DOMAINS_EXT); 1639 if (copy_to_user((char __user *)arg, device_status, 1640 total_size)) 1641 rc = -EFAULT; 1642 kvfree(device_status); 1643 return rc; 1644 } 1645 case ZCRYPT_STATUS_MASK: { 1646 char status[AP_DEVICES]; 1647 1648 zcrypt_status_mask(status, AP_DEVICES); 1649 if (copy_to_user((char __user *)arg, status, sizeof(status))) 1650 return -EFAULT; 1651 return 0; 1652 } 1653 case ZCRYPT_QDEPTH_MASK: { 1654 char qdepth[AP_DEVICES]; 1655 1656 zcrypt_qdepth_mask(qdepth, AP_DEVICES); 1657 if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth))) 1658 return -EFAULT; 1659 return 0; 1660 } 1661 case ZCRYPT_PERDEV_REQCNT: { 1662 u32 *reqcnt; 1663 1664 reqcnt = kcalloc(AP_DEVICES, sizeof(u32), GFP_KERNEL); 1665 if (!reqcnt) 1666 return -ENOMEM; 1667 zcrypt_perdev_reqcnt(reqcnt, AP_DEVICES); 1668 if (copy_to_user((int __user *)arg, reqcnt, 1669 sizeof(u32) * AP_DEVICES)) 1670 rc = -EFAULT; 1671 kfree(reqcnt); 1672 return rc; 1673 } 1674 case Z90STAT_REQUESTQ_COUNT: 1675 return put_user(zcrypt_requestq_count(), (int __user *)arg); 1676 case Z90STAT_PENDINGQ_COUNT: 1677 return put_user(zcrypt_pendingq_count(), (int __user *)arg); 1678 case Z90STAT_TOTALOPEN_COUNT: 1679 return put_user(atomic_read(&zcrypt_open_count), 1680 (int __user *)arg); 1681 case Z90STAT_DOMAIN_INDEX: 1682 return put_user(ap_domain_index, (int __user *)arg); 1683 /* 1684 * Deprecated ioctls 1685 */ 1686 case ZDEVICESTATUS: { 1687 /* the old ioctl supports only 64 adapters */ 1688 struct zcrypt_device_status *device_status; 1689 size_t total_size = MAX_ZDEV_ENTRIES 1690 * sizeof(struct zcrypt_device_status); 1691 1692 device_status = kzalloc(total_size, GFP_KERNEL); 1693 if (!device_status) 1694 return -ENOMEM; 1695 zcrypt_device_status_mask(device_status); 1696 if (copy_to_user((char __user *)arg, device_status, 1697 total_size)) 1698 rc = -EFAULT; 1699 kfree(device_status); 1700 return rc; 1701 } 1702 case Z90STAT_STATUS_MASK: { 1703 /* the old ioctl supports only 64 adapters */ 1704 char status[MAX_ZDEV_CARDIDS]; 1705 1706 zcrypt_status_mask(status, MAX_ZDEV_CARDIDS); 1707 if (copy_to_user((char __user *)arg, status, sizeof(status))) 1708 return -EFAULT; 1709 return 0; 1710 } 1711 case Z90STAT_QDEPTH_MASK: { 1712 /* the old ioctl supports only 64 adapters */ 1713 char qdepth[MAX_ZDEV_CARDIDS]; 1714 1715 zcrypt_qdepth_mask(qdepth, MAX_ZDEV_CARDIDS); 1716 if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth))) 1717 return -EFAULT; 1718 return 0; 1719 } 1720 case Z90STAT_PERDEV_REQCNT: { 1721 /* the old ioctl supports only 64 adapters */ 1722 u32 reqcnt[MAX_ZDEV_CARDIDS]; 1723 1724 zcrypt_perdev_reqcnt(reqcnt, MAX_ZDEV_CARDIDS); 1725 if (copy_to_user((int __user *)arg, reqcnt, sizeof(reqcnt))) 1726 return -EFAULT; 1727 return 0; 1728 } 1729 /* unknown ioctl number */ 1730 default: 1731 pr_debug("unknown ioctl 0x%08x\n", cmd); 1732 return -ENOIOCTLCMD; 1733 } 1734 } 1735 1736 /* 1737 * Misc device file operations. 1738 */ 1739 static const struct file_operations zcrypt_fops = { 1740 .owner = THIS_MODULE, 1741 .read = zcrypt_read, 1742 .write = zcrypt_write, 1743 .unlocked_ioctl = zcrypt_unlocked_ioctl, 1744 .open = zcrypt_open, 1745 .release = zcrypt_release, 1746 }; 1747 1748 /* 1749 * Misc device. 1750 */ 1751 static struct miscdevice zcrypt_misc_device = { 1752 .minor = MISC_DYNAMIC_MINOR, 1753 .name = "z90crypt", 1754 .fops = &zcrypt_fops, 1755 }; 1756 1757 static int zcrypt_rng_device_count; 1758 static u32 *zcrypt_rng_buffer; 1759 static int zcrypt_rng_buffer_index; 1760 static DEFINE_MUTEX(zcrypt_rng_mutex); 1761 1762 static int zcrypt_rng_data_read(struct hwrng *rng, u32 *data) 1763 { 1764 int rc; 1765 1766 /* 1767 * We don't need locking here because the RNG API guarantees serialized 1768 * read method calls. 1769 */ 1770 if (zcrypt_rng_buffer_index == 0) { 1771 rc = zcrypt_rng((char *)zcrypt_rng_buffer); 1772 /* on ENODEV failure: retry once again after an AP bus rescan */ 1773 if (rc == -ENODEV && zcrypt_process_rescan()) 1774 rc = zcrypt_rng((char *)zcrypt_rng_buffer); 1775 if (rc < 0) 1776 return -EIO; 1777 zcrypt_rng_buffer_index = rc / sizeof(*data); 1778 } 1779 *data = zcrypt_rng_buffer[--zcrypt_rng_buffer_index]; 1780 return sizeof(*data); 1781 } 1782 1783 static struct hwrng zcrypt_rng_dev = { 1784 .name = "zcrypt", 1785 .data_read = zcrypt_rng_data_read, 1786 .quality = 990, 1787 }; 1788 1789 int zcrypt_rng_device_add(void) 1790 { 1791 int rc = 0; 1792 1793 mutex_lock(&zcrypt_rng_mutex); 1794 if (zcrypt_rng_device_count == 0) { 1795 zcrypt_rng_buffer = (u32 *)get_zeroed_page(GFP_KERNEL); 1796 if (!zcrypt_rng_buffer) { 1797 rc = -ENOMEM; 1798 goto out; 1799 } 1800 zcrypt_rng_buffer_index = 0; 1801 rc = hwrng_register(&zcrypt_rng_dev); 1802 if (rc) 1803 goto out_free; 1804 zcrypt_rng_device_count = 1; 1805 } else { 1806 zcrypt_rng_device_count++; 1807 } 1808 mutex_unlock(&zcrypt_rng_mutex); 1809 return 0; 1810 1811 out_free: 1812 free_page((unsigned long)zcrypt_rng_buffer); 1813 out: 1814 mutex_unlock(&zcrypt_rng_mutex); 1815 return rc; 1816 } 1817 1818 void zcrypt_rng_device_remove(void) 1819 { 1820 mutex_lock(&zcrypt_rng_mutex); 1821 zcrypt_rng_device_count--; 1822 if (zcrypt_rng_device_count == 0) { 1823 hwrng_unregister(&zcrypt_rng_dev); 1824 free_page((unsigned long)zcrypt_rng_buffer); 1825 } 1826 mutex_unlock(&zcrypt_rng_mutex); 1827 } 1828 1829 /* 1830 * Wait until the zcrypt api is operational. 1831 * The AP bus scan and the binding of ap devices to device drivers is 1832 * an asynchronous job. This function waits until these initial jobs 1833 * are done and so the zcrypt api should be ready to serve crypto 1834 * requests - if there are resources available. The function uses an 1835 * internal timeout of 30s. The very first caller will either wait for 1836 * ap bus bindings complete or the timeout happens. This state will be 1837 * remembered for further callers which will only be blocked until a 1838 * decision is made (timeout or bindings complete). 1839 * On timeout -ETIME is returned, on success the return value is 0. 1840 */ 1841 int zcrypt_wait_api_operational(void) 1842 { 1843 static DEFINE_MUTEX(zcrypt_wait_api_lock); 1844 static int zcrypt_wait_api_state; 1845 int rc; 1846 1847 rc = mutex_lock_interruptible(&zcrypt_wait_api_lock); 1848 if (rc) 1849 return rc; 1850 1851 switch (zcrypt_wait_api_state) { 1852 case 0: 1853 /* initial state, invoke wait for the ap bus complete */ 1854 rc = ap_wait_apqn_bindings_complete( 1855 msecs_to_jiffies(ZCRYPT_WAIT_BINDINGS_COMPLETE_MS)); 1856 switch (rc) { 1857 case 0: 1858 /* ap bus bindings are complete */ 1859 zcrypt_wait_api_state = 1; 1860 break; 1861 case -EINTR: 1862 /* interrupted, go back to caller */ 1863 break; 1864 case -ETIME: 1865 /* timeout */ 1866 ZCRYPT_DBF_WARN("%s ap_wait_init_apqn_bindings_complete()=ETIME\n", 1867 __func__); 1868 zcrypt_wait_api_state = -ETIME; 1869 break; 1870 default: 1871 /* other failure */ 1872 pr_debug("ap_wait_init_apqn_bindings_complete()=%d\n", rc); 1873 break; 1874 } 1875 break; 1876 case 1: 1877 /* a previous caller already found ap bus bindings complete */ 1878 rc = 0; 1879 break; 1880 default: 1881 /* a previous caller had timeout or other failure */ 1882 rc = zcrypt_wait_api_state; 1883 break; 1884 } 1885 1886 mutex_unlock(&zcrypt_wait_api_lock); 1887 1888 return rc; 1889 } 1890 EXPORT_SYMBOL(zcrypt_wait_api_operational); 1891 1892 int __init zcrypt_debug_init(void) 1893 { 1894 zcrypt_dbf_info = debug_register("zcrypt", 2, 1, 1895 ZCRYPT_DBF_MAX_SPRINTF_ARGS * sizeof(long)); 1896 debug_register_view(zcrypt_dbf_info, &debug_sprintf_view); 1897 debug_set_level(zcrypt_dbf_info, DBF_ERR); 1898 1899 return 0; 1900 } 1901 1902 void zcrypt_debug_exit(void) 1903 { 1904 debug_unregister(zcrypt_dbf_info); 1905 } 1906 1907 static int __init zcdn_init(void) 1908 { 1909 int rc; 1910 1911 /* create a new class 'zcrypt' */ 1912 rc = class_register(&zcrypt_class); 1913 if (rc) 1914 goto out_class_register_failed; 1915 1916 /* alloc device minor range */ 1917 rc = alloc_chrdev_region(&zcrypt_devt, 1918 0, ZCRYPT_MAX_MINOR_NODES, 1919 ZCRYPT_NAME); 1920 if (rc) 1921 goto out_alloc_chrdev_failed; 1922 1923 cdev_init(&zcrypt_cdev, &zcrypt_fops); 1924 zcrypt_cdev.owner = THIS_MODULE; 1925 rc = cdev_add(&zcrypt_cdev, zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 1926 if (rc) 1927 goto out_cdev_add_failed; 1928 1929 /* need some class specific sysfs attributes */ 1930 rc = class_create_file(&zcrypt_class, &class_attr_zcdn_create); 1931 if (rc) 1932 goto out_class_create_file_1_failed; 1933 rc = class_create_file(&zcrypt_class, &class_attr_zcdn_destroy); 1934 if (rc) 1935 goto out_class_create_file_2_failed; 1936 1937 return 0; 1938 1939 out_class_create_file_2_failed: 1940 class_remove_file(&zcrypt_class, &class_attr_zcdn_create); 1941 out_class_create_file_1_failed: 1942 cdev_del(&zcrypt_cdev); 1943 out_cdev_add_failed: 1944 unregister_chrdev_region(zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 1945 out_alloc_chrdev_failed: 1946 class_unregister(&zcrypt_class); 1947 out_class_register_failed: 1948 return rc; 1949 } 1950 1951 static void zcdn_exit(void) 1952 { 1953 class_remove_file(&zcrypt_class, &class_attr_zcdn_create); 1954 class_remove_file(&zcrypt_class, &class_attr_zcdn_destroy); 1955 zcdn_destroy_all(); 1956 cdev_del(&zcrypt_cdev); 1957 unregister_chrdev_region(zcrypt_devt, ZCRYPT_MAX_MINOR_NODES); 1958 class_unregister(&zcrypt_class); 1959 } 1960 1961 /* 1962 * zcrypt_api_init(): Module initialization. 1963 * 1964 * The module initialization code. 1965 */ 1966 int __init zcrypt_api_init(void) 1967 { 1968 int rc; 1969 1970 /* make sure the mempool threshold is >= 1 */ 1971 if (zcrypt_mempool_threshold < 1) { 1972 rc = -EINVAL; 1973 goto out; 1974 } 1975 1976 rc = zcrypt_debug_init(); 1977 if (rc) 1978 goto out; 1979 1980 rc = zcdn_init(); 1981 if (rc) 1982 goto out_zcdn_init_failed; 1983 1984 rc = zcrypt_ccamisc_init(); 1985 if (rc) 1986 goto out_ccamisc_init_failed; 1987 1988 rc = zcrypt_ep11misc_init(); 1989 if (rc) 1990 goto out_ep11misc_init_failed; 1991 1992 /* Register the request sprayer. */ 1993 rc = misc_register(&zcrypt_misc_device); 1994 if (rc < 0) 1995 goto out_misc_register_failed; 1996 1997 zcrypt_msgtype6_init(); 1998 zcrypt_msgtype50_init(); 1999 2000 return 0; 2001 2002 out_misc_register_failed: 2003 zcrypt_ep11misc_exit(); 2004 out_ep11misc_init_failed: 2005 zcrypt_ccamisc_exit(); 2006 out_ccamisc_init_failed: 2007 zcdn_exit(); 2008 out_zcdn_init_failed: 2009 zcrypt_debug_exit(); 2010 out: 2011 return rc; 2012 } 2013 2014 /* 2015 * zcrypt_api_exit(): Module termination. 2016 * 2017 * The module termination code. 2018 */ 2019 void __exit zcrypt_api_exit(void) 2020 { 2021 zcdn_exit(); 2022 misc_deregister(&zcrypt_misc_device); 2023 zcrypt_msgtype6_exit(); 2024 zcrypt_msgtype50_exit(); 2025 zcrypt_ccamisc_exit(); 2026 zcrypt_ep11misc_exit(); 2027 zcrypt_debug_exit(); 2028 } 2029 2030 module_init(zcrypt_api_init); 2031 module_exit(zcrypt_api_exit); 2032