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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.