Changeset da1bafb in mainline for kernel/generic/src/time/clock.c

Timestamp:

2010-05-24T18:57:31Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0095368

Parents:

666f492

Message:

major code revision

• replace spinlocks taken with interrupts disabled with irq_spinlocks
• change spacing (not indendation) to be tab-size independent
• use unsigned integer types where appropriate (especially bit flags)
• visual separation
• remove argument names in function prototypes
• string changes
• correct some formating directives
• replace various cryptic single-character variables (t, a, m, c, b, etc.) with proper identifiers (thread, task, timeout, as, itm, itc, etc.)
• unify some assembler constructs
• unused page table levels are now optimized out in compile time
• replace several ints (with boolean semantics) with bools
• use specifically sized types instead of generic types where appropriate (size_t, uint32_t, btree_key_t)
• improve comments
• split asserts with conjuction into multiple independent asserts

File:

• kernel/generic/src/time/clock.c (modified) (8 diffs)

kernel/generic/src/time/clock.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       High-level clock interrupt handler.
+ * @brief High-level clock interrupt handler.
  *
  * This file contains the clock() function which is the source
  * of preemption. It is also responsible for executing expired
  * timeouts.
- */
- 
+ *
+ */
+
 #include <time/clock.h>
 #include <time/timeout.h>
@@ -63 +64 @@
 static parea_t clock_parea;
 
-/* Variable holding fragment of second, so that we would update
- * seconds correctly
+/** Fragment of second
+ *
+ * For updating  seconds correctly.
+ *
  */
 static unative_t secfrag = 0;
@@ -73 +76 @@
  * information about realtime data. We allocate 1 page with these 
  * data and update it periodically.
+ *
  */
 void clock_counter_init(void)
 {
-        void *faddr;
-
-        faddr = frame_alloc(ONE_FRAME, FRAME_ATOMIC);
+        void *faddr = frame_alloc(ONE_FRAME, FRAME_ATOMIC);
         if (!faddr)
                 panic("Cannot allocate page for clock.");
@@ -87 +89 @@
         uptime->seconds2 = 0;
         uptime->useconds = 0;
-
+        
         clock_parea.pbase = (uintptr_t) faddr;
         clock_parea.frames = 1;
         ddi_parea_register(&clock_parea);
-
+        
         /*
          * Prepare information for the userspace so that it can successfully
          * physmem_map() the clock_parea.
+         *
          */
         sysinfo_set_item_val("clock.cacheable", NULL, (unative_t) true);
@@ -100 +103 @@
 }
 
-
 /** Update public counters
  *
  * Update it only on first processor
- * TODO: Do we really need so many write barriers? 
+ * TODO: Do we really need so many write barriers?
+ *
  */
 static void clock_update_counters(void)
@@ -131 +134 @@
 void clock(void)
 {
-        link_t *l;
-        timeout_t *h;
-        timeout_handler_t f;
-        void *arg;
         size_t missed_clock_ticks = CPU->missed_clock_ticks;
-        unsigned int i;
-
+        
         /* Account lost ticks to CPU usage */
-        if (CPU->idle) {
+        if (CPU->idle)
                 CPU->idle_ticks += missed_clock_ticks + 1;
-        } else {
+        else
                 CPU->busy_ticks += missed_clock_ticks + 1;
-        }
+        
         CPU->idle = false;
-
+        
         /*
          * To avoid lock ordering problems,
          * run all expired timeouts as you visit them.
+         *
          */
+        size_t i;
         for (i = 0; i <= missed_clock_ticks; i++) {
                 clock_update_counters();
-                spinlock_lock(&CPU->timeoutlock);
-                while ((l = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
-                        h = list_get_instance(l, timeout_t, link);
-                        spinlock_lock(&h->lock);
-                        if (h->ticks-- != 0) {
-                                spinlock_unlock(&h->lock);
+                irq_spinlock_lock(&CPU->timeoutlock, false);
+                
+                link_t *cur;
+                while ((cur = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
+                        timeout_t *timeout = list_get_instance(cur, timeout_t, link);
+                        
+                        irq_spinlock_lock(&timeout->lock, false);
+                        if (timeout->ticks-- != 0) {
+                                irq_spinlock_unlock(&timeout->lock, false);
                                 break;
                         }
-                        list_remove(l);
-                        f = h->handler;
-                        arg = h->arg;
-                        timeout_reinitialize(h);
-                        spinlock_unlock(&h->lock);      
-                        spinlock_unlock(&CPU->timeoutlock);
-
-                        f(arg);
-
-                        spinlock_lock(&CPU->timeoutlock);
+                        
+                        list_remove(cur);
+                        timeout_handler_t handler = timeout->handler;
+                        void *arg = timeout->arg;
+                        timeout_reinitialize(timeout);
+                        
+                        irq_spinlock_unlock(&timeout->lock, false);
+                        irq_spinlock_unlock(&CPU->timeoutlock, false);
+                        
+                        handler(arg);
+                        
+                        irq_spinlock_lock(&CPU->timeoutlock, false);
                 }
-                spinlock_unlock(&CPU->timeoutlock);
+                
+                irq_spinlock_unlock(&CPU->timeoutlock, false);
         }
         CPU->missed_clock_ticks = 0;
-
+        
         /*
          * Do CPU usage accounting and find out whether to preempt THREAD.
+         *
          */
-
+        
         if (THREAD) {
                 uint64_t ticks;
                 
-                spinlock_lock(&CPU->lock);
+                irq_spinlock_lock(&CPU->lock, false);
                 CPU->needs_relink += 1 + missed_clock_ticks;
-                spinlock_unlock(&CPU->lock);    
-        
-                spinlock_lock(&THREAD->lock);
+                irq_spinlock_unlock(&CPU->lock, false);
+                
+                irq_spinlock_lock(&THREAD->lock, false);
                 if ((ticks = THREAD->ticks)) {
                         if (ticks >= 1 + missed_clock_ticks)
@@ -193 +200 @@
                                 THREAD->ticks = 0;
                 }
-                spinlock_unlock(&THREAD->lock);
+                irq_spinlock_unlock(&THREAD->lock, false);
                 
                 if ((!ticks) && (!PREEMPTION_DISABLED)) {
-#ifdef CONFIG_UDEBUG
-                        istate_t *istate;
-#endif
                         scheduler();
 #ifdef CONFIG_UDEBUG
@@ -205 +209 @@
                          * before it begins executing userspace code.
                          */
-                        istate = THREAD->udebug.uspace_state;
-                        if (istate && istate_from_uspace(istate))
+                        istate_t *istate = THREAD->udebug.uspace_state;
+                        if ((istate) && (istate_from_uspace(istate)))
                                 udebug_before_thread_runs();
 #endif
                 }
         }
-
 }