Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 626 → Rev 627

/kernel/trunk/test/synch/semaphore1/test.c
89,8 → 89,8
for (i=1; i<=3; i++) {
thread_t *thrd;
 
items_produced = 0;
items_consumed = 0;
atomic_set(&items_produced, 0);
atomic_set(&items_consumed, 0);
consumers = i * CONSUMERS;
producers = (4-i) * PRODUCERS;
119,8 → 119,8
thread_sleep(1);
waitq_wakeup(&can_start, WAKEUP_ALL);
while (items_consumed != consumers || items_produced != producers) {
printf("%d consumers remaining, %d producers remaining\n", consumers - items_consumed, producers - items_produced);
while (items_consumed.count != consumers || items_produced.count != producers) {
printf("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count);
thread_sleep(1);
}
}
/kernel/trunk/test/synch/rwlock5/test.c
85,8 → 85,8
for (i=1; i<=3; i++) {
thread_t *thrd;
 
items_read = 0;
items_written = 0;
atomic_set(&items_read, 0);
atomic_set(&items_written, 0);
 
readers = i*READERS;
writers = (4-i)*WRITERS;
115,8 → 115,8
thread_sleep(1);
waitq_wakeup(&can_start, WAKEUP_ALL);
while (items_read != readers || items_written != writers) {
printf("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read, writers - items_written, rwlock.readers_in);
while (items_read.count != readers || items_written.count != writers) {
printf("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in);
thread_usleep(100000);
}
}
/kernel/trunk/arch/sparc64/include/trap.h
29,6 → 29,16
#ifndef __sparc64_TRAP_H__
#define __sparc64_TRAP_H__
 
#include <arch/trap_table.h>
#include <arch/asm.h>
 
/** Switch to in-kernel trap table. */
static inline void trap_switch_trap_table(void)
{
/* Point TBA to kernel copy of OFW's trap table. */
tba_write((__u64) trap_table);
}
 
extern void trap_init(void);
 
#endif
/kernel/trunk/arch/sparc64/include/atomic.h
38,12 → 38,24
* WARNING: the following functions cause the code to be preemption-unsafe !!!
*/
 
static inline void atomic_inc(atomic_t *val) {
static inline void atomic_inc(atomic_t *val)
{
val->count++;
}
 
static inline void atomic_dec(atomic_t *val) {
static inline void atomic_dec(atomic_t *val)
{
val->count--;
}
 
static inline void atomic_set(atomic_t *val, __u64 i)
{
val->count = i;
}
 
static inline __u64 atomic_get(atomic_t *val)
{
return val->count;
}
 
#endif
/kernel/trunk/arch/sparc64/src/sparc64.c
35,6 → 35,7
void arch_pre_mm_init(void)
{
ofw_sparc64_console_init();
trap_init();
}
 
void arch_post_mm_init(void)
43,7 → 44,6
 
void arch_pre_smp_init(void)
{
trap_init();
}
 
void arch_post_smp_init(void)
/kernel/trunk/arch/sparc64/src/trap.c
31,6 → 31,7
#include <arch/asm.h>
#include <memstr.h>
 
/** Initialize trap table. */
void trap_init(void)
{
/*
37,7 → 38,4
* Copy OFW's trap table into kernel.
*/
memcpy((void *) trap_table, (void *) tba_read(), TRAP_TABLE_SIZE);
 
/* Point TBA to kernel copy of OFW's trap table. */
tba_write((__u64) trap_table);
}
/kernel/trunk/arch/sparc64/src/mm/tlb.c
35,6 → 35,7
#include <arch/types.h>
#include <typedefs.h>
#include <config.h>
#include <arch/trap.h>
 
/** Initialize ITLB and DTLB.
*
43,6 → 44,9
* kernel 4M locked entry can be installed.
* After TLB is initialized, MMU is enabled
* again.
*
* Switching MMU off imposes the requirement for
* the kernel to run in identity mapped environment.
*/
void tlb_arch_init(void)
{
81,6 → 85,13
itlb_data_in_write(data.value);
dtlb_data_in_write(data.value);
 
/*
* Register window traps can occur before MMU is enabled again.
* This ensures that any such traps will be handled from
* kernel identity mapped trap handler.
*/
trap_switch_trap_table();
tlb_invalidate_all();
 
dmmu_enable();
/kernel/trunk/arch/ia64/include/atomic.h
33,11 → 33,17
 
typedef struct { volatile __u64 count; } atomic_t;
 
static inline atomic_t atomic_add(atomic_t *val, int imm)
/** Atomic addition.
*
* @param val Atomic value.
* @param imm Value to add.
*
* @return Value after addition.
*/
static inline count_t atomic_add(atomic_t *val, int imm)
{
atomic_t v;
count_t v;
 
__asm__ volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v), "+m" (val->count) : "i" (imm));
return v;
56,12 → 62,10
static inline void atomic_inc(atomic_t *val) { atomic_add(val, 1); }
static inline void atomic_dec(atomic_t *val) { atomic_add(val, -1); }
 
static inline count_t atomic_inc_pre(atomic_t *val) { return atomic_add(val, 1); }
static inline count_t atomic_dec_pre(atomic_t *val) { return atomic_add(val, -1); }
 
static inline atomic_t atomic_inc_pre(atomic_t *val) { return atomic_add(val, 1); }
static inline atomic_t atomic_dec_pre(atomic_t *val) { return atomic_add(val, -1); }
static inline count_t atomic_inc_post(atomic_t *val) { return atomic_add(val, 1) + 1; }
static inline count_t atomic_dec_post(atomic_t *val) { return atomic_add(val, -1) - 1; }
 
 
static inline atomic_t atomic_inc_post(atomic_t *val) { return atomic_add(val, 1) + 1; }
static inline atomic_t atomic_dec_post(atomic_t *val) { return atomic_add(val, -1) - 1; }
 
#endif
/kernel/trunk/arch/mips32/include/atomic.h
50,9 → 50,9
*
* @return Value after addition.
*/
static inline atomic_t atomic_add(atomic_t *val, int i)
static inline count_t atomic_add(atomic_t *val, int i)
{
atomic_t tmp, v;
count_t tmp, v;
 
__asm__ volatile (
"1:\n"
/kernel/trunk/arch/ia32/include/atomic.h
59,27 → 59,29
#endif /* CONFIG_SMP */
}
 
static inline atomic_t atomic_inc_pre(atomic_t *val)
static inline count_t atomic_inc_pre(atomic_t *val)
{
atomic_t r;
count_t r;
 
__asm__ volatile (
"movl $1, %0\n"
"lock xaddl %0, %1\n"
: "=r"(r), "=m" (val->count)
: "=r" (r), "=m" (val->count)
);
 
return r;
}
 
 
 
static inline atomic_t atomic_dec_pre(atomic_t *val)
static inline count_t atomic_dec_pre(atomic_t *val)
{
atomic_t r;
count_t r;
__asm__ volatile (
"movl $-1, %0\n"
"lock xaddl %0, %1\n"
: "=r"(r), "=m" (*val)
: "=r" (r), "=m" (*val)
);
return r;
}