// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2023, Microsoft Corporation.
 *
 * mshv_root module's main interrupt handler and associated functionality.
 *
 * Authors: Microsoft Linux virtualization team
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/random.h>
#include <linux/cpuhotplug.h>
#include <linux/reboot.h>
#include <asm/mshyperv.h>
#include <linux/acpi.h>

#include "mshv_eventfd.h"
#include "mshv.h"

static int synic_cpuhp_online;
static struct hv_synic_pages __percpu *synic_pages;
static int mshv_sint_vector = -1; /* hwirq for the SynIC SINTs */
static int mshv_sint_irq = -1; /* Linux IRQ for mshv_sint_vector */

static u32 synic_event_ring_get_queued_port(u32 sint_index)
{
        struct hv_synic_event_ring_page **event_ring_page;
        volatile struct hv_synic_event_ring *ring;
        struct hv_synic_pages *spages;
        u8 **synic_eventring_tail;
        u32 message;
        u8 tail;

        spages = this_cpu_ptr(synic_pages);
        event_ring_page = &spages->synic_event_ring_page;
        synic_eventring_tail = (u8 **)this_cpu_ptr(hv_synic_eventring_tail);

        if (unlikely(!*synic_eventring_tail)) {
                pr_debug("Missing synic event ring tail!\n");
                return 0;
        }
        tail = (*synic_eventring_tail)[sint_index];

        if (unlikely(!*event_ring_page)) {
                pr_debug("Missing synic event ring page!\n");
                return 0;
        }

        ring = &(*event_ring_page)->sint_event_ring[sint_index];

        /*
         * Get the message.
         */
        message = ring->data[tail];

        if (!message) {
                if (ring->ring_full) {
                        /*
                         * Ring is marked full, but we would have consumed all
                         * the messages. Notify the hypervisor that ring is now
                         * empty and check again.
                         */
                        ring->ring_full = 0;
                        hv_call_notify_port_ring_empty(sint_index);
                        message = ring->data[tail];
                }

                if (!message) {
                        ring->signal_masked = 0;
                        /*
                         * Unmask the signal and sync with hypervisor
                         * before one last check for any message.
                         */
                        mb();
                        message = ring->data[tail];

                        /*
                         * Ok, lets bail out.
                         */
                        if (!message)
                                return 0;
                }

                ring->signal_masked = 1;
        }

        /*
         * Clear the message in the ring buffer.
         */
        ring->data[tail] = 0;

        if (++tail == HV_SYNIC_EVENT_RING_MESSAGE_COUNT)
                tail = 0;

        (*synic_eventring_tail)[sint_index] = tail;

        return message;
}

static bool
mshv_doorbell_isr(struct hv_message *msg)
{
        struct hv_notification_message_payload *notification;
        u32 port;

        if (msg->header.message_type != HVMSG_SYNIC_SINT_INTERCEPT)
                return false;

        notification = (struct hv_notification_message_payload *)msg->u.payload;
        if (notification->sint_index != HV_SYNIC_DOORBELL_SINT_INDEX)
                return false;

        while ((port = synic_event_ring_get_queued_port(HV_SYNIC_DOORBELL_SINT_INDEX))) {
                struct port_table_info ptinfo = { 0 };

                if (mshv_portid_lookup(port, &ptinfo)) {
                        pr_debug("Failed to get port info from port_table!\n");
                        continue;
                }

                if (ptinfo.hv_port_type != HV_PORT_TYPE_DOORBELL) {
                        pr_debug("Not a doorbell port!, port: %d, port_type: %d\n",
                                 port, ptinfo.hv_port_type);
                        continue;
                }

                /* Invoke the callback */
                ptinfo.hv_port_doorbell.doorbell_cb(port,
                                                 ptinfo.hv_port_doorbell.data);
        }

        return true;
}

