On 18.07.2016 15:34, Alexander Popov wrote:
> On 16.07.2016 11:22, Marc Zyngier wrote:
>> On Sat, 16 Jul 2016 04:33:59 +0300
>> Alexander Popov <alex.po...@linux.com> wrote:
>>
>>> On 08.07.2016 11:34, Alexander Popov wrote:
>>>> On 06.07.2016 14:17, Thomas Gleixner wrote:
>>>>> On Fri, 1 Jul 2016, Alexander Popov wrote:
>>>>>
>>>>>> Export __irq_domain_alloc_irqs() and irq_domain_free_irqs() for being
>>>>>> able to work with irq_domain hierarchy in modules.
>>>>>
>>>>> We usually export only when we have a proper use case which is supposed
>>>>> to go
>>>>> into the kernel tree proper. What's yours?
>
> ...
>
>>> Did I properly answer your question? Will you accept my patch exporting
>>> these
>>> two functions?
>>
>> I think that without any in-tree modular users of these symbols, the
>> incentive for exporting those is pretty low. I can't really say
>> anything about your particular use-case, but I'd really to see some
>> code before taking that kind of patch.
>
> Thanks for your answer, Mark.
>
> Here is the module which uses __irq_domain_alloc_irqs() and
> irq_domain_free_irqs() and allows registering IRQ handlers for interrupts
> injected by the hypervisor on x86_64. Large hypervisors usually emulate
> an MSI-capable PCI device to do this job, but that way is inappropriate
> for lightweight hypervisors.
I hope that the code below is a valid use-case of irq_domain hierarchy API.
Such simple registration of IRQ handlers for interrupts injected by a hypervisor
is great for lightweight hypervisors, which avoid as much emulation as possible.
It only needs __irq_domain_alloc_irqs() and irq_domain_free_irqs() to be
exported to modules. Will you apply my patch which exports them?
[Add CC to KVM people to share the idea and, hopefully, find anybody interested]
> /*
> * The module for registering IRQ handlers for interrupts injected
> * by the hypervisor using Intel VT-x technology. This module targets
> * x86_64 platform.
> *
> * It works fine if __irq_domain_alloc_irqs() and irq_domain_free_irqs()
> * are exported.
> */
>
> #include <linux/module.h>
> #include <linux/irq.h>
> #include <linux/irqdesc.h>
> #include <linux/irqnr.h>
> #include <linux/irqdomain.h>
> #include <linux/interrupt.h>
> #include <asm/hw_irq.h>
> #include <asm/irqdomain.h>
>
> #define PARAVIRT_IRQS_N 10
>
> struct irq_domain *paravirq_domain = NULL;
> static int paravirq_irqbase = -EINVAL;
> static int paravirq_irqs[PARAVIRT_IRQS_N] =
> {[0 ... PARAVIRT_IRQS_N - 1] = -EINVAL};
>
> static irqreturn_t paravirq_irq_handler(int irq, void *cookie)
> {
> printk("\tparavirq_irq_handler: virq %d\n", irq);
>
> /* ... some job ... */
>
> return IRQ_HANDLED;
> }
>
> static void paravirq_chip_irq_mask(struct irq_data *data)
> {
> printk("\tparavirq_chip_irq_mask\n");
>
> /* ... tell the hypervisor not to inject the interrupt ... */
> }
>
> static void paravirq_chip_irq_unmask(struct irq_data *data)
> {
> printk("\tparavirq_chip_irq_UNmask\n");
>
> /* ... allow the hypervisor to inject the interrupt ... */
> }
>
> static void paravirq_chip_ack(struct irq_data *data)
> {
> data = data->parent_data;
> data->chip->irq_ack(data);
> }
>
> static struct irq_chip paravirq_chip __read_mostly = {
> .name = "PARAVIRQ",
> .irq_mask = paravirq_chip_irq_mask,
> .irq_unmask = paravirq_chip_irq_unmask,
> .irq_ack = paravirq_chip_ack,
> };
>
> static int paravirq_domain_alloc(struct irq_domain *domain,
> unsigned int virq, unsigned int nr_irqs, void *arg)
> {
> int ret = 0;
> unsigned int i = 0;
> unsigned int irq = 0;
>
> printk("\tparavirq_domain_alloc: virq %u, nr_irqs %u, arg 0x%p\n",
> virq, nr_irqs, arg);
> for (i = 0; i < nr_irqs; i++) {
> irq = virq + i;
>
> ret = irq_domain_set_hwirq_and_chip(domain,
> irq, i, ¶virq_chip, NULL);
> if (ret) {
> printk("\t\tsetting chip, hwirq for %d failed\n", irq);
> return ret;
> }
>
> __irq_set_handler(irq, handle_edge_irq, 0, "edge");
> }
>
> return 0;
> }
>
> static void paravirq_domain_free(struct irq_domain *domain, unsigned int virq,
> unsigned int nr_irqs)
> {
> int ret = 0;
> unsigned int i = 0;
> unsigned int irq = 0;
>
> printk("\tparavirq_domain_free: virq %u, nr_irqs %u\n", virq, nr_irqs);
>
> for (i = 0; i < nr_irqs; i++) {
> irq = virq + i;
>
> ret = irq_set_chip(irq, NULL);
> if (ret)
> printk("\t\tunsetting chip for %d failed\n", irq);
> }
> }
>
> const struct irq_domain_ops paravirq_irqdomain_ops = {
> .alloc = paravirq_domain_alloc,
> .free = paravirq_domain_free,
> };
>
> static int __init paravirq_init(void)
> {
> int ret = 0;
> int i = 0;
> struct irq_alloc_info info = { 0 };
> struct irq_cfg *cfg = NULL;
>
> printk("paravirq_init\n");
>
> paravirq_domain = irq_domain_add_linear(NULL, PARAVIRT_IRQS_N,
> ¶virq_irqdomain_ops, NULL);
> if (!paravirq_domain) {
> ret = -ENOMEM;
> goto err0;
> }
>
> paravirq_domain->name = paravirq_chip.name;
> paravirq_domain->parent = x86_vector_domain;
> paravirq_domain->flags |= IRQ_DOMAIN_FLAG_AUTO_RECURSIVE;
> printk("\tparavirq_domain %s (0x%p) is created\n",
> paravirq_domain->name, paravirq_domain);
>
> printk("\tcall irq_domain_alloc_irqs with info 0x%p\n", &info);
> paravirq_irqbase = irq_domain_alloc_irqs(paravirq_domain,
> PARAVIRT_IRQS_N, NUMA_NO_NODE, &info);
> if (paravirq_irqbase < 0) {
> printk("\tallocating irqs failed: %d\n", paravirq_irqbase);
> ret = paravirq_irqbase;
> goto err1;
> }
>
> printk("\tsuccessfully allocated %d irqs beginning from %d\n",
> PARAVIRT_IRQS_N, paravirq_irqbase);
>
> for (i = 0; i < PARAVIRT_IRQS_N; i++) {
> int irq = paravirq_irqbase + i;
>
> ret = request_irq(irq, paravirq_irq_handler,
> 0, "paravirq_mod", NULL);
> if (ret) {
> printk("\trequest_irq %d failed: %d\n", irq, ret);
> goto err2;
> } else {
> printk("\tvirq %d is requested!\n", irq);
> paravirq_irqs[i] = irq;
> }
> }
>
> printk("\tSo, paravirq_mod grabbed %d irqs:\n", PARAVIRT_IRQS_N);
> for (i = 0; i < PARAVIRT_IRQS_N; i++) {
> cfg = irqd_cfg(irq_get_irq_data(paravirq_irqs[i]));
> if (!cfg) {
> printk("\t\tirq #%d: NULL irq_cfg\n", paravirq_irqs[i]);
> goto err2;
> }
>
> printk("\t\tirq #%d: virq %d, vector %d\n",
> i, paravirq_irqs[i], cfg->vector);
> }
>
> return 0;
>
> err2:
> for (i = 0; i < PARAVIRT_IRQS_N; i++) {
> if (paravirq_irqs[i] >= 0) {
> printk("\tfreeing virq %d\n", paravirq_irqs[i]);
> free_irq(paravirq_irqs[i], NULL);
> }
> }
> irq_domain_free_irqs(paravirq_irqbase, PARAVIRT_IRQS_N);
> err1:
> irq_domain_remove(paravirq_domain);
> err0:
> return ret;
> }
>
> static void __exit paravirq_exit(void)
> {
> int i;
>
> printk("paravirq_exit\n");
>
> for (i = 0; i < PARAVIRT_IRQS_N; i++) {
> if (paravirq_irqs[i] > 0) {
> printk("\tfreeing virq %d\n", paravirq_irqs[i]);
> free_irq(paravirq_irqs[i], NULL);
> }
> }
>
> if (paravirq_irqbase >= 0)
> irq_domain_free_irqs(paravirq_irqbase, PARAVIRT_IRQS_N);
>
> if (paravirq_domain)
> irq_domain_remove(paravirq_domain);
> }
>
> module_init(paravirq_init)
> module_exit(paravirq_exit)
>
> MODULE_AUTHOR("Alexander Popov <alex.po...@linux.com>");
> MODULE_DESCRIPTION("The module for handling interrupts from the hypervisor");
> MODULE_LICENSE("GPL v2");
>
