mirror of
https://github.com/torvalds/linux.git
synced 2024-12-08 12:11:30 +00:00
932b646727
When doing device passthrough where interrupts are being forwarded from host to guest, we wish to use a pinned section of guest memory as the vector (the same memory used by the guest as the vector). To accomplish this, add a new parameter for airq_iv_create which allows passing an existing vector to be used instead of allocating a new one. The caller is responsible for ensuring the vector is pinned in memory as well as for unpinning the memory when the vector is no longer needed. A subsequent patch will use this new parameter for zPCI interpretation. Reviewed-by: Thomas Huth <thuth@redhat.com> Reviewed-by: Pierre Morel <pmorel@linux.ibm.com> Reviewed-by: Claudio Imbrenda <imbrenda@linux.ibm.com> Acked-by: Cornelia Huck <cohuck@redhat.com> Signed-off-by: Matthew Rosato <mjrosato@linux.ibm.com> Link: https://lore.kernel.org/r/20220606203325.110625-7-mjrosato@linux.ibm.com Signed-off-by: Christian Borntraeger <borntraeger@linux.ibm.com>
316 lines
7.9 KiB
C
316 lines
7.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Support for adapter interruptions
|
|
*
|
|
* Copyright IBM Corp. 1999, 2007
|
|
* Author(s): Ingo Adlung <adlung@de.ibm.com>
|
|
* Cornelia Huck <cornelia.huck@de.ibm.com>
|
|
* Arnd Bergmann <arndb@de.ibm.com>
|
|
* Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/kernel_stat.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/rculist.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/dmapool.h>
|
|
|
|
#include <asm/airq.h>
|
|
#include <asm/isc.h>
|
|
#include <asm/cio.h>
|
|
|
|
#include "cio.h"
|
|
#include "cio_debug.h"
|
|
#include "ioasm.h"
|
|
|
|
static DEFINE_SPINLOCK(airq_lists_lock);
|
|
static struct hlist_head airq_lists[MAX_ISC+1];
|
|
|
|
static struct dma_pool *airq_iv_cache;
|
|
|
|
/**
|
|
* register_adapter_interrupt() - register adapter interrupt handler
|
|
* @airq: pointer to adapter interrupt descriptor
|
|
*
|
|
* Returns 0 on success, or -EINVAL.
|
|
*/
|
|
int register_adapter_interrupt(struct airq_struct *airq)
|
|
{
|
|
char dbf_txt[32];
|
|
|
|
if (!airq->handler || airq->isc > MAX_ISC)
|
|
return -EINVAL;
|
|
if (!airq->lsi_ptr) {
|
|
airq->lsi_ptr = cio_dma_zalloc(1);
|
|
if (!airq->lsi_ptr)
|
|
return -ENOMEM;
|
|
airq->flags |= AIRQ_PTR_ALLOCATED;
|
|
}
|
|
if (!airq->lsi_mask)
|
|
airq->lsi_mask = 0xff;
|
|
snprintf(dbf_txt, sizeof(dbf_txt), "rairq:%p", airq);
|
|
CIO_TRACE_EVENT(4, dbf_txt);
|
|
isc_register(airq->isc);
|
|
spin_lock(&airq_lists_lock);
|
|
hlist_add_head_rcu(&airq->list, &airq_lists[airq->isc]);
|
|
spin_unlock(&airq_lists_lock);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(register_adapter_interrupt);
|
|
|
|
/**
|
|
* unregister_adapter_interrupt - unregister adapter interrupt handler
|
|
* @airq: pointer to adapter interrupt descriptor
|
|
*/
|
|
void unregister_adapter_interrupt(struct airq_struct *airq)
|
|
{
|
|
char dbf_txt[32];
|
|
|
|
if (hlist_unhashed(&airq->list))
|
|
return;
|
|
snprintf(dbf_txt, sizeof(dbf_txt), "urairq:%p", airq);
|
|
CIO_TRACE_EVENT(4, dbf_txt);
|
|
spin_lock(&airq_lists_lock);
|
|
hlist_del_rcu(&airq->list);
|
|
spin_unlock(&airq_lists_lock);
|
|
synchronize_rcu();
|
|
isc_unregister(airq->isc);
|
|
if (airq->flags & AIRQ_PTR_ALLOCATED) {
|
|
cio_dma_free(airq->lsi_ptr, 1);
|
|
airq->lsi_ptr = NULL;
|
|
airq->flags &= ~AIRQ_PTR_ALLOCATED;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(unregister_adapter_interrupt);
|
|
|
|
static irqreturn_t do_airq_interrupt(int irq, void *dummy)
|
|
{
|
|
struct tpi_info *tpi_info;
|
|
struct airq_struct *airq;
|
|
struct hlist_head *head;
|
|
|
|
set_cpu_flag(CIF_NOHZ_DELAY);
|
|
tpi_info = &get_irq_regs()->tpi_info;
|
|
trace_s390_cio_adapter_int(tpi_info);
|
|
head = &airq_lists[tpi_info->isc];
|
|
rcu_read_lock();
|
|
hlist_for_each_entry_rcu(airq, head, list)
|
|
if ((*airq->lsi_ptr & airq->lsi_mask) != 0)
|
|
airq->handler(airq, tpi_info);
|
|
rcu_read_unlock();
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
void __init init_airq_interrupts(void)
|
|
{
|
|
irq_set_chip_and_handler(THIN_INTERRUPT,
|
|
&dummy_irq_chip, handle_percpu_irq);
|
|
if (request_irq(THIN_INTERRUPT, do_airq_interrupt, 0, "AIO", NULL))
|
|
panic("Failed to register AIO interrupt\n");
|
|
}
|
|
|
|
static inline unsigned long iv_size(unsigned long bits)
|
|
{
|
|
return BITS_TO_LONGS(bits) * sizeof(unsigned long);
|
|
}
|
|
|
|
/**
|
|
* airq_iv_create - create an interrupt vector
|
|
* @bits: number of bits in the interrupt vector
|
|
* @flags: allocation flags
|
|
* @vec: pointer to pinned guest memory if AIRQ_IV_GUESTVEC
|
|
*
|
|
* Returns a pointer to an interrupt vector structure
|
|
*/
|
|
struct airq_iv *airq_iv_create(unsigned long bits, unsigned long flags,
|
|
unsigned long *vec)
|
|
{
|
|
struct airq_iv *iv;
|
|
unsigned long size;
|
|
|
|
iv = kzalloc(sizeof(*iv), GFP_KERNEL);
|
|
if (!iv)
|
|
goto out;
|
|
iv->bits = bits;
|
|
iv->flags = flags;
|
|
size = iv_size(bits);
|
|
|
|
if (flags & AIRQ_IV_CACHELINE) {
|
|
if ((cache_line_size() * BITS_PER_BYTE) < bits
|
|
|| !airq_iv_cache)
|
|
goto out_free;
|
|
|
|
iv->vector = dma_pool_zalloc(airq_iv_cache, GFP_KERNEL,
|
|
&iv->vector_dma);
|
|
if (!iv->vector)
|
|
goto out_free;
|
|
} else if (flags & AIRQ_IV_GUESTVEC) {
|
|
iv->vector = vec;
|
|
} else {
|
|
iv->vector = cio_dma_zalloc(size);
|
|
if (!iv->vector)
|
|
goto out_free;
|
|
}
|
|
if (flags & AIRQ_IV_ALLOC) {
|
|
iv->avail = kmalloc(size, GFP_KERNEL);
|
|
if (!iv->avail)
|
|
goto out_free;
|
|
memset(iv->avail, 0xff, size);
|
|
iv->end = 0;
|
|
} else
|
|
iv->end = bits;
|
|
if (flags & AIRQ_IV_BITLOCK) {
|
|
iv->bitlock = kzalloc(size, GFP_KERNEL);
|
|
if (!iv->bitlock)
|
|
goto out_free;
|
|
}
|
|
if (flags & AIRQ_IV_PTR) {
|
|
size = bits * sizeof(unsigned long);
|
|
iv->ptr = kzalloc(size, GFP_KERNEL);
|
|
if (!iv->ptr)
|
|
goto out_free;
|
|
}
|
|
if (flags & AIRQ_IV_DATA) {
|
|
size = bits * sizeof(unsigned int);
|
|
iv->data = kzalloc(size, GFP_KERNEL);
|
|
if (!iv->data)
|
|
goto out_free;
|
|
}
|
|
spin_lock_init(&iv->lock);
|
|
return iv;
|
|
|
|
out_free:
|
|
kfree(iv->ptr);
|
|
kfree(iv->bitlock);
|
|
kfree(iv->avail);
|
|
if (iv->flags & AIRQ_IV_CACHELINE && iv->vector)
|
|
dma_pool_free(airq_iv_cache, iv->vector, iv->vector_dma);
|
|
else if (!(iv->flags & AIRQ_IV_GUESTVEC))
|
|
cio_dma_free(iv->vector, size);
|
|
kfree(iv);
|
|
out:
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(airq_iv_create);
|
|
|
|
/**
|
|
* airq_iv_release - release an interrupt vector
|
|
* @iv: pointer to interrupt vector structure
|
|
*/
|
|
void airq_iv_release(struct airq_iv *iv)
|
|
{
|
|
kfree(iv->data);
|
|
kfree(iv->ptr);
|
|
kfree(iv->bitlock);
|
|
if (iv->flags & AIRQ_IV_CACHELINE)
|
|
dma_pool_free(airq_iv_cache, iv->vector, iv->vector_dma);
|
|
else if (!(iv->flags & AIRQ_IV_GUESTVEC))
|
|
cio_dma_free(iv->vector, iv_size(iv->bits));
|
|
kfree(iv->avail);
|
|
kfree(iv);
|
|
}
|
|
EXPORT_SYMBOL(airq_iv_release);
|
|
|
|
/**
|
|
* airq_iv_alloc - allocate irq bits from an interrupt vector
|
|
* @iv: pointer to an interrupt vector structure
|
|
* @num: number of consecutive irq bits to allocate
|
|
*
|
|
* Returns the bit number of the first irq in the allocated block of irqs,
|
|
* or -1UL if no bit is available or the AIRQ_IV_ALLOC flag has not been
|
|
* specified
|
|
*/
|
|
unsigned long airq_iv_alloc(struct airq_iv *iv, unsigned long num)
|
|
{
|
|
unsigned long bit, i, flags;
|
|
|
|
if (!iv->avail || num == 0)
|
|
return -1UL;
|
|
spin_lock_irqsave(&iv->lock, flags);
|
|
bit = find_first_bit_inv(iv->avail, iv->bits);
|
|
while (bit + num <= iv->bits) {
|
|
for (i = 1; i < num; i++)
|
|
if (!test_bit_inv(bit + i, iv->avail))
|
|
break;
|
|
if (i >= num) {
|
|
/* Found a suitable block of irqs */
|
|
for (i = 0; i < num; i++)
|
|
clear_bit_inv(bit + i, iv->avail);
|
|
if (bit + num >= iv->end)
|
|
iv->end = bit + num + 1;
|
|
break;
|
|
}
|
|
bit = find_next_bit_inv(iv->avail, iv->bits, bit + i + 1);
|
|
}
|
|
if (bit + num > iv->bits)
|
|
bit = -1UL;
|
|
spin_unlock_irqrestore(&iv->lock, flags);
|
|
return bit;
|
|
}
|
|
EXPORT_SYMBOL(airq_iv_alloc);
|
|
|
|
/**
|
|
* airq_iv_free - free irq bits of an interrupt vector
|
|
* @iv: pointer to interrupt vector structure
|
|
* @bit: number of the first irq bit to free
|
|
* @num: number of consecutive irq bits to free
|
|
*/
|
|
void airq_iv_free(struct airq_iv *iv, unsigned long bit, unsigned long num)
|
|
{
|
|
unsigned long i, flags;
|
|
|
|
if (!iv->avail || num == 0)
|
|
return;
|
|
spin_lock_irqsave(&iv->lock, flags);
|
|
for (i = 0; i < num; i++) {
|
|
/* Clear (possibly left over) interrupt bit */
|
|
clear_bit_inv(bit + i, iv->vector);
|
|
/* Make the bit positions available again */
|
|
set_bit_inv(bit + i, iv->avail);
|
|
}
|
|
if (bit + num >= iv->end) {
|
|
/* Find new end of bit-field */
|
|
while (iv->end > 0 && !test_bit_inv(iv->end - 1, iv->avail))
|
|
iv->end--;
|
|
}
|
|
spin_unlock_irqrestore(&iv->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(airq_iv_free);
|
|
|
|
/**
|
|
* airq_iv_scan - scan interrupt vector for non-zero bits
|
|
* @iv: pointer to interrupt vector structure
|
|
* @start: bit number to start the search
|
|
* @end: bit number to end the search
|
|
*
|
|
* Returns the bit number of the next non-zero interrupt bit, or
|
|
* -1UL if the scan completed without finding any more any non-zero bits.
|
|
*/
|
|
unsigned long airq_iv_scan(struct airq_iv *iv, unsigned long start,
|
|
unsigned long end)
|
|
{
|
|
unsigned long bit;
|
|
|
|
/* Find non-zero bit starting from 'ivs->next'. */
|
|
bit = find_next_bit_inv(iv->vector, end, start);
|
|
if (bit >= end)
|
|
return -1UL;
|
|
clear_bit_inv(bit, iv->vector);
|
|
return bit;
|
|
}
|
|
EXPORT_SYMBOL(airq_iv_scan);
|
|
|
|
int __init airq_init(void)
|
|
{
|
|
airq_iv_cache = dma_pool_create("airq_iv_cache", cio_get_dma_css_dev(),
|
|
cache_line_size(),
|
|
cache_line_size(), PAGE_SIZE);
|
|
if (!airq_iv_cache)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|