static bool mshv_async_call_completion_isr(struct hv_message *msg)
{
        bool handled = false;
        struct hv_async_completion_message_payload *async_msg;
        struct mshv_partition *partition;
        u64 partition_id;

        if (msg->header.message_type != HVMSG_ASYNC_CALL_COMPLETION)
                goto out;

        async_msg =
                (struct hv_async_completion_message_payload *)msg->u.payload;

        partition_id = async_msg->partition_id;

        /*
         * Hold this lock for the rest of the isr, because the partition could
         * be released anytime.
         * e.g. the MSHV_RUN_VP thread could wake on another cpu; it could
         * release the partition unless we hold this!
         */
        rcu_read_lock();

        partition = mshv_partition_find(partition_id);

        if (unlikely(!partition)) {
                pr_debug("failed to find partition %llu\n", partition_id);
                goto unlock_out;
        }

        partition->async_hypercall_status = async_msg->status;
        complete(&partition->async_hypercall);

        handled = true;

unlock_out:
        rcu_read_unlock();
out:
        return handled;
}

static void kick_vp(struct mshv_vp *vp)
{
        atomic64_inc(&vp->run.vp_signaled_count);
        vp->run.kicked_by_hv = 1;
        wake_up(&vp->run.vp_suspend_queue);
}

static void
handle_bitset_message(const struct hv_vp_signal_bitset_scheduler_message *msg)
{
        int bank_idx, vps_signaled = 0, bank_mask_size;
        struct mshv_partition *partition;
        const struct hv_vpset *vpset;
        const u64 *bank_contents;
        u64 partition_id = msg->partition_id;

        if (msg->vp_bitset.bitset.format != HV_GENERIC_SET_SPARSE_4K) {
                pr_debug("scheduler message format is not HV_GENERIC_SET_SPARSE_4K");
                return;
        }

        if (msg->vp_count == 0) {
                pr_debug("scheduler message with no VP specified");
                return;
        }

        rcu_read_lock();

        partition = mshv_partition_find(partition_id);
        if (unlikely(!partition)) {
                pr_debug("failed to find partition %llu\n", partition_id);
                goto unlock_out;
        }

        vpset = &msg->vp_bitset.bitset;

        bank_idx = -1;
        bank_contents = vpset->bank_contents;
        bank_mask_size = sizeof(vpset->valid_bank_mask) * BITS_PER_BYTE;

        while (true) {
                int vp_bank_idx = -1;
                int vp_bank_size = sizeof(*bank_contents) * BITS_PER_BYTE;
                int vp_index;

                bank_idx = find_next_bit((unsigned long *)&vpset->valid_bank_mask,
                                         bank_mask_size, bank_idx + 1);
                if (bank_idx == bank_mask_size)
                        break;

                while (true) {
                        struct mshv_vp *vp;

                        vp_bank_idx = find_next_bit((unsigned long *)bank_contents,
                                                    vp_bank_size, vp_bank_idx + 1);
                        if (vp_bank_idx == vp_bank_size)
                                break;

                        vp_index = (bank_idx * vp_bank_size) + vp_bank_idx;

                        /* This shouldn't happen, but just in case. */
                        if (unlikely(vp_index >= MSHV_MAX_VPS)) {
                                pr_debug("VP index %u out of bounds\n",
                                         vp_index);
                                goto unlock_out;
                        }

                        vp = partition->pt_vp_array[vp_index];
                        if (unlikely(!vp)) {
                                pr_debug("failed to find VP %u\n", vp_index);
                                goto unlock_out;
                        }

                        kick_vp(vp);
                        vps_signaled++;
                }

                bank_contents++;
        }

unlock_out:
        rcu_read_unlock();

        if (vps_signaled != msg->vp_count)
                pr_debug("asked to signal %u VPs but only did %u\n",
                         msg->vp_count, vps_signaled);
}

static void
handle_pair_message(const struct hv_vp_signal_pair_scheduler_message *msg)
{
        struct mshv_partition *partition = NULL;
        struct mshv_vp *vp;
        int idx;

        rcu_read_lock();

        for (idx = 0; idx < msg->vp_count; idx++) {
                u64 partition_id = msg->partition_ids[idx];
                u32 vp_index = msg->vp_indexes[idx];

                if (idx == 0 || partition->pt_id != partition_id) {
                        partition = mshv_partition_find(partition_id);
                        if (unlikely(!partition)) {
                                pr_debug("failed to find partition %llu\n",
                                         partition_id);
                                break;
                        }
                }

                /* This shouldn't happen, but just in case. */
                if (unlikely(vp_index >= MSHV_MAX_VPS)) {
                        pr_debug("VP index %u out of bounds\n", vp_index);
                        break;
                }

                vp = partition->pt_vp_array[vp_index];
                if (!vp) {
                        pr_debug("failed to find VP %u\n", vp_index);
                        break;
                }

                kick_vp(vp);
        }

        rcu_read_unlock();
}

