Change all references of num_cpus -> num_cores
[akaros.git] / kern / include / atomic.h
index f724af9..11a9a69 100644 (file)
@@ -40,8 +40,8 @@ extern inline bool atomic_sub_and_test(atomic_t *number, long val);
 
 /* Spin locks */
 struct spinlock {
-       volatile uint32_t RACY rlock;
-#ifdef __CONFIG_SPINLOCK_DEBUG__
+       volatile uint32_t rlock;
+#ifdef CONFIG_SPINLOCK_DEBUG
        uintptr_t call_site;
        uint32_t calling_core;
        bool irq_okay;
@@ -50,7 +50,7 @@ struct spinlock {
 typedef struct spinlock spinlock_t;
 #define SPINLOCK_INITIALIZER {0}
 
-#ifdef __CONFIG_SPINLOCK_DEBUG__
+#ifdef CONFIG_SPINLOCK_DEBUG
 #define SPINLOCK_INITIALIZER_IRQSAVE {0, .irq_okay = TRUE}
 #else
 #define SPINLOCK_INITIALIZER_IRQSAVE SPINLOCK_INITIALIZER
@@ -61,11 +61,41 @@ extern inline void __spinlock_init(spinlock_t *lock);
 extern inline bool spin_locked(spinlock_t *lock);
 extern inline void __spin_lock(spinlock_t *lock);
 extern inline void __spin_unlock(spinlock_t *lock);
-extern inline void spinlock_debug(spinlock_t *lock);
 
+/* So we can inline a __spin_lock if we want.  Even though we don't need this
+ * if we're debugging, its helpful to keep the include at the same place for
+ * all builds. */
+#include <arch/atomic.h>
+
+#ifdef CONFIG_SPINLOCK_DEBUG
 /* Arch indep, in k/s/atomic.c */
 void spin_lock(spinlock_t *lock);
+bool spin_trylock(spinlock_t *lock);
 void spin_unlock(spinlock_t *lock);
+void spinlock_debug(spinlock_t *lock);
+
+#else
+/* Just inline the arch-specific __ versions */
+static inline void spin_lock(spinlock_t *lock)
+{
+       __spin_lock(lock);
+}
+
+static inline bool spin_trylock(spinlock_t *lock)
+{
+       return __spin_trylock(lock);
+}
+
+static inline void spin_unlock(spinlock_t *lock)
+{
+       __spin_unlock(lock);
+}
+
+static inline void spinlock_debug(spinlock_t *lock)
+{
+}
+
+#endif /* CONFIG_SPINLOCK_DEBUG */
 
 /* Inlines, defined below */
 static inline void spinlock_init(spinlock_t *lock);
@@ -127,6 +157,14 @@ struct poke_tracker {
 };
 void poke(struct poke_tracker *tracker, void *arg);
 
+static inline void poke_init(struct poke_tracker *tracker, void (*func)(void*))
+{
+       tracker->need_to_run = 0;
+       tracker->run_in_progress = 0;
+       tracker->func = func;
+}
+#define POKE_INITIALIZER(f) {.func = f}
+
 /* Arch-specific implementations / declarations go here */
 #include <arch/atomic.h>
 
@@ -146,7 +184,7 @@ void poke(struct poke_tracker *tracker, void *arg);
 typedef struct checklist_mask {
        // only need an uint8_t, but we need the bits[] to be word aligned
        uint32_t size;
-       volatile uint8_t (COUNT(BYTES_FOR_BITMASK(size)) bits)[MAX_NUM_CPUS];
+       volatile uint8_t bits[MAX_NUM_CORES];
 } checklist_mask_t;
 
 // mask contains an unspecified array, so it needs to be at the bottom
@@ -156,7 +194,7 @@ struct checklist {
        // eagle-eyed readers may know why this might have been needed. 2009-09-04
        //volatile uint8_t (COUNT(BYTES_FOR_BITMASK(size)) bits)[];
 };
-typedef struct checklist RACY checklist_t;
+typedef struct checklist checklist_t;
 
 #define ZEROS_ARRAY(size) {[0 ... ((size)-1)] 0}
 
@@ -174,6 +212,7 @@ int waiton_checklist(checklist_t* list);
 int release_checklist(checklist_t* list);
 int checklist_is_locked(checklist_t* list);
 int checklist_is_clear(checklist_t* list);
+int checklist_is_full(checklist_t* list);
 void reset_checklist(checklist_t* list);
 void down_checklist(checklist_t* list);
 // TODO - do we want to adjust the size?  (YES, don't want to check it all)
@@ -195,9 +234,9 @@ struct barrier {
        volatile uint8_t ready;
 };
 
-typedef struct barrier RACY barrier_t;
+typedef struct barrier barrier_t;
 
-void init_barrier(barrier_t*COUNT(1) barrier, uint32_t count);
+void init_barrier(barrier_t *barrier, uint32_t count);
 void reset_barrier(barrier_t* barrier);
 void waiton_barrier(barrier_t* barrier);
 
@@ -207,7 +246,7 @@ void waiton_barrier(barrier_t* barrier);
 static inline void spinlock_init(spinlock_t *lock)
 {
        __spinlock_init(lock);
-#ifdef __CONFIG_SPINLOCK_DEBUG__
+#ifdef CONFIG_SPINLOCK_DEBUG
        lock->call_site = 0;
        lock->calling_core = 0;
        lock->irq_okay = FALSE;
@@ -217,7 +256,7 @@ static inline void spinlock_init(spinlock_t *lock)
 static inline void spinlock_init_irqsave(spinlock_t *lock)
 {
        __spinlock_init(lock);
-#ifdef __CONFIG_SPINLOCK_DEBUG__
+#ifdef CONFIG_SPINLOCK_DEBUG
        lock->call_site = 0;
        lock->calling_core = 0;
        lock->irq_okay = TRUE;
@@ -226,7 +265,7 @@ static inline void spinlock_init_irqsave(spinlock_t *lock)
 
 // If ints are enabled, disable them and note it in the top bit of the lock
 // There is an assumption about releasing locks in order here...
-static inline void spin_lock_irqsave(spinlock_t *SAFE lock)
+static inline void spin_lock_irqsave(spinlock_t *lock)
 {
        uint32_t irq_en;
        irq_en = irq_is_enabled();
@@ -238,7 +277,7 @@ static inline void spin_lock_irqsave(spinlock_t *SAFE lock)
 
 // if the high bit of the lock is set, then re-enable interrupts
 // (note from asw: you're lucky this works, you little-endian jerks)
-static inline void spin_unlock_irqsave(spinlock_t *SAFE lock)
+static inline void spin_unlock_irqsave(spinlock_t *lock)
 {
        if (spin_lock_irq_enabled(lock)) {
                spin_unlock(lock);
@@ -249,7 +288,7 @@ static inline void spin_unlock_irqsave(spinlock_t *SAFE lock)
 
 /* Returns whether or not unlocking this lock should enable interrupts or not.
  * Is meaningless on locks that weren't locked with irqsave. */
-static inline bool spin_lock_irq_enabled(spinlock_t *SAFE lock)
+static inline bool spin_lock_irq_enabled(spinlock_t *lock)
 {
        return lock->rlock & SPINLOCK_IRQ_EN;
 }
@@ -260,7 +299,7 @@ static inline bool spin_lock_irq_enabled(spinlock_t *SAFE lock)
  * concurrent write. */
 static inline void __seq_start_write(seq_ctr_t *seq_ctr)
 {
-#ifdef _CONFIG_SEQLOCK_DEBUG_
+#ifdef CONFIG_SEQLOCK_DEBUG
        assert(*seq_ctr % 2 == 0);
 #endif
        (*seq_ctr)++;
@@ -271,7 +310,7 @@ static inline void __seq_start_write(seq_ctr_t *seq_ctr)
 
 static inline void __seq_end_write(seq_ctr_t *seq_ctr)
 {
-#ifdef _CONFIG_SEQLOCK_DEBUG_
+#ifdef CONFIG_SEQLOCK_DEBUG
        assert(*seq_ctr % 2 == 1);
 #endif
        /* Need to prevent the compiler (and some arches) from reordering older