Subversion Repositories HelenOS

Compare Revisions

Regard whitespace Rev 2264 → Rev 2265

/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;