static bool
mshv_scheduler_isr(struct hv_message *msg)
{
        if (msg->header.message_type != HVMSG_SCHEDULER_VP_SIGNAL_BITSET &&
            msg->header.message_type != HVMSG_SCHEDULER_VP_SIGNAL_PAIR)
                return false;

        if (msg->header.message_type == HVMSG_SCHEDULER_VP_SIGNAL_BITSET)
                handle_bitset_message((struct hv_vp_signal_bitset_scheduler_message *)
                                      msg->u.payload);
        else
                handle_pair_message((struct hv_vp_signal_pair_scheduler_message *)
                                    msg->u.payload);

        return true;
}

static bool
mshv_intercept_isr(struct hv_message *msg)
{
        struct mshv_partition *partition;
        bool handled = false;
        struct mshv_vp *vp;
        u64 partition_id;
        u32 vp_index;

        partition_id = msg->header.sender;

        rcu_read_lock();

        partition = mshv_partition_find(partition_id);
        if (unlikely(!partition)) {
                pr_debug("failed to find partition %llu\n",
                         partition_id);
                goto unlock_out;
        }

        if (msg->header.message_type == HVMSG_X64_APIC_EOI) {
                /*
                 * Check if this gsi is registered in the
                 * ack_notifier list and invoke the callback
                 * if registered.
                 */

                /*
                 * If there is a notifier, the ack callback is supposed
                 * to handle the VMEXIT. So we need not pass this message
                 * to vcpu thread.
                 */
                struct hv_x64_apic_eoi_message *eoi_msg =
                        (struct hv_x64_apic_eoi_message *)&msg->u.payload[0];

                if (mshv_notify_acked_gsi(partition, eoi_msg->interrupt_vector)) {
                        handled = true;
                        goto unlock_out;
                }
        }

        /*
         * We should get an opaque intercept message here for all intercept
         * messages, since we're using the mapped VP intercept message page.
         *
         * The intercept message will have been placed in intercept message
         * page at this point.
         *
         * Make sure the message type matches our expectation.
         */
        if (msg->header.message_type != HVMSG_OPAQUE_INTERCEPT) {
                pr_debug("wrong message type %d", msg->header.message_type);
                goto unlock_out;
        }

        /*
         * Since we directly index the vp, and it has to exist for us to be here
         * (because the vp is only deleted when the partition is), no additional
         * locking is needed here
         */
        vp_index =
               ((struct hv_opaque_intercept_message *)msg->u.payload)->vp_index;
        vp = partition->pt_vp_array[vp_index];
        if (unlikely(!vp)) {
                pr_debug("failed to find VP %u\n", vp_index);
                goto unlock_out;
        }

        kick_vp(vp);

        handled = true;

unlock_out:
        rcu_read_unlock();

        return handled;
}

void mshv_isr(void)
{
        struct hv_synic_pages *spages = this_cpu_ptr(synic_pages);
        struct hv_message_page **msg_page = &spages->hyp_synic_message_page;
        struct hv_message *msg;
        bool handled;

        if (unlikely(!(*msg_page))) {
                pr_debug("Missing synic page!\n");
                return;
        }

        msg = &((*msg_page)->sint_message[HV_SYNIC_INTERCEPTION_SINT_INDEX]);

        /*
         * If the type isn't set, there isn't really a message;
         * it may be some other hyperv interrupt
         */
        if (msg->header.message_type == HVMSG_NONE)
                return;

        handled = mshv_doorbell_isr(msg);

        if (!handled)
                handled = mshv_scheduler_isr(msg);

        if (!handled)
                handled = mshv_async_call_completion_isr(msg);

        if (!handled)
                handled = mshv_intercept_isr(msg);

        if (handled) {
                /*
                 * Acknowledge message with hypervisor if another message is
                 * pending.
                 */
                msg->header.message_type = HVMSG_NONE;
                /*
                 * Ensure the write is complete so the hypervisor will deliver
                 * the next message if available.
                 */
                mb();
                if (msg->header.message_flags.msg_pending)
                        hv_set_non_nested_msr(HV_MSR_EOM, 0);

                add_interrupt_randomness(mshv_sint_vector);
        } else {
                pr_warn_once("%s: unknown message type 0x%x\n", __func__,
                             msg->header.message_type);
        }
}

