/branches/rcu/kernel/test/tasklet/tasklet1.c |
---|
30,7 → 30,7 |
#include <print.h> |
#include <test.h> |
#include <ddi/tasklet.h> |
#include <proc/tasklet.h> |
#include <synch/waitq.h> |
#include <arch/types.h> |
/branches/rcu/kernel/generic/include/synch/rcu.h |
---|
36,7 → 36,7 |
#define KERN_RCU_H_ |
#include <arch/types.h> |
#include <ddi/tasklet.h> |
#include <proc/tasklet.h> |
#include <arch/barrier.h> |
#include <preemption.h> |
/branches/rcu/kernel/generic/include/ddi/tasklet.h |
---|
File deleted |
/branches/rcu/kernel/generic/include/ddi/irq.h |
---|
122,6 → 122,14 |
*/ |
SPINLOCK_DECLARE(lock); |
/** Send EOI before processing the interrupt. |
* This is essential for timer interrupt which |
* has to be acknowledged before doing preemption |
* to make sure another timer interrupt will |
* be eventually generated. |
*/ |
bool preack; |
/** Unique device number. -1 if not yet assigned. */ |
devno_t devno; |
/branches/rcu/kernel/generic/src/synch/rcu.c |
---|
37,21 → 37,19 |
#include <arch.h> |
#include <config.h> |
#include <arch/types.h> |
#include <ddi/tasklet.h> |
#include <proc/tasklet.h> |
#include <synch/spinlock.h> |
#include <time/delay.h> |
#include <panic.h> |
#include <print.h> |
typedef struct rcu_global |
{ |
typedef struct { |
uint32_t current_batch; |
uint32_t completed_batch; |
bool next_batch_waiting; |
} rcu_global_t; |
typedef struct rcu_callback_list |
{ |
typedef struct rcu_callback_list { |
struct rcu_callback_list* next; |
void (*func)(void*); |
void* data; |
59,12 → 57,10 |
} rcu_callback_list_t; |
typedef struct rcu_percpu |
{ |
typedef struct { |
uint32_t current_batch_number; |
uint32_t QS_passed; |
bool QS_pending; |
rcu_callback_list_t* next_batch, *current_batch, *done_batch; |
} rcu_percpu_t; |
77,7 → 73,6 |
_rcu_global.completed_batch = -1; |
_rcu_global.current_batch = -1; |
_rcu_global.next_batch_waiting = -1; |
} |
void rcu_synchronize(void) |
97,7 → 92,7 |
{ |
int i; |
rcu_callback_list_t *rd; |
rd = malloc(sizeof(rcu_desc), 0); |
rd = malloc(sizeof(rcu_callback_list_t), 0); |
rd->func = func; |
rd->data = data; |
rd->next = NULL; |
110,11 → 105,9 |
_rcu_global.next_batch_waiting = true; |
rd->next = _rcu_cpu_lists[0].next_batch; |
for (i=0;i<config.cpu_count;i++) |
{ |
for (i=0;i<config.cpu_count;i++) { |
_rcu_cpu_lists[i].next_batch = rd; |
_rcu_cpu_lists[i].QS_pending = true; |
} |
//TODO:tasklet, after_thread_ran, polishing |
/branches/rcu/kernel/generic/src/main/main.c |
---|
81,7 → 81,7 |
#include <console/klog.h> |
#include <smp/smp.h> |
#include <ddi/ddi.h> |
#include <ddi/tasklet.h> |
#include <proc/tasklet.h> |
/** Global configuration structure. */ |
config_t config; |
220,7 → 220,6 |
tlb_init(); |
ddi_init(); |
tasklet_init(); |
// tasklet_do(); |
arch_post_mm_init(); |
version_print(); |
242,7 → 241,6 |
calibrate_delay_loop(); |
clock_counter_init(); |
// tasklet_do(); |
timeout_init(); |
scheduler_init(); |
task_init(); |
259,9 → 257,7 |
init.tasks[i].size); |
} else |
printf("No init binaries found\n"); |
ipc_init(); |
//tasklet_do(); |
/* |
* Create kernel task. |
278,7 → 274,8 |
panic("can't create kinit thread\n"); |
thread_ready(t); |
tasklet_run_tasklet_thread(k); |
//tasklets disabled for debugging purposes |
//tasklet_run_tasklet_thread(k); |
/* |
* This call to scheduler() will return to kinit, |
/branches/rcu/kernel/generic/src/ddi/tasklet.c |
---|
File deleted |
/branches/rcu/kernel/generic/src/ddi/irq.c |
---|
138,6 → 138,7 |
{ |
link_initialize(&irq->link); |
spinlock_initialize(&irq->lock, "irq.lock"); |
irq->preack = false; |
irq->inr = -1; |
irq->devno = -1; |
irq->trigger = (irq_trigger_t) 0; |
/branches/rcu/kernel/Makefile |
---|
155,7 → 155,6 |
generic/src/ddi/ddi.c \ |
generic/src/ddi/irq.c \ |
generic/src/ddi/device.c \ |
generic/src/ddi/tasklet.c \ |
generic/src/interrupt/interrupt.c \ |
generic/src/main/main.c \ |
generic/src/main/kinit.c \ |
164,6 → 163,7 |
generic/src/proc/scheduler.c \ |
generic/src/proc/thread.c \ |
generic/src/proc/task.c \ |
generic/src/proc/tasklet.c \ |
generic/src/proc/the.c \ |
generic/src/syscall/syscall.c \ |
generic/src/syscall/copy.c \ |
/branches/rcu/kernel/arch/ppc32/src/interrupt.c |
---|
60,11 → 60,19 |
int inum; |
while ((inum = pic_get_pending()) != -1) { |
bool ack = false; |
irq_t *irq = irq_dispatch_and_lock(inum); |
if (irq) { |
/* |
* The IRQ handler was found. |
*/ |
if (irq->preack) { |
/* Acknowledge the interrupt before processing */ |
pic_ack_interrupt(inum); |
ack = true; |
} |
irq->handler(irq, irq->arg); |
spinlock_unlock(&irq->lock); |
} else { |
75,6 → 83,8 |
printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum); |
#endif |
} |
if (!ack) |
pic_ack_interrupt(inum); |
} |
} |
/branches/rcu/kernel/arch/ia32xen/src/interrupt.c |
---|
176,6 → 176,7 |
ASSERT(n >= IVT_IRQBASE); |
int inum = n - IVT_IRQBASE; |
bool ack = false; |
ASSERT(inum < IRQ_COUNT); |
ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1)); |
184,6 → 185,12 |
/* |
* The IRQ handler was found. |
*/ |
if (irq->preack) { |
/* Send EOI before processing the interrupt */ |
trap_virtual_eoi(); |
ack = true; |
} |
irq->handler(irq, irq->arg); |
spinlock_unlock(&irq->lock); |
} else { |
194,6 → 201,8 |
printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum); |
#endif |
} |
if (!ack) |
trap_virtual_eoi(); |
} |
237,3 → 246,4 |
/** @} |
*/ |
/branches/rcu/kernel/arch/amd64/src/interrupt.c |
---|
156,6 → 156,7 |
ASSERT(n >= IVT_IRQBASE); |
int inum = n - IVT_IRQBASE; |
bool ack = false; |
ASSERT(inum < IRQ_COUNT); |
ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1)); |
164,6 → 165,12 |
/* |
* The IRQ handler was found. |
*/ |
if (irq->preack) { |
/* Send EOI before processing the interrupt */ |
trap_virtual_eoi(); |
ack = true; |
} |
irq->handler(irq, irq->arg); |
spinlock_unlock(&irq->lock); |
} else { |
174,6 → 181,8 |
printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum); |
#endif |
} |
if (!ack) |
trap_virtual_eoi(); |
} |
/branches/rcu/kernel/arch/ppc64/src/interrupt.c |
---|
60,11 → 60,19 |
int inum; |
while ((inum = pic_get_pending()) != -1) { |
bool ack = false; |
irq_t *irq = irq_dispatch_and_lock(inum); |
if (irq) { |
/* |
* The IRQ handler was found. |
*/ |
if (irq->preack) { |
/* Acknowledge the interrupt before processing */ |
pic_ack_interrupt(inum); |
ack = true; |
} |
irq->handler(irq, irq->arg); |
spinlock_unlock(&irq->lock); |
} else { |
75,6 → 83,8 |
printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum); |
#endif |
} |
if (!ack) |
pic_ack_interrupt(inum); |
} |
} |
/branches/rcu/kernel/arch/ia32/src/smp/apic.c |
---|
139,7 → 139,14 |
static void l_apic_timer_irq_handler(irq_t *irq, void *arg, ...) |
{ |
/* |
* Holding a spinlock could prevent clock() from preempting |
* the current thread. In this case, we don't need to hold the |
* irq->lock so we just unlock it and then lock it again. |
*/ |
spinlock_unlock(&irq->lock); |
clock(); |
spinlock_lock(&irq->lock); |
} |
/** Initialize APIC on BSP. */ |
162,6 → 169,7 |
io_apic_disable_irqs(0xffff); |
irq_initialize(&l_apic_timer_irq); |
l_apic_timer_irq.preack = true; |
l_apic_timer_irq.devno = device_assign_devno(); |
l_apic_timer_irq.inr = IRQ_CLK; |
l_apic_timer_irq.claim = l_apic_timer_claim; |
/branches/rcu/kernel/arch/ia32/src/interrupt.c |
---|
176,6 → 176,7 |
ASSERT(n >= IVT_IRQBASE); |
int inum = n - IVT_IRQBASE; |
bool ack = false; |
ASSERT(inum < IRQ_COUNT); |
ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1)); |
184,6 → 185,12 |
/* |
* The IRQ handler was found. |
*/ |
if (irq->preack) { |
/* Send EOI before processing the interrupt */ |
trap_virtual_eoi(); |
ack = true; |
} |
irq->handler(irq, irq->arg); |
spinlock_unlock(&irq->lock); |
} else { |
194,6 → 201,8 |
printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum); |
#endif |
} |
if (!ack) |
trap_virtual_eoi(); |
} |
/branches/rcu/kernel/arch/ia32/src/drivers/i8254.c |
---|
82,6 → 82,7 |
void i8254_init(void) |
{ |
irq_initialize(&i8254_irq); |
i8254_irq.preack = true; |
i8254_irq.devno = device_assign_devno(); |
i8254_irq.inr = IRQ_CLK; |
i8254_irq.claim = i8254_claim; |