1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * s390 kvm PCI passthrough support 4 * 5 * Copyright IBM Corp. 2022 6 * 7 * Author(s): Matthew Rosato <mjrosato@linux.ibm.com> 8 */ 9 10 #include <linux/kvm_host.h> 11 #include <linux/pci.h> 12 #include <asm/pci.h> 13 #include <asm/pci_insn.h> 14 #include <asm/pci_io.h> 15 #include <asm/sclp.h> 16 #include "pci.h" 17 #include "kvm-s390.h" 18 19 struct zpci_aift *aift; 20 21 static inline int __set_irq_noiib(u16 ctl, u8 isc) 22 { 23 union zpci_sic_iib iib = {{0}}; 24 25 return zpci_set_irq_ctrl(ctl, isc, &iib); 26 } 27 28 void kvm_s390_pci_aen_exit(void) 29 { 30 unsigned long flags; 31 struct kvm_zdev **gait_kzdev; 32 33 lockdep_assert_held(&aift->aift_lock); 34 35 /* 36 * Contents of the aipb remain registered for the life of the host 37 * kernel, the information preserved in zpci_aipb and zpci_aif_sbv 38 * in case we insert the KVM module again later. Clear the AIFT 39 * information and free anything not registered with underlying 40 * firmware. 41 */ 42 spin_lock_irqsave(&aift->gait_lock, flags); 43 gait_kzdev = aift->kzdev; 44 aift->gait = NULL; 45 aift->sbv = NULL; 46 aift->kzdev = NULL; 47 spin_unlock_irqrestore(&aift->gait_lock, flags); 48 49 kfree(gait_kzdev); 50 } 51 52 static int zpci_setup_aipb(u8 nisc) 53 { 54 struct page *page; 55 int size, rc; 56 57 zpci_aipb = kzalloc(sizeof(union zpci_sic_iib), GFP_KERNEL); 58 if (!zpci_aipb) 59 return -ENOMEM; 60 61 aift->sbv = airq_iv_create(ZPCI_NR_DEVICES, AIRQ_IV_ALLOC, NULL); 62 if (!aift->sbv) { 63 rc = -ENOMEM; 64 goto free_aipb; 65 } 66 zpci_aif_sbv = aift->sbv; 67 size = get_order(PAGE_ALIGN(ZPCI_NR_DEVICES * 68 sizeof(struct zpci_gaite))); 69 page = alloc_pages(GFP_KERNEL | __GFP_ZERO, size); 70 if (!page) { 71 rc = -ENOMEM; 72 goto free_sbv; 73 } 74 aift->gait = (struct zpci_gaite *)page_to_virt(page); 75 76 zpci_aipb->aipb.faisb = virt_to_phys(aift->sbv->vector); 77 zpci_aipb->aipb.gait = virt_to_phys(aift->gait); 78 zpci_aipb->aipb.afi = nisc; 79 zpci_aipb->aipb.faal = ZPCI_NR_DEVICES; 80 81 /* Setup Adapter Event Notification Interpretation */ 82 if (zpci_set_irq_ctrl(SIC_SET_AENI_CONTROLS, 0, zpci_aipb)) { 83 rc = -EIO; 84 goto free_gait; 85 } 86 87 return 0; 88 89 free_gait: 90 free_pages((unsigned long)aift->gait, size); 91 free_sbv: 92 airq_iv_release(aift->sbv); 93 zpci_aif_sbv = NULL; 94 free_aipb: 95 kfree(zpci_aipb); 96 zpci_aipb = NULL; 97 98 return rc; 99 } 100 101 static int zpci_reset_aipb(u8 nisc) 102 { 103 /* 104 * AEN registration can only happen once per system boot. If 105 * an aipb already exists then AEN was already registered and 106 * we can re-use the aipb contents. This can only happen if 107 * the KVM module was removed and re-inserted. However, we must 108 * ensure that the same forwarding ISC is used as this is assigned 109 * during KVM module load. 110 */ 111 if (zpci_aipb->aipb.afi != nisc) 112 return -EINVAL; 113 114 aift->sbv = zpci_aif_sbv; 115 aift->gait = phys_to_virt(zpci_aipb->aipb.gait); 116 117 return 0; 118 } 119 120 int kvm_s390_pci_aen_init(u8 nisc) 121 { 122 int rc = 0; 123 124 /* If already enabled for AEN, bail out now */ 125 if (aift->gait || aift->sbv) 126 return -EPERM; 127 128 mutex_lock(&aift->aift_lock); 129 aift->kzdev = kcalloc(ZPCI_NR_DEVICES, sizeof(struct kvm_zdev *), 130 GFP_KERNEL); 131 if (!aift->kzdev) { 132 rc = -ENOMEM; 133 goto unlock; 134 } 135 136 if (!zpci_aipb) 137 rc = zpci_setup_aipb(nisc); 138 else 139 rc = zpci_reset_aipb(nisc); 140 if (rc) 141 goto free_zdev; 142 143 /* Enable floating IRQs */ 144 if (__set_irq_noiib(SIC_IRQ_MODE_SINGLE, nisc)) { 145 rc = -EIO; 146 kvm_s390_pci_aen_exit(); 147 } 148 149 goto unlock; 150 151 free_zdev: 152 kfree(aift->kzdev); 153 unlock: 154 mutex_unlock(&aift->aift_lock); 155 return rc; 156 } 157 158 /* Modify PCI: Register floating adapter interruption forwarding */ 159 static int kvm_zpci_set_airq(struct zpci_dev *zdev) 160 { 161 u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_REG_INT); 162 struct zpci_fib fib = {}; 163 u8 status; 164 165 fib.fmt0.isc = zdev->kzdev->fib.fmt0.isc; 166 fib.fmt0.sum = 1; /* enable summary notifications */ 167 fib.fmt0.noi = airq_iv_end(zdev->aibv); 168 fib.fmt0.aibv = virt_to_phys(zdev->aibv->vector); 169 fib.fmt0.aibvo = 0; 170 fib.fmt0.aisb = virt_to_phys(aift->sbv->vector + (zdev->aisb / 64) * 8); 171 fib.fmt0.aisbo = zdev->aisb & 63; 172 fib.gd = zdev->gisa; 173 174 return zpci_mod_fc(req, &fib, &status) ? -EIO : 0; 175 } 176 177 /* Modify PCI: Unregister floating adapter interruption forwarding */ 178 static int kvm_zpci_clear_airq(struct zpci_dev *zdev) 179 { 180 u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_DEREG_INT); 181 struct zpci_fib fib = {}; 182 u8 cc, status; 183 184 fib.gd = zdev->gisa; 185 186 cc = zpci_mod_fc(req, &fib, &status); 187 if (cc == 3 || (cc == 1 && status == 24)) 188 /* Function already gone or IRQs already deregistered. */ 189 cc = 0; 190 191 return cc ? -EIO : 0; 192 } 193 194 static inline void unaccount_mem(unsigned long nr_pages) 195 { 196 struct user_struct *user = get_uid(current_user()); 197 198 if (user) 199 atomic_long_sub(nr_pages, &user->locked_vm); 200 if (current->mm) 201 atomic64_sub(nr_pages, ¤t->mm->pinned_vm); 202 } 203 204 static inline int account_mem(unsigned long nr_pages) 205 { 206 struct user_struct *user = get_uid(current_user()); 207 unsigned long page_limit, cur_pages, new_pages; 208 209 page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT; 210 211 do { 212 cur_pages = atomic_long_read(&user->locked_vm); 213 new_pages = cur_pages + nr_pages; 214 if (new_pages > page_limit) 215 return -ENOMEM; 216 } while (atomic_long_cmpxchg(&user->locked_vm, cur_pages, 217 new_pages) != cur_pages); 218 219 atomic64_add(nr_pages, ¤t->mm->pinned_vm); 220 221 return 0; 222 } 223 224 static int kvm_s390_pci_aif_enable(struct zpci_dev *zdev, struct zpci_fib *fib, 225 bool assist) 226 { 227 struct page *pages[1], *aibv_page, *aisb_page = NULL; 228 unsigned int msi_vecs, idx; 229 struct zpci_gaite *gaite; 230 unsigned long hva, bit; 231 struct kvm *kvm; 232 phys_addr_t gaddr; 233 int rc = 0, gisc, npages, pcount = 0; 234 235 /* 236 * Interrupt forwarding is only applicable if the device is already 237 * enabled for interpretation 238 */ 239 if (zdev->gisa == 0) 240 return -EINVAL; 241 242 kvm = zdev->kzdev->kvm; 243 msi_vecs = min_t(unsigned int, fib->fmt0.noi, zdev->max_msi); 244 245 /* Get the associated forwarding ISC - if invalid, return the error */ 246 gisc = kvm_s390_gisc_register(kvm, fib->fmt0.isc); 247 if (gisc < 0) 248 return gisc; 249 250 /* Replace AIBV address */ 251 idx = srcu_read_lock(&kvm->srcu); 252 hva = gfn_to_hva(kvm, gpa_to_gfn((gpa_t)fib->fmt0.aibv)); 253 npages = pin_user_pages_fast(hva, 1, FOLL_WRITE | FOLL_LONGTERM, pages); 254 srcu_read_unlock(&kvm->srcu, idx); 255 if (npages < 1) { 256 rc = -EIO; 257 goto out; 258 } 259 aibv_page = pages[0]; 260 pcount++; 261 gaddr = page_to_phys(aibv_page) + (fib->fmt0.aibv & ~PAGE_MASK); 262 fib->fmt0.aibv = gaddr; 263 264 /* Pin the guest AISB if one was specified */ 265 if (fib->fmt0.sum == 1) { 266 idx = srcu_read_lock(&kvm->srcu); 267 hva = gfn_to_hva(kvm, gpa_to_gfn((gpa_t)fib->fmt0.aisb)); 268 npages = pin_user_pages_fast(hva, 1, FOLL_WRITE | FOLL_LONGTERM, 269 pages); 270 srcu_read_unlock(&kvm->srcu, idx); 271 if (npages < 1) { 272 rc = -EIO; 273 goto unpin1; 274 } 275 aisb_page = pages[0]; 276 pcount++; 277 } 278 279 /* Account for pinned pages, roll back on failure */ 280 if (account_mem(pcount)) 281 goto unpin2; 282 283 /* AISB must be allocated before we can fill in GAITE */ 284 mutex_lock(&aift->aift_lock); 285 bit = airq_iv_alloc_bit(aift->sbv); 286 if (bit == -1UL) 287 goto unlock; 288 zdev->aisb = bit; /* store the summary bit number */ 289 zdev->aibv = airq_iv_create(msi_vecs, AIRQ_IV_DATA | 290 AIRQ_IV_BITLOCK | 291 AIRQ_IV_GUESTVEC, 292 phys_to_virt(fib->fmt0.aibv)); 293 294 spin_lock_irq(&aift->gait_lock); 295 gaite = (struct zpci_gaite *)aift->gait + (zdev->aisb * 296 sizeof(struct zpci_gaite)); 297 298 /* If assist not requested, host will get all alerts */ 299 if (assist) 300 gaite->gisa = (u32)virt_to_phys(&kvm->arch.sie_page2->gisa); 301 else 302 gaite->gisa = 0; 303 304 gaite->gisc = fib->fmt0.isc; 305 gaite->count++; 306 gaite->aisbo = fib->fmt0.aisbo; 307 gaite->aisb = virt_to_phys(page_address(aisb_page) + (fib->fmt0.aisb & 308 ~PAGE_MASK)); 309 aift->kzdev[zdev->aisb] = zdev->kzdev; 310 spin_unlock_irq(&aift->gait_lock); 311 312 /* Update guest FIB for re-issue */ 313 fib->fmt0.aisbo = zdev->aisb & 63; 314 fib->fmt0.aisb = virt_to_phys(aift->sbv->vector + (zdev->aisb / 64) * 8); 315 fib->fmt0.isc = gisc; 316 317 /* Save some guest fib values in the host for later use */ 318 zdev->kzdev->fib.fmt0.isc = fib->fmt0.isc; 319 zdev->kzdev->fib.fmt0.aibv = fib->fmt0.aibv; 320 mutex_unlock(&aift->aift_lock); 321 322 /* Issue the clp to setup the irq now */ 323 rc = kvm_zpci_set_airq(zdev); 324 return rc; 325 326 unlock: 327 mutex_unlock(&aift->aift_lock); 328 unpin2: 329 if (fib->fmt0.sum == 1) 330 unpin_user_page(aisb_page); 331 unpin1: 332 unpin_user_page(aibv_page); 333 out: 334 return rc; 335 } 336 337 static int kvm_s390_pci_aif_disable(struct zpci_dev *zdev, bool force) 338 { 339 struct kvm_zdev *kzdev = zdev->kzdev; 340 struct zpci_gaite *gaite; 341 struct page *vpage = NULL, *spage = NULL; 342 int rc, pcount = 0; 343 u8 isc; 344 345 if (zdev->gisa == 0) 346 return -EINVAL; 347 348 mutex_lock(&aift->aift_lock); 349 350 /* 351 * If the clear fails due to an error, leave now unless we know this 352 * device is about to go away (force) -- In that case clear the GAITE 353 * regardless. 354 */ 355 rc = kvm_zpci_clear_airq(zdev); 356 if (rc && !force) 357 goto out; 358 359 if (zdev->kzdev->fib.fmt0.aibv == 0) 360 goto out; 361 spin_lock_irq(&aift->gait_lock); 362 gaite = (struct zpci_gaite *)aift->gait + (zdev->aisb * 363 sizeof(struct zpci_gaite)); 364 isc = gaite->gisc; 365 gaite->count--; 366 if (gaite->count == 0) { 367 /* Release guest AIBV and AISB */ 368 vpage = phys_to_page(kzdev->fib.fmt0.aibv); 369 if (gaite->aisb != 0) 370 spage = phys_to_page(gaite->aisb); 371 /* Clear the GAIT entry */ 372 gaite->aisb = 0; 373 gaite->gisc = 0; 374 gaite->aisbo = 0; 375 gaite->gisa = 0; 376 aift->kzdev[zdev->aisb] = NULL; 377 /* Clear zdev info */ 378 airq_iv_free_bit(aift->sbv, zdev->aisb); 379 airq_iv_release(zdev->aibv); 380 zdev->aisb = 0; 381 zdev->aibv = NULL; 382 } 383 spin_unlock_irq(&aift->gait_lock); 384 kvm_s390_gisc_unregister(kzdev->kvm, isc); 385 kzdev->fib.fmt0.isc = 0; 386 kzdev->fib.fmt0.aibv = 0; 387 388 if (vpage) { 389 unpin_user_page(vpage); 390 pcount++; 391 } 392 if (spage) { 393 unpin_user_page(spage); 394 pcount++; 395 } 396 if (pcount > 0) 397 unaccount_mem(pcount); 398 out: 399 mutex_unlock(&aift->aift_lock); 400 401 return rc; 402 } 403 404 static int kvm_s390_pci_dev_open(struct zpci_dev *zdev) 405 { 406 struct kvm_zdev *kzdev; 407 408 kzdev = kzalloc(sizeof(struct kvm_zdev), GFP_KERNEL); 409 if (!kzdev) 410 return -ENOMEM; 411 412 kzdev->zdev = zdev; 413 zdev->kzdev = kzdev; 414 415 return 0; 416 } 417 418 static void kvm_s390_pci_dev_release(struct zpci_dev *zdev) 419 { 420 struct kvm_zdev *kzdev; 421 422 kzdev = zdev->kzdev; 423 WARN_ON(kzdev->zdev != zdev); 424 zdev->kzdev = NULL; 425 kfree(kzdev); 426 } 427 428 429 /* 430 * Register device with the specified KVM. If interpretation facilities are 431 * available, enable them and let userspace indicate whether or not they will 432 * be used (specify SHM bit to disable). 433 */ 434 static int kvm_s390_pci_register_kvm(void *opaque, struct kvm *kvm) 435 { 436 struct zpci_dev *zdev = opaque; 437 u8 status; 438 int rc; 439 440 if (!zdev) 441 return -EINVAL; 442 443 mutex_lock(&zdev->kzdev_lock); 444 445 if (zdev->kzdev || zdev->gisa != 0 || !kvm) { 446 mutex_unlock(&zdev->kzdev_lock); 447 return -EINVAL; 448 } 449 450 kvm_get_kvm(kvm); 451 452 mutex_lock(&kvm->lock); 453 454 rc = kvm_s390_pci_dev_open(zdev); 455 if (rc) 456 goto err; 457 458 /* 459 * If interpretation facilities aren't available, add the device to 460 * the kzdev list but don't enable for interpretation. 461 */ 462 if (!kvm_s390_pci_interp_allowed()) 463 goto out; 464 465 /* 466 * If this is the first request to use an interpreted device, make the 467 * necessary vcpu changes 468 */ 469 if (!kvm->arch.use_zpci_interp) 470 kvm_s390_vcpu_pci_enable_interp(kvm); 471 472 if (zdev_enabled(zdev)) { 473 rc = zpci_disable_device(zdev); 474 if (rc) 475 goto err; 476 } 477 478 /* 479 * Store information about the identity of the kvm guest allowed to 480 * access this device via interpretation to be used by host CLP 481 */ 482 zdev->gisa = (u32)virt_to_phys(&kvm->arch.sie_page2->gisa); 483 484 rc = zpci_enable_device(zdev); 485 if (rc) 486 goto clear_gisa; 487 488 /* Re-register the IOMMU that was already created */ 489 rc = zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma, 490 virt_to_phys(zdev->dma_table), &status); 491 if (rc) 492 goto clear_gisa; 493 494 out: 495 zdev->kzdev->kvm = kvm; 496 497 spin_lock(&kvm->arch.kzdev_list_lock); 498 list_add_tail(&zdev->kzdev->entry, &kvm->arch.kzdev_list); 499 spin_unlock(&kvm->arch.kzdev_list_lock); 500 501 mutex_unlock(&kvm->lock); 502 mutex_unlock(&zdev->kzdev_lock); 503 return 0; 504 505 clear_gisa: 506 zdev->gisa = 0; 507 err: 508 if (zdev->kzdev) 509 kvm_s390_pci_dev_release(zdev); 510 mutex_unlock(&kvm->lock); 511 mutex_unlock(&zdev->kzdev_lock); 512 kvm_put_kvm(kvm); 513 return rc; 514 } 515 516 static void kvm_s390_pci_unregister_kvm(void *opaque) 517 { 518 struct zpci_dev *zdev = opaque; 519 struct kvm *kvm; 520 u8 status; 521 522 if (!zdev) 523 return; 524 525 mutex_lock(&zdev->kzdev_lock); 526 527 if (WARN_ON(!zdev->kzdev)) { 528 mutex_unlock(&zdev->kzdev_lock); 529 return; 530 } 531 532 kvm = zdev->kzdev->kvm; 533 mutex_lock(&kvm->lock); 534 535 /* 536 * A 0 gisa means interpretation was never enabled, just remove the 537 * device from the list. 538 */ 539 if (zdev->gisa == 0) 540 goto out; 541 542 /* Forwarding must be turned off before interpretation */ 543 if (zdev->kzdev->fib.fmt0.aibv != 0) 544 kvm_s390_pci_aif_disable(zdev, true); 545 546 /* Remove the host CLP guest designation */ 547 zdev->gisa = 0; 548 549 if (zdev_enabled(zdev)) { 550 if (zpci_disable_device(zdev)) 551 goto out; 552 } 553 554 if (zpci_enable_device(zdev)) 555 goto out; 556 557 /* Re-register the IOMMU that was already created */ 558 zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma, 559 virt_to_phys(zdev->dma_table), &status); 560 561 out: 562 spin_lock(&kvm->arch.kzdev_list_lock); 563 list_del(&zdev->kzdev->entry); 564 spin_unlock(&kvm->arch.kzdev_list_lock); 565 kvm_s390_pci_dev_release(zdev); 566 567 mutex_unlock(&kvm->lock); 568 mutex_unlock(&zdev->kzdev_lock); 569 570 kvm_put_kvm(kvm); 571 } 572 573 void kvm_s390_pci_init_list(struct kvm *kvm) 574 { 575 spin_lock_init(&kvm->arch.kzdev_list_lock); 576 INIT_LIST_HEAD(&kvm->arch.kzdev_list); 577 } 578 579 void kvm_s390_pci_clear_list(struct kvm *kvm) 580 { 581 /* 582 * This list should already be empty, either via vfio device closures 583 * or kvm fd cleanup. 584 */ 585 spin_lock(&kvm->arch.kzdev_list_lock); 586 WARN_ON_ONCE(!list_empty(&kvm->arch.kzdev_list)); 587 spin_unlock(&kvm->arch.kzdev_list_lock); 588 } 589 590 static struct zpci_dev *get_zdev_from_kvm_by_fh(struct kvm *kvm, u32 fh) 591 { 592 struct zpci_dev *zdev = NULL; 593 struct kvm_zdev *kzdev; 594 595 spin_lock(&kvm->arch.kzdev_list_lock); 596 list_for_each_entry(kzdev, &kvm->arch.kzdev_list, entry) { 597 if (kzdev->zdev->fh == fh) { 598 zdev = kzdev->zdev; 599 break; 600 } 601 } 602 spin_unlock(&kvm->arch.kzdev_list_lock); 603 604 return zdev; 605 } 606 607 static int kvm_s390_pci_zpci_reg_aen(struct zpci_dev *zdev, 608 struct kvm_s390_zpci_op *args) 609 { 610 struct zpci_fib fib = {}; 611 bool hostflag; 612 613 fib.fmt0.aibv = args->u.reg_aen.ibv; 614 fib.fmt0.isc = args->u.reg_aen.isc; 615 fib.fmt0.noi = args->u.reg_aen.noi; 616 if (args->u.reg_aen.sb != 0) { 617 fib.fmt0.aisb = args->u.reg_aen.sb; 618 fib.fmt0.aisbo = args->u.reg_aen.sbo; 619 fib.fmt0.sum = 1; 620 } else { 621 fib.fmt0.aisb = 0; 622 fib.fmt0.aisbo = 0; 623 fib.fmt0.sum = 0; 624 } 625 626 hostflag = !(args->u.reg_aen.flags & KVM_S390_ZPCIOP_REGAEN_HOST); 627 return kvm_s390_pci_aif_enable(zdev, &fib, hostflag); 628 } 629 630 int kvm_s390_pci_zpci_op(struct kvm *kvm, struct kvm_s390_zpci_op *args) 631 { 632 struct kvm_zdev *kzdev; 633 struct zpci_dev *zdev; 634 int r; 635 636 zdev = get_zdev_from_kvm_by_fh(kvm, args->fh); 637 if (!zdev) 638 return -ENODEV; 639 640 mutex_lock(&zdev->kzdev_lock); 641 mutex_lock(&kvm->lock); 642 643 kzdev = zdev->kzdev; 644 if (!kzdev) { 645 r = -ENODEV; 646 goto out; 647 } 648 if (kzdev->kvm != kvm) { 649 r = -EPERM; 650 goto out; 651 } 652 653 switch (args->op) { 654 case KVM_S390_ZPCIOP_REG_AEN: 655 /* Fail on unknown flags */ 656 if (args->u.reg_aen.flags & ~KVM_S390_ZPCIOP_REGAEN_HOST) { 657 r = -EINVAL; 658 break; 659 } 660 r = kvm_s390_pci_zpci_reg_aen(zdev, args); 661 break; 662 case KVM_S390_ZPCIOP_DEREG_AEN: 663 r = kvm_s390_pci_aif_disable(zdev, false); 664 break; 665 default: 666 r = -EINVAL; 667 } 668 669 out: 670 mutex_unlock(&kvm->lock); 671 mutex_unlock(&zdev->kzdev_lock); 672 return r; 673 } 674 675 int __init kvm_s390_pci_init(void) 676 { 677 zpci_kvm_hook.kvm_register = kvm_s390_pci_register_kvm; 678 zpci_kvm_hook.kvm_unregister = kvm_s390_pci_unregister_kvm; 679 680 if (!kvm_s390_pci_interp_allowed()) 681 return 0; 682 683 aift = kzalloc(sizeof(struct zpci_aift), GFP_KERNEL); 684 if (!aift) 685 return -ENOMEM; 686 687 spin_lock_init(&aift->gait_lock); 688 mutex_init(&aift->aift_lock); 689 690 return 0; 691 } 692 693 void kvm_s390_pci_exit(void) 694 { 695 zpci_kvm_hook.kvm_register = NULL; 696 zpci_kvm_hook.kvm_unregister = NULL; 697 698 if (!kvm_s390_pci_interp_allowed()) 699 return; 700 701 mutex_destroy(&aift->aift_lock); 702 703 kfree(aift); 704 } 705