static int mshv_synic_cpu_init(unsigned int cpu)
{
        union hv_synic_simp simp;
        union hv_synic_siefp siefp;
        union hv_synic_sirbp sirbp;
        union hv_synic_sint sint;
        union hv_synic_scontrol sctrl;
        struct hv_synic_pages *spages = this_cpu_ptr(synic_pages);
        struct hv_message_page **msg_page = &spages->hyp_synic_message_page;
        struct hv_synic_event_flags_page **event_flags_page =
                        &spages->synic_event_flags_page;
        struct hv_synic_event_ring_page **event_ring_page =
                        &spages->synic_event_ring_page;

        /* Setup the Synic's message page */
        simp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIMP);
        simp.simp_enabled = true;
        *msg_page = memremap(simp.base_simp_gpa << HV_HYP_PAGE_SHIFT,
                             HV_HYP_PAGE_SIZE,
                             MEMREMAP_WB);

        if (!(*msg_page))
                return -EFAULT;

        hv_set_non_nested_msr(HV_MSR_SIMP, simp.as_uint64);

        /* Setup the Synic's event flags page */
        siefp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIEFP);
        siefp.siefp_enabled = true;
        *event_flags_page = memremap(siefp.base_siefp_gpa << PAGE_SHIFT,
                                     PAGE_SIZE, MEMREMAP_WB);

        if (!(*event_flags_page))
                goto cleanup;

        hv_set_non_nested_msr(HV_MSR_SIEFP, siefp.as_uint64);

        /* Setup the Synic's event ring page */
        sirbp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIRBP);
        sirbp.sirbp_enabled = true;
        *event_ring_page = memremap(sirbp.base_sirbp_gpa << PAGE_SHIFT,
                                    PAGE_SIZE, MEMREMAP_WB);

        if (!(*event_ring_page))
                goto cleanup;

        hv_set_non_nested_msr(HV_MSR_SIRBP, sirbp.as_uint64);

        if (mshv_sint_irq != -1)
                enable_percpu_irq(mshv_sint_irq, 0);

        /* Enable intercepts */
        sint.as_uint64 = 0;
        sint.vector = mshv_sint_vector;
        sint.masked = false;
        sint.auto_eoi = hv_recommend_using_aeoi();
        hv_set_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX,
                              sint.as_uint64);

        /* Doorbell SINT */
        sint.as_uint64 = 0;
        sint.vector = mshv_sint_vector;
        sint.masked = false;
        sint.as_intercept = 1;
        sint.auto_eoi = hv_recommend_using_aeoi();
        hv_set_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_DOORBELL_SINT_INDEX,
                              sint.as_uint64);

        /* Enable global synic bit */
        sctrl.as_uint64 = hv_get_non_nested_msr(HV_MSR_SCONTROL);
        sctrl.enable = 1;
        hv_set_non_nested_msr(HV_MSR_SCONTROL, sctrl.as_uint64);

        return 0;

cleanup:
        if (*event_ring_page) {
                sirbp.sirbp_enabled = false;
                hv_set_non_nested_msr(HV_MSR_SIRBP, sirbp.as_uint64);
                memunmap(*event_ring_page);
        }
        if (*event_flags_page) {
                siefp.siefp_enabled = false;
                hv_set_non_nested_msr(HV_MSR_SIEFP, siefp.as_uint64);
                memunmap(*event_flags_page);
        }
        if (*msg_page) {
                simp.simp_enabled = false;
                hv_set_non_nested_msr(HV_MSR_SIMP, simp.as_uint64);
                memunmap(*msg_page);
        }

        return -EFAULT;
}

