github/acrn-hypervisor
1
0
Fork 0
mirror of https://github.com/projectacrn/acrn-hypervisor.git synced 2025-09-24 02:08:04 +00:00
Code Issues Projects Releases Wiki Activity

hv: softirq: refine softirq

Browse Source 
1. add register_softirq to register a softirq handler
2. rename exec_softirq to do_softirq; raise_softirq to fire_softirq.
3. in do_softirq call registered softirq handler not call
the device softirq handle function directly
4. enable irq after vm exit and disable irq after the first
call do_softirq before vm enter.
5. call do_softirq again when irq disabled to handle the risk
unhandled softirq.
6. rename SOFTIRQ_DEV_ASSIGN to SOFTIRQ_PTDEV
7. remove SOFTIRQ_ATOMIC

Signed-off-by: Li, Fei1 <fei1.li@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>
This commit is contained in:
Li, Fei1
2018-07-30 15:58:36 +08:00
committed by lijinxia
parent 073583cc41
commit 457ecd6ef7
8 changed files with 82 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
hypervisor/common/hv_main.c
View File

@@ -6,6 +6,7 @@
#include <hypervisor.h>
#include <schedule.h>
#include <softirq.h>
bool x2apic_enabled;
@@ -33,8 +34,11 @@ void vcpu_thread(struct vcpu *vcpu)
run_vcpu_pre_work(vcpu);
do {
/* handling pending softirq */
exec_softirq();
/* handle pending softirq when irq enable*/
do_softirq();
CPU_IRQ_DISABLE();
/* handle risk softirq when disabling irq*/
do_softirq();
/* Check and process pending requests(including interrupt) */
ret = acrn_handle_pending_request(vcpu);
@@ -85,6 +89,7 @@ void vcpu_thread(struct vcpu *vcpu)
/* Restore native TSC_AUX */
CPU_MSR_WRITE(MSR_IA32_TSC_AUX, tsc_aux_hyp_cpu);
CPU_IRQ_ENABLE();
/* Dispatch handler */
ret = vmexit_handler(vcpu);
if (ret < 0) {

8
hypervisor/common/ptdev.c
View File

@@ -8,7 +8,7 @@
#include <softirq.h>
#include <ptdev.h>
/* SOFTIRQ_DEV_ASSIGN list for all CPUs */
/* SOFTIRQ_PTDEV list for all CPUs */
struct list_head softirq_dev_entry_list;
/* passthrough device link */
struct list_head ptdev_list;
@@ -31,7 +31,7 @@ spinlock_t softirq_dev_lock;
static void ptdev_enqueue_softirq(struct ptdev_remapping_info *entry)
{
spinlock_rflags;
/* enqueue request in order, SOFTIRQ_DEV_ASSIGN will pickup */
/* enqueue request in order, SOFTIRQ_PTDEV will pickup */
spinlock_irqsave_obtain(&softirq_dev_lock);
/* avoid adding recursively */
@@ -40,7 +40,7 @@ static void ptdev_enqueue_softirq(struct ptdev_remapping_info *entry)
list_add_tail(&entry->softirq_node,
&softirq_dev_entry_list);
spinlock_irqrestore_release(&softirq_dev_lock);
raise_softirq(SOFTIRQ_DEV_ASSIGN);
fire_softirq(SOFTIRQ_PTDEV);
}
struct ptdev_remapping_info*
@@ -169,6 +169,8 @@ void ptdev_init(void)
spinlock_init(&ptdev_lock);
INIT_LIST_HEAD(&softirq_dev_entry_list);
spinlock_init(&softirq_dev_lock);
register_softirq(SOFTIRQ_PTDEV, ptdev_softirq);
}
void ptdev_release_all_entries(struct vm *vm)

103
hypervisor/common/softirq.c
View File

@@ -7,89 +7,42 @@
#include <hypervisor.h>
#include <softirq.h>
void disable_softirq(uint16_t cpu_id)
{
bitmap_clear_lock(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id));
}
void enable_softirq(uint16_t cpu_id)
{
bitmap_set_lock(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id));
}
static softirq_handler softirq_handlers[NR_SOFTIRQS];
void init_softirq(void)
{
uint16_t pcpu_id;
for (pcpu_id = 0U; pcpu_id < phys_cpu_num; pcpu_id++) {
per_cpu(softirq_pending, pcpu_id) = 0UL;
bitmap_set_lock(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, pcpu_id));
}
}
void raise_softirq(uint16_t softirq_id)
/*
* @pre: nr will not equal or large than NR_SOFTIRQS
*/
void register_softirq(uint16_t nr, softirq_handler handler)
{
uint16_t cpu_id = get_cpu_id();
uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id);
if (cpu_id >= phys_cpu_num) {
return;
}
bitmap_set_lock(softirq_id, bitmap);
softirq_handlers[nr] = handler;
}
void exec_softirq(void)
/*
* @pre: nr will not equal or large than NR_SOFTIRQS
*/
void fire_softirq(uint16_t nr)
{
uint16_t cpu_id = get_cpu_id();
volatile uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id);
uint16_t softirq_id;
if (cpu_id >= phys_cpu_num) {
return;
}
if (((*bitmap) & SOFTIRQ_MASK) == 0UL) {
return;
}
/* Disable softirq
* SOFTIRQ_ATOMIC bit = 0 means softirq already in execution
*/
if (!bitmap_test_and_clear_lock(SOFTIRQ_ATOMIC, bitmap)) {
return;
}
again:
CPU_IRQ_ENABLE();
while (1) {
softirq_id = ffs64(*bitmap);
if ((softirq_id == INVALID_BIT_INDEX) || (softirq_id >= SOFTIRQ_MAX)) {
break;
}
bitmap_clear_lock(softirq_id, bitmap);
switch (softirq_id) {
case SOFTIRQ_TIMER:
timer_softirq(cpu_id);
break;
case SOFTIRQ_DEV_ASSIGN:
ptdev_softirq(cpu_id);
break;
default:
break;
}
}
CPU_IRQ_DISABLE();
if (((*bitmap) & SOFTIRQ_MASK) != 0U) {
goto again;
}
enable_softirq(cpu_id);
bitmap_set_lock(nr, &per_cpu(softirq_pending, get_cpu_id()));
}
void do_softirq(void)
{
uint16_t nr;
uint16_t cpu_id = get_cpu_id();
volatile uint64_t *softirq_pending_bitmap =
&per_cpu(softirq_pending, cpu_id);
while (true) {
nr = ffs64(*softirq_pending_bitmap);
if (nr >= NR_SOFTIRQS)
break;
bitmap_clear_lock(nr, softirq_pending_bitmap);
(*softirq_handlers[nr])(cpu_id);
}
}