sync kvm patch for loongarch

[lixianglai]

Summary by Sourcery

This pull request synchronizes the KVM patch for the LoongArch architecture. It introduces support for performance monitoring units (PMU), LBT, stolen time, and IPI. It also includes changes to the MMU, timer, and other core components to improve virtualization performance and stability.

New Features:

• Adds support for performance monitoring units (PMU) to allow guest VMs to monitor their performance.
• Introduces support for LBT (likely Load-and-Branch Tracking) to improve the performance of nested virtualization.
• Implements stolen time accounting to provide more accurate timekeeping in guest VMs.
• Adds support for Inter-Processor Interrupts (IPI) to enable communication between virtual CPUs.
• Adds support for virtualized EXTIOI (External Interrupt Controller)

[sourcery-ai]

🧙 Sourcery has finished reviewing your pull request!

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!
• Generate a plan of action for an issue: Comment @sourcery-ai plan on
  an issue to generate a plan of action for it.

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[deepin-ci-robot]

[APPROVALNOTIFIER] This PR is NOT APPROVED

This pull-request has been approved by:
Once this PR has been reviewed and has the lgtm label, please assign mingcongbai for approval. For more information see the Code Review Process.

The full list of commands accepted by this bot can be found here.

Needs approval from an approver in each of these files:

• deepin/OWNERS

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

[deepin-ci-robot]

Hi @lixianglai. Thanks for your PR.

I'm waiting for a deepin-community member to verify that this patch is reasonable to test. If it is, they should reply with /ok-to-test on its own line. Until that is done, I will not automatically test new commits in this PR, but the usual testing commands by org members will still work. Regular contributors should join the org to skip this step.

Once the patch is verified, the new status will be reflected by the ok-to-test label.

I understand the commands that are listed here.

Instructions for interacting with me using PR comments are available here. If you have questions or suggestions related to my behavior, please file an issue against the kubernetes/test-infra repository.

[sourcery-ai]

Hey @lixianglai - I've reviewed your changes - here's some feedback:

Overall Comments:

• The PMU save/restore functions could be simplified by using a loop instead of unrolling the registers.
• Consider using helper functions to improve the readability of the MMIO read/write emulation code.

Here's what I looked at during the review

• 🟡 General issues: 1 issue found
• 🟢 Security: all looks good
• 🟢 Testing: all looks good
• 🟡 Complexity: 5 issues found
• 🟢 Documentation: all looks good

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[sourcery-ai]

suggestion (bug_risk): Device registration return value handling.

Since the registration of pch_pic (and the other devices) is performed sequentially, ensure that on failure, any previously registered devices are correctly cleaned up to avoid resource leaks or inconsistent state.

Suggested implementation:

	ret = kvm_loongarch_register_ipi_device();
	if (ret)
		goto fail_ipi;

	/* Register loongarch extioi interrupt controller interface. */
	ret = kvm_loongarch_register_extioi_device();
	if (ret)
		goto fail_extioi;

	/* Register loongarch pch pic interrupt controller interface. */
	ret = kvm_loongarch_register_pch_pic_device();
	if (ret)
		goto fail_pch_pic;

	return 0;

fail_pch_pic:
	/* Clean up previously registered extioi device */
	kvm_loongarch_unregister_extioi_device();
fail_extioi:
	/* Clean up previously registered ipi device */
	kvm_loongarch_unregister_ipi_device();
fail_ipi:
	return ret;
}

Ensure that the functions kvm_loongarch_unregister_ipi_device() and kvm_loongarch_unregister_extioi_device() exist and correctly reverse the initialization performed during registration.

[sourcery-ai]

issue (complexity): Consider extracting the bit-twiddling and clustering logic in pv_send_ipi_mask() into a helper function to improve readability and reduce nested conditionals within the loop.

Consider extracting the bit‐twiddling and clustering logic in
`pv_send_ipi_mask()` into a helper function to isolate the “cluster update”
logic. This would reduce the number of nested conditionals in the loop and
make the code easier to follow. For example, you can create a helper that
updates the cluster variables and the bitmap:

```c
static void update_cluster(int cpu, int *min, int *max, __uint128_t *bitmap)
{
    if (!*bitmap) {
        *min = *max = cpu;
    } else if (cpu < *min && cpu > (*max - KVM_IPI_CLUSTER_SIZE)) {
        *bitmap <<= (*min - cpu);
        *min = cpu;
    } else if (cpu > *min && cpu < (*min + KVM_IPI_CLUSTER_SIZE)) {
        *max = cpu > *max ? cpu : *max;
    } else {
        /* Cluster full; send IPI with current bitmap and start new cluster */
        kvm_hypercall3(KVM_HCALL_FUNC_IPI, (unsigned long)*bitmap,
                        (unsigned long)(*bitmap >> BITS_PER_LONG), *min);
        *min = *max = cpu;
        *bitmap = 0;
    }
    __set_bit(cpu - *min, (unsigned long *)bitmap);
}

Then in your loop in pv_send_ipi_mask(), simply call:

for_each_cpu(i, mask) {
    info = &per_cpu(irq_stat, i);
    old = atomic_fetch_or(action, &info->message);
    if (old)
        continue;
    cpu = cpu_logical_map(i);
    update_cluster(cpu, &min, &max, &bitmap);
}

This refactoring isolates the complex decision‐logic and keeps the loop more
readable while retaining all functionality.

[sourcery-ai]

issue (complexity): Consider using a simple loop or memset instead of an unrolled loop with manual assignments to improve code clarity and maintainability

Consider replacing the unrolled loop with a simple, clear loop. For example, instead of mixing pointer arithmetic like:

    p[-3] = _PAGE_GLOBAL;
    p[-2] = _PAGE_GLOBAL;
    p[-1] = _PAGE_GLOBAL;

you could write:

    for (int i = 0; i < NUM_ENTRIES; i++) {
        p[i] = _PAGE_GLOBAL;
    }

If all entries share the same value in a contiguous memory block, even a `memset()` (or a helper wrapping it) could make the intent clearer. This change preserves functionality without the non-intuitive backward indexing, improving readability and maintainability.

[sourcery-ai]

issue (complexity): Consider extracting common bit-manipulation loops and update routines into helper functions to improve readability and reduce code duplication, such as the IRQ update loop using ffs().

Consider extracting common bit-manipulation loops and update routines as helper functions to reduce nested inline functions and duplicated control flow. For instance, the loops that iterate with ffs() (or equivalent) to update IRQ state appear in multiple places. Consolidating this code into a well—named helper function will make the intent clearer and decouple the locking/update logic.

For example, you could refactor the IRQ update loop into a helper function:

static void update_pending_irq(struct loongarch_extioi *s, int base_irq, u8 bitmask, int level)
{
    int irq = ffs(bitmask);
    while (irq) {
        extioi_update_irq(s, base_irq + irq - 1, level);
        bitmask &= ~(1 << (irq - 1));
        irq = ffs(bitmask);
    }
}

Then in your write functions you would replace patterns like:

irq = ffs(coreisr);
while (irq != 0) {
    extioi_update_irq(s, irq - 1 + index * 8, 0);
    coreisr &= ~(1 << (irq - 1));
    irq = ffs(coreisr);
}

with:

update_pending_irq(s, index * 8, coreisr, 0);

Similarly, extract routines for common bit fiddling when handling enable/disable transitions. This keeps functionality intact while improving readability and reducing nesting.

[sourcery-ai]

issue (complexity): Consider simplifying the 'pch_pic_update_irq' function by using early returns and using the 'for_each_set_bit()' macro in 'pch_pic_update_batch_irqs' to reduce nested logic and repeated code.

It would help to simplify the duplicated branches by “failing‐fast” in the update function. For example, you can remove the duplicated code by using early returns rather than nested if/else. Also consider using the kernel helper macros (e.g. for_each_set_bit()) in your batch update.

Suggested refactoring for pch_pic_update_irq:

static void pch_pic_update_irq(struct loongarch_pch_pic *s, int irq, int level)
{
    u64 mask = 1ULL << irq;

    if (level) {
        if (!(mask & s->irr & ~s->mask))
            return;
        s->isr |= mask;
    } else {
        if (!(mask & s->isr & ~s->irr))
            return;
        s->isr &= ~mask;
    }

    irq = s->htmsi_vector[irq];
    extioi_set_irq(s->kvm->arch.extioi, irq, level);
}

And for pch_pic_update_batch_irqs:

static void pch_pic_update_batch_irqs(struct loongarch_pch_pic *s, u64 irq_mask, int level)
{
    unsigned int irq;
    for_each_set_bit(irq, &irq_mask, sizeof(irq_mask) * 8)
        pch_pic_update_irq(s, irq, level);
}

These changes reduce nested logic and repeated code while preserving the original behavior.

[sourcery-ai]

issue (complexity): Consider refactoring common lock-acquire/release and mailbox access patterns to reduce code duplication and improve readability by extracting helper functions and consolidating logic into a single function with a boolean write parameter, then creating simple wrapper functions for read and write operations, and applying similar factoring to other areas with repeated lock patterns or switch statements..

Consider refactoring common lock‐acquire/release and mailbox access patterns. For example, instead of duplicating similar locking and pointer arithmetic in both read_mailbox and write_mailbox, you can extract a helper:

static inline void *get_mailbox_ptr(struct kvm_vcpu *vcpu, int offset)
{
    return (void *)vcpu->arch.ipi_state.buf + (offset - 0x20);
}

Then rewrite the two functions to only differ in the read/write part:

```c
static uint64_t mailbox_access(struct kvm_vcpu *vcpu, int offset, int len,
                               bool write, uint64_t data)
{
    void *pbuf;
    uint64_t ret = 0;

    spin_lock(&vcpu->arch.ipi_state.lock);
    pbuf = get_mailbox_ptr(vcpu, offset);
    if (write) {
        if (len == 1)
            *(unsigned char *)pbuf = (unsigned char)data;
        else if (len == 2)
            *(unsigned short *)pbuf = (unsigned short)data;
        else if (len == 4)
            *(unsigned int *)pbuf = (unsigned int)data;
        else if (len == 8)
            *(unsigned long *)pbuf = (unsigned long)data;
        else
            kvm_err("%s: unknown data len: %d\n", __func__, len);
    } else {
        if (len == 1)
            ret = *(unsigned char *)pbuf;
        else if (len == 2)
            ret = *(unsigned short *)pbuf;
        else if (len == 4)
            ret = *(unsigned int *)pbuf;
        else if (len == 8)
            ret = *(unsigned long *)pbuf;
        else
            kvm_err("%s: unknown data len: %d\n", __func__, len);
    }
    spin_unlock(&vcpu->arch.ipi_state.lock);

    return ret;
}

Then redefine the read and write versions as simple wrappers:

static uint64_t read_mailbox(struct kvm_vcpu *vcpu, int offset, int len)
{
    return mailbox_access(vcpu, offset, len, false, 0);
}

static void write_mailbox(struct kvm_vcpu *vcpu, int offset,
                          uint64_t data, int len)
{
    (void)mailbox_access(vcpu, offset, len, true, data);
}

Similarly, you could factor out the repeated lock patterns in ipi_send/ipi_clear or in the switch statements (e.g. by mapping register offsets to member pointers) to reduce duplicate code paths.

These are non‐breaking changes that consolidate duplicated logic and lower cognitive complexity.

[Avenger-285714]

default时ret未赋值。

[Avenger-285714]

多余的空行？

[Avenger-285714]

default时ret未赋值。

[opsiff]

此处是否使用PCI_VENDOR_ID_LOONGSON?

[opsiff]

此处if (h->type == la_iommu_target_ivhd_type) 是否需要放在if (h->type == la_iommu_target_ivhd_type)前面?

[opsiff]

另外一个地方用的 if (h->type == la_iommu_target_ivhd_type) 能不能统一?