static int mshv_synic_cpu_exit(unsigned int cpu)
{
        union hv_synic_sint sint;
        union hv_synic_simp simp;
        union hv_synic_siefp siefp;
        union hv_synic_sirbp sirbp;
        union hv_synic_scontrol sctrl;
        struct hv_synic_pages *spages = this_cpu_ptr(synic_pages);
        struct hv_message_page **msg_page = &spages->hyp_synic_message_page;
        struct hv_synic_event_flags_page **event_flags_page =
                &spages->synic_event_flags_page;
        struct hv_synic_event_ring_page **event_ring_page =
                &spages->synic_event_ring_page;

        /* Disable the interrupt */
        sint.as_uint64 = hv_get_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX);
        sint.masked = true;
        hv_set_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX,
                              sint.as_uint64);

        /* Disable Doorbell SINT */
        sint.as_uint64 = hv_get_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_DOORBELL_SINT_INDEX);
        sint.masked = true;
        hv_set_non_nested_msr(HV_MSR_SINT0 + HV_SYNIC_DOORBELL_SINT_INDEX,
                              sint.as_uint64);

        if (mshv_sint_irq != -1)
                disable_percpu_irq(mshv_sint_irq);

        /* Disable Synic's event ring page */
        sirbp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIRBP);
        sirbp.sirbp_enabled = false;
        hv_set_non_nested_msr(HV_MSR_SIRBP, sirbp.as_uint64);
        memunmap(*event_ring_page);

        /* Disable Synic's event flags page */
        siefp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIEFP);
        siefp.siefp_enabled = false;
        hv_set_non_nested_msr(HV_MSR_SIEFP, siefp.as_uint64);
        memunmap(*event_flags_page);

        /* Disable Synic's message page */
        simp.as_uint64 = hv_get_non_nested_msr(HV_MSR_SIMP);
        simp.simp_enabled = false;
        hv_set_non_nested_msr(HV_MSR_SIMP, simp.as_uint64);
        memunmap(*msg_page);

        /* Disable global synic bit */
        sctrl.as_uint64 = hv_get_non_nested_msr(HV_MSR_SCONTROL);
        sctrl.enable = 0;
        hv_set_non_nested_msr(HV_MSR_SCONTROL, sctrl.as_uint64);

        return 0;
}

int
mshv_register_doorbell(u64 partition_id, doorbell_cb_t doorbell_cb, void *data,
                       u64 gpa, u64 val, u64 flags)
{
        struct hv_connection_info connection_info = { 0 };
        union hv_connection_id connection_id = { 0 };
        struct port_table_info *port_table_info;
        struct hv_port_info port_info = { 0 };
        union hv_port_id port_id = { 0 };
        int ret;

        port_table_info = kmalloc_obj(*port_table_info);
        if (!port_table_info)
                return -ENOMEM;

        port_table_info->hv_port_type = HV_PORT_TYPE_DOORBELL;
        port_table_info->hv_port_doorbell.doorbell_cb = doorbell_cb;
        port_table_info->hv_port_doorbell.data = data;
        ret = mshv_portid_alloc(port_table_info);
        if (ret < 0) {
                kfree(port_table_info);
                return ret;
        }

        port_id.u.id = ret;
        port_info.port_type = HV_PORT_TYPE_DOORBELL;
        port_info.doorbell_port_info.target_sint = HV_SYNIC_DOORBELL_SINT_INDEX;
        port_info.doorbell_port_info.target_vp = HV_ANY_VP;
        ret = hv_call_create_port(hv_current_partition_id, port_id, partition_id,
                                  &port_info,
                                  0, 0, NUMA_NO_NODE);

        if (ret < 0) {
                mshv_portid_free(port_id.u.id);
                return ret;
        }

        connection_id.u.id = port_id.u.id;
        connection_info.port_type = HV_PORT_TYPE_DOORBELL;
        connection_info.doorbell_connection_info.gpa = gpa;
        connection_info.doorbell_connection_info.trigger_value = val;
        connection_info.doorbell_connection_info.flags = flags;

        ret = hv_call_connect_port(hv_current_partition_id, port_id, partition_id,
                                   connection_id, &connection_info, 0, NUMA_NO_NODE);
        if (ret < 0) {
                hv_call_delete_port(hv_current_partition_id, port_id);
                mshv_portid_free(port_id.u.id);
                return ret;
        }

        // lets use the port_id as the doorbell_id
        return port_id.u.id;
}

void
mshv_unregister_doorbell(u64 partition_id, int doorbell_portid)
{
        union hv_port_id port_id = { 0 };
        union hv_connection_id connection_id = { 0 };

        connection_id.u.id = doorbell_portid;
        hv_call_disconnect_port(partition_id, connection_id);

        port_id.u.id = doorbell_portid;
        hv_call_delete_port(hv_current_partition_id, port_id);

        mshv_portid_free(doorbell_portid);
}

