dpdk +vfio 中断关和开

1、request_irq会去写mxi msg

普通网卡驱动申请中断

int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
{

    err = ixgbe_alloc_q_vectors(adapter);

}
static int ixgbe_alloc_q_vectors(struct ixgbe_adapter *adapter)
{

    if (q_vectors >= (rxr_remaining + txr_remaining)) {
        for (; rxr_remaining; v_idx++) {
            err = ixgbe_alloc_q_vector(adapter, q_vectors, v_idx,
                           0, 0, 1, rxr_idx);

            if (err)
                goto err_out;

            /* update counts and index */
            rxr_remaining--;
            rxr_idx++;
        }
    }
}
static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,
                int v_count, int v_idx,
                int txr_count, int txr_idx,
                int rxr_count, int rxr_idx)
{
    /* setup affinity mask and node */
    if (cpu != -1)
        cpumask_set_cpu(cpu, &q_vector->affinity_mask);
    q_vector->numa_node = node;

#ifdef CONFIG_IXGBE_DCA
    /* initialize CPU for DCA */
    q_vector->cpu = -1;

#endif
    /* initialize NAPI */
    netif_napi_add(adapter->netdev, &q_vector->napi,
               ixgbe_poll, 64);
    napi_hash_add(&q_vector->napi);
}

static int ixgbe_open(struct net_device *netdev)
{
    /* allocate transmit descriptors */
    err = ixgbe_setup_all_tx_resources(adapter);
    if (err)
        goto err_setup_tx;

    /* allocate receive descriptors */
    err = ixgbe_setup_all_rx_resources(adapter);
    /*注册中断*/
    err = ixgbe_request_irq(adapter);
}

static int ixgbe_request_irq(struct ixgbe_adapter *adapter)
{
    struct net_device *netdev = adapter->netdev;
    int err;

    if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED)
        err = ixgbe_request_msix_irqs(adapter);
    else if (adapter->flags & IXGBE_FLAG_MSI_ENABLED)
        err = request_irq(adapter->pdev->irq, ixgbe_intr, 0,
                  netdev->name, adapter);
    else
        err = request_irq(adapter->pdev->irq, ixgbe_intr, IRQF_SHARED,
                  netdev->name, adapter);

    if (err)
        e_err(probe, "request_irq failed, Error %d\n", err);

    return err;
}

static int ixgbe_request_msix_irqs(struct ixgbe_adapter *adapter)
{
    for (vector = 0; vector < adapter->num_q_vectors; vector++) {
        struct ixgbe_q_vector *q_vector = adapter->q_vector[vector];
        struct msix_entry *entry = &adapter->msix_entries[vector];

        err = request_irq(entry->vector, &ixgbe_msix_clean_rings, 0,
                  q_vector->name, q_vector);
    }
}

开中断

int igb_up(struct igb_adapter *adapter)
{
    struct e1000_hw *hw = &adapter->hw;
    int i;

    /* hardware has been reset, we need to reload some things */
    igb_configure(adapter);

    clear_bit(__IGB_DOWN, &adapter->state);

    for (i = 0; i < adapter->num_q_vectors; i++)
        napi_enable(&(adapter->q_vector[i]->napi));

    if (adapter->msix_entries)
        igb_configure_msix(adapter);
    else
        igb_assign_vector(adapter->q_vector[0], 0);

    /* Clear any pending interrupts. */
    rd32(E1000_ICR);
    igb_irq_enable(adapter);

    /* notify VFs that reset has been completed */
    if (adapter->vfs_allocated_count) {
        u32 reg_data = rd32(E1000_CTRL_EXT);
        reg_data |= E1000_CTRL_EXT_PFRSTD;
        wr32(E1000_CTRL_EXT, reg_data);
    }

    netif_tx_start_all_queues(adapter->netdev);

    /* start the watchdog. */
    hw->mac.get_link_status = 1;
    schedule_work(&adapter->watchdog_task);

    return 0;
}

**/
static void igb_irq_enable(struct igb_adapter *adapter)
{
    struct e1000_hw *hw = &adapter->hw;

    if (adapter->msix_entries) {
        u32 ims = E1000_IMS_LSC | E1000_IMS_DOUTSYNC | E1000_IMS_DRSTA;
        u32 regval = rd32(E1000_EIAC);
        wr32(E1000_EIAC, regval | adapter->eims_enable_mask);
        regval = rd32(E1000_EIAM);
        wr32(E1000_EIAM, regval | adapter->eims_enable_mask);
        wr32(E1000_EIMS, adapter->eims_ena