static int mshv_synic_reboot_notify(struct notifier_block *nb,
                              unsigned long code, void *unused)
{
        if (!hv_root_partition())
                return 0;

        cpuhp_remove_state(synic_cpuhp_online);
        return 0;
}

static struct notifier_block mshv_synic_reboot_nb = {
        .notifier_call = mshv_synic_reboot_notify,
};

#ifndef HYPERVISOR_CALLBACK_VECTOR
static DEFINE_PER_CPU(long, mshv_evt);

static irqreturn_t mshv_percpu_isr(int irq, void *dev_id)
{
        mshv_isr();
        return IRQ_HANDLED;
}

#ifdef CONFIG_ACPI
static int __init mshv_acpi_setup_sint_irq(void)
{
        return acpi_register_gsi(NULL, mshv_sint_vector, ACPI_EDGE_SENSITIVE,
                                        ACPI_ACTIVE_HIGH);
}

static void mshv_acpi_cleanup_sint_irq(void)
{
        acpi_unregister_gsi(mshv_sint_vector);
}
#else
static int __init mshv_acpi_setup_sint_irq(void)
{
        return -ENODEV;
}

static void mshv_acpi_cleanup_sint_irq(void)
{
}
#endif

static int __init mshv_sint_vector_setup(void)
{
        int ret;
        struct hv_register_assoc reg = {
                .name = HV_ARM64_REGISTER_SINT_RESERVED_INTERRUPT_ID,
        };
        union hv_input_vtl input_vtl = { 0 };

        if (acpi_disabled)
                return -ENODEV;

        ret = hv_call_get_vp_registers(HV_VP_INDEX_SELF, HV_PARTITION_ID_SELF,
                                1, input_vtl, &reg);
        if (ret || !reg.value.reg64)
                return -ENODEV;

        mshv_sint_vector = reg.value.reg64;
        ret = mshv_acpi_setup_sint_irq();
        if (ret < 0) {
                pr_err("Failed to setup IRQ for MSHV SINT vector %d: %d\n",
                        mshv_sint_vector, ret);
                goto out_fail;
        }

        mshv_sint_irq = ret;

        ret = request_percpu_irq(mshv_sint_irq, mshv_percpu_isr, "MSHV",
                &mshv_evt);
        if (ret)
                goto out_unregister;

        return 0;

out_unregister:
        mshv_acpi_cleanup_sint_irq();
out_fail:
        return ret;
}

static void mshv_sint_vector_cleanup(void)
{
        free_percpu_irq(mshv_sint_irq, &mshv_evt);
        mshv_acpi_cleanup_sint_irq();
}
#else /* !HYPERVISOR_CALLBACK_VECTOR */
static int __init mshv_sint_vector_setup(void)
{
        mshv_sint_vector = HYPERVISOR_CALLBACK_VECTOR;
        return 0;
}

static void mshv_sint_vector_cleanup(void)
{
}
#endif /* HYPERVISOR_CALLBACK_VECTOR */

int __init mshv_synic_init(struct device *dev)
{
        int ret = 0;

        ret = mshv_sint_vector_setup();
        if (ret)
                return ret;

        synic_pages = alloc_percpu(struct hv_synic_pages);
        if (!synic_pages) {
                dev_err(dev, "Failed to allocate percpu synic page\n");
                ret = -ENOMEM;
                goto sint_vector_cleanup;
        }

        ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "mshv_synic",
                                mshv_synic_cpu_init,
                                mshv_synic_cpu_exit);
        if (ret < 0) {
                dev_err(dev, "Failed to setup cpu hotplug state: %i\n", ret);
                goto free_synic_pages;
        }

        synic_cpuhp_online = ret;

        ret = register_reboot_notifier(&mshv_synic_reboot_nb);
        if (ret)
                goto remove_cpuhp_state;

        return 0;

remove_cpuhp_state:
        cpuhp_remove_state(synic_cpuhp_online);
free_synic_pages:
        free_percpu(synic_pages);
sint_vector_cleanup:
        mshv_sint_vector_cleanup();
        return ret;
}

void mshv_synic_exit(void)
{
        unregister_reboot_notifier(&mshv_synic_reboot_nb);
        cpuhp_remove_state(synic_cpuhp_online);
        free_percpu(synic_pages);
        mshv_sint_vector_cleanup();
}