Changeset 8565a42 in mainline for kernel/generic/src/synch

Timestamp:

2018-03-02T20:34:50Z (8 years ago)

Author:

GitHub <noreply@…>

Branches:

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

Children:

a1a81f69, d5e5fd1

Parents:

3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)

git-committer:

GitHub <noreply@…> (2018-03-02 20:34:50)

Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:

kernel/generic/src/synch

Files:

• condvar.c (modified) (3 diffs)
• futex.c (modified) (21 diffs)
• mutex.c (modified) (1 diff)
• rcu.c (modified) (93 diffs)
• smp_memory_barrier.c (modified) (1 diff)
• spinlock.c (modified) (11 diffs)
• waitq.c (modified) (23 diffs)
• workqueue.c (modified) (51 diffs)

kernel/generic/src/synch/condvar.c

@@ -143 +143 @@
         /* Lock only after releasing the waitq to avoid a possible deadlock. */
         spinlock_lock(lock);
-        
+
         return rc;
 }
@@ -168 +168 @@
         ipl_t ipl = irq_lock->ipl;
         bool guard = irq_lock->guard;
-        
+
         irq_lock->guard = false;
-        
+
         /*
          * waitq_prepare() restores interrupts to the current state,
@@ -182 +182 @@
          */
         rc = _condvar_wait_timeout_spinlock(cv, &irq_lock->lock, usec, flags);
-        
+
         irq_lock->guard = guard;
         irq_lock->ipl = ipl;
-        
+
         return rc;
 }

kernel/generic/src/synch/futex.c

@@ -157 +157 @@
 {
         task->futexes = malloc(sizeof(struct futex_cache), 0);
-        
+
         cht_create(&task->futexes->ht, 0, 0, 0, true, &task_futex_ht_ops);
-        
+
         list_initialize(&task->futexes->list);
         spinlock_initialize(&task->futexes->list_lock, "futex-list-lock");
@@ -183 +183 @@
         struct futex_cache *cache =
                 member_to_inst(work, struct futex_cache, destroy_work);
-        
+
         /*
          * Destroy the cache before manually freeing items of the cache in case
@@ -189 +189 @@
          */
         cht_destroy_unsafe(&cache->ht);
-        
+
         /* Manually free futex_ptr cache items. */
         list_foreach_safe(cache->list, cur_link, next_link) {
@@ -197 +197 @@
                 free(fut_ptr);
         }
-        
+
         free(cache);
 }
@@ -205 +205 @@
 {
         struct futex_cache *futexes = TASK->futexes;
-        
+
         /* All threads of this task have terminated. This is the last thread. */
         spinlock_lock(&futexes->list_lock);
-        
+
         list_foreach_safe(futexes->list, cur_link, next_link) {
                 futex_ptr_t *fut_ptr = member_to_inst(cur_link, futex_ptr_t, all_link);
@@ -222 +222 @@
                 futex_release_ref_locked(fut_ptr->futex);
         }
-        
+
         spinlock_unlock(&futexes->list_lock);
 }
@@ -252 +252 @@
         assert(spinlock_locked(&futex_ht_lock));
         assert(0 < futex->refcount);
-        
+
         --futex->refcount;
-        
+
         if (0 == futex->refcount) {
                 hash_table_remove(&futex_ht, &futex->paddr);
@@ -272 +272 @@
 {
         futex_t *futex = find_cached_futex(uaddr);
-        
+
         if (futex)
                 return futex;
@@ -303 +303 @@
                     (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
         }
-        
+
         spinlock_unlock(&futex_ht_lock);
         page_table_unlock(AS, false);
-        
+
         return success;
 }
@@ -314 +314 @@
 {
         cht_read_lock();
-        
+
         futex_t *futex;
         cht_link_t *futex_ptr_link = cht_find_lazy(&TASK->futexes->ht, &uaddr);
@@ -321 +321 @@
                 futex_ptr_t *futex_ptr
                         = member_to_inst(futex_ptr_link, futex_ptr_t, cht_link);
-                
+
                 futex = futex_ptr->futex;
         } else {
                 futex = NULL;
         }
-        
+
         cht_read_unlock();
-        
+
         return futex;
 }
@@ -340 +340 @@
 {
         futex_t *futex = malloc(sizeof(futex_t), 0);
-        
+
         /*
          * Find the futex object in the global futex table (or insert it
@@ -346 +346 @@
          */
         spinlock_lock(&futex_ht_lock);
-        
+
         ht_link_t *fut_link = hash_table_find(&futex_ht, &phys_addr);
-        
+
         if (fut_link) {
                 free(futex);
@@ -357 +357 @@
                 hash_table_insert(&futex_ht, &futex->ht_link);
         }
-        
+
         spinlock_unlock(&futex_ht_lock);
-        
+
         /*
          * Cache the link to the futex object for this task.
@@ -365 +365 @@
         futex_ptr_t *fut_ptr = malloc(sizeof(futex_ptr_t), 0);
         cht_link_t *dup_link;
-        
+
         fut_ptr->futex = futex;
         fut_ptr->uaddr = uaddr;
-        
+
         cht_read_lock();
-        
+
         /* Cache the mapping from the virtual address to the futex for this task. */
         if (cht_insert_unique(&TASK->futexes->ht, &fut_ptr->cht_link, &dup_link)) {
@@ -380 +380 @@
                 free(fut_ptr);
                 futex_release_ref_locked(futex);
-                
+
                 futex_ptr_t *dup = member_to_inst(dup_link, futex_ptr_t, cht_link);
                 futex = dup->futex;
@@ -386 +386 @@
 
         cht_read_unlock();
-        
+
         return futex;
 }
@@ -401 +401 @@
 {
         futex_t *futex = get_futex(uaddr);
-        
+
         if (!futex)
                 return (sys_errno_t) ENOENT;
@@ -428 +428 @@
 {
         futex_t *futex = get_futex(uaddr);
-        
+
         if (futex) {
                 waitq_wakeup(&futex->wq, WAKEUP_FIRST);
@@ -492 +492 @@
         const futex_ptr_t *fut_ptr1 = member_to_inst(item1, futex_ptr_t, cht_link);
         const futex_ptr_t *fut_ptr2 = member_to_inst(item2, futex_ptr_t, cht_link);
-        
+
         return fut_ptr1->uaddr == fut_ptr2->uaddr;
 }
@@ -500 +500 @@
         const futex_ptr_t *fut_ptr = member_to_inst(item, futex_ptr_t, cht_link);
         uintptr_t uaddr = *(uintptr_t*)key;
-        
+
         return fut_ptr->uaddr == uaddr;
 }

kernel/generic/src/synch/mutex.c

@@ -108 +108 @@
                 assert(usec == SYNCH_NO_TIMEOUT);
                 assert(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
-                
+
                 unsigned int cnt = 0;
                 bool deadlock_reported = false;

kernel/generic/src/synch/rcu.c

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
- 
- 
+
+
 /** @addtogroup sync
  * @{
@@ -182 +182 @@
          */
         rcu_gp_t completed_gp;
-        
+
         /** Protects the following 3 fields. */
         IRQ_SPINLOCK_DECLARE(preempt_lock);
@@ -195 +195 @@
          */
         bool preempt_blocking_det;
-        
+
 #ifdef RCU_PREEMPT_A
-        
+
         /**
          * The detector waits on this semaphore for any preempted readers
@@ -205 +205 @@
 
 #elif defined(RCU_PREEMPT_PODZIMEK)
-        
+
         /** Reclaimers notify the detector when they request more grace periods.*/
         condvar_t req_gp_changed;
@@ -228 +228 @@
         semaphore_t remaining_readers;
 #endif
-        
+
         /** Excludes simultaneous rcu_barrier() calls. */
         mutex_t barrier_mtx;
@@ -235 +235 @@
         /** rcu_barrier() waits for the completion of barrier callbacks on this wq.*/
         waitq_t barrier_wq;
-        
+
         /** Interruptible attached detector thread pointer. */
         thread_t *detector_thr;
-        
+
         /* Some statistics. */
         size_t stat_expedited_cnt;
@@ -305 +305 @@
         _rcu_cur_gp = 0;
         rcu.completed_gp = 0;
-        
+
         irq_spinlock_initialize(&rcu.preempt_lock, "rcu.preempt_lock");
         list_initialize(&rcu.cur_preempted);
         list_initialize(&rcu.next_preempted);
         rcu.preempt_blocking_det = false;
-        
+
         mutex_initialize(&rcu.barrier_mtx, MUTEX_PASSIVE);
         atomic_set(&rcu.barrier_wait_cnt, 0);
@@ -316 +316 @@
 
         semaphore_initialize(&rcu.remaining_readers, 0);
-        
+
 #ifdef RCU_PREEMPT_PODZIMEK
         condvar_initialize(&rcu.req_gp_changed);
-        
+
         rcu.req_gp_end_cnt = 0;
         rcu.req_expedited_cnt = 0;
         atomic_set(&rcu.delaying_cpu_cnt, 0);
 #endif
-        
+
         rcu.detector_thr = NULL;
-        
+
         rcu.stat_expedited_cnt = 0;
         rcu.stat_delayed_cnt = 0;
@@ -347 +347 @@
         CPU->rcu.signal_unlock = false;
 #endif
-        
+
         CPU->rcu.cur_cbs = NULL;
         CPU->rcu.cur_cbs_cnt = 0;
@@ -358 +358 @@
         CPU->rcu.cur_cbs_gp = 0;
         CPU->rcu.next_cbs_gp = 0;
-        
+
         semaphore_initialize(&CPU->rcu.arrived_flag, 0);
 
@@ -364 +364 @@
         if (config.cpu_active == 1)
                 CPU->rcu.reclaimer_thr = NULL;
-        
+
         CPU->rcu.stat_max_cbs = 0;
         CPU->rcu.stat_avg_cbs = 0;
@@ -379 +379 @@
         start_detector();
 #endif
-        
+
         start_reclaimers();
 }
@@ -391 +391 @@
         thread->rcu.was_preempted = false;
 #endif
-        
+
         link_initialize(&thread->rcu.preempt_link);
 }
@@ -406 +406 @@
         for (unsigned int cpu_id = 0; cpu_id < config.cpu_active; ++cpu_id) {
                 assert(cpus[cpu_id].rcu.reclaimer_thr != NULL);
-        
+
                 if (cpus[cpu_id].rcu.reclaimer_thr) {
                         thread_interrupt(cpus[cpu_id].rcu.reclaimer_thr);
@@ -432 +432 @@
         uint64_t completed = rcu.completed_gp;
         spinlock_unlock(&rcu.gp_lock);
-        
+
         return completed;
 }
@@ -441 +441 @@
         for (unsigned int cpu_id = 0; cpu_id < config.cpu_count; ++cpu_id) {
                 char name[THREAD_NAME_BUFLEN] = {0};
-                
+
                 snprintf(name, THREAD_NAME_BUFLEN - 1, "rcu-rec/%u", cpu_id);
-                
+
                 cpus[cpu_id].rcu.reclaimer_thr =
                         thread_create(reclaimer, NULL, TASK, THREAD_FLAG_NONE, name);
@@ -462 +462 @@
         rcu.detector_thr =
                 thread_create(detector, NULL, TASK, THREAD_FLAG_NONE, "rcu-det");
-        
+
         if (!rcu.detector_thr)
                 panic("Failed to create RCU detector thread.");
-        
+
         thread_ready(rcu.detector_thr);
 }
@@ -475 +475 @@
         bool locked = 0 < CPU->rcu.nesting_cnt;
         preemption_enable();
-        
+
         return locked;
 }
@@ -489 +489 @@
 {
         assert(PREEMPTION_DISABLED || interrupts_disabled());
-        
+
         if (0 == --(*pnesting_cnt)) {
                 _rcu_record_qs();
-                
+
                 /*
                  * The thread was preempted while in a critical section or
@@ -511 +511 @@
 {
         assert(PREEMPTION_DISABLED || interrupts_disabled());
-        
+
         /*
          * If an interrupt occurs here (even a NMI) it may beat us to
@@ -517 +517 @@
          * for us.
          */
-        
+
         /*
          * If the detector is eagerly waiting for this cpu's reader to unlock,
@@ -525 +525 @@
                 semaphore_up(&rcu.remaining_readers);
         }
-        
+
         /*
          * This reader was preempted while in a reader section.
@@ -536 +536 @@
                 rm_preempted_reader();
         }
-        
+
         /* If there was something to signal to the detector we have done so. */
         CPU->rcu.signal_unlock = false;
@@ -565 +565 @@
         /* Calling from a reader section will deadlock. */
         assert(!rcu_read_locked());
-        
+
         synch_item_t completion;
 
@@ -589 +589 @@
          */
         mutex_lock(&rcu.barrier_mtx);
-        
+
         /*
          * Ensure we queue a barrier callback on all cpus before the already
@@ -598 +598 @@
         DEFINE_CPU_MASK(cpu_mask);
         cpu_mask_active(cpu_mask);
-        
+
         cpu_mask_for_each(*cpu_mask, cpu_id) {
                 smp_call(cpu_id, add_barrier_cb, NULL);
         }
-        
+
         if (0 < atomic_predec(&rcu.barrier_wait_cnt)) {
                 waitq_sleep(&rcu.barrier_wq);
         }
-        
+
         mutex_unlock(&rcu.barrier_mtx);
 }
@@ -659 +659 @@
 {
         assert(rcu_item);
-        
+
         rcu_item->func = func;
         rcu_item->next = NULL;
-        
+
         preemption_disable();
 
@@ -670 +670 @@
                 = local_atomic_exchange(&r->parriving_cbs_tail, &rcu_item->next);
         *prev_tail = rcu_item;
-        
+
         /* Approximate the number of callbacks present. */
         ++r->arriving_cbs_cnt;
-        
+
         if (expedite) {
                 r->expedite_arriving = true;
         }
-        
+
         bool first_cb = (prev_tail == &CPU->rcu.arriving_cbs);
-        
+
         /* Added first callback - notify the reclaimer. */
         if (first_cb && !semaphore_count_get(&r->arrived_flag)) {
                 semaphore_up(&r->arrived_flag);
         }
-        
+
         preemption_enable();
 }
@@ -725 +725 @@
         rcu_gp_t last_compl_gp = 0;
         bool ok = true;
-        
+
         while (ok && wait_for_pending_cbs()) {
                 assert(CPU->rcu.reclaimer_thr == THREAD);
-                
+
                 exec_completed_cbs(last_compl_gp);
 
                 bool expedite = advance_cbs();
-                
+
                 ok = wait_for_cur_cbs_gp_end(expedite, &last_compl_gp);
         }
@@ -744 +744 @@
 
         bool ok = true;
-        
+
         while (arriving_cbs_empty() && ok) {
                 ok = semaphore_down_interruptable(&CPU->rcu.arrived_flag);
         }
-        
+
         return ok;
 }
@@ -763 +763 @@
 {
         upd_stat_missed_gp(last_completed_gp);
-        
+
         /* Both next_cbs and cur_cbs GP elapsed. */
         if (CPU->rcu.next_cbs_gp <= last_completed_gp) {
                 assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-                
+
                 size_t exec_cnt = CPU->rcu.cur_cbs_cnt + CPU->rcu.next_cbs_cnt;
-                
+
                 if (exec_cnt < CRITICAL_THRESHOLD) {
                         exec_cbs(&CPU->rcu.cur_cbs);
@@ -784 +784 @@
                         preemption_enable();
                 }
-                
+
                 CPU->rcu.cur_cbs_cnt = 0;
                 CPU->rcu.next_cbs_cnt = 0;
@@ -815 +815 @@
                 rcu_item_t *next = rcu_item->next;
                 rcu_func_t func = rcu_item->func;
-                
+
                 func(rcu_item);
-                
+
                 rcu_item = next;
         }
-        
+
         *phead = NULL;
 }
@@ -843 +843 @@
         CPU->rcu.cur_cbs_cnt = CPU->rcu.next_cbs_cnt;
         CPU->rcu.cur_cbs_gp = CPU->rcu.next_cbs_gp;
-        
+
         /* Move arriving_cbs to next_cbs. */
-        
+
         CPU->rcu.next_cbs_cnt = CPU->rcu.arriving_cbs_cnt;
         CPU->rcu.arriving_cbs_cnt = 0;
-        
+
         /*
          * Too many callbacks queued. Better speed up the detection
@@ -859 +859 @@
         /* Start moving the arriving_cbs list to next_cbs. */
         CPU->rcu.next_cbs = CPU->rcu.arriving_cbs;
-        
+
         /*
          * At least one callback arrived. The tail therefore does not point
@@ -866 +866 @@
         if (CPU->rcu.next_cbs) {
                 assert(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
-                
+
                 CPU->rcu.arriving_cbs = NULL;
                 /* Reset arriving_cbs before updating the tail pointer. */
@@ -883 +883 @@
         /* Update statistics of arrived callbacks. */
         upd_stat_cb_cnts(CPU->rcu.next_cbs_cnt);
-        
+
         /*
          * Make changes prior to queuing next_cbs visible to readers.
@@ -891 +891 @@
 
         /* At the end of next_cbs_gp, exec next_cbs. Determine what GP that is. */
-        
+
         if (!next_cbs_empty()) {
                 spinlock_lock(&rcu.gp_lock);
-        
+
                 /* Exec next_cbs at the end of the next GP. */
                 CPU->rcu.next_cbs_gp = _rcu_cur_gp + 1;
-                
+
                 /*
                  * There are no callbacks to invoke before next_cbs. Instruct
@@ -908 +908 @@
                         CPU->rcu.cur_cbs_gp = rcu.completed_gp + 1;
                 }
-                
+
                 spinlock_unlock(&rcu.gp_lock);
         } else {
                 CPU->rcu.next_cbs_gp = CPU->rcu.cur_cbs_gp;
         }
-        
+
         assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-        
+
         return expedite;
 }
@@ -936 +936 @@
         assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
         assert(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
-        
+
         while (rcu.completed_gp < CPU->rcu.cur_cbs_gp) {
                 /* GP has not yet started - start a new one. */
@@ -952 +952 @@
                 } else {
                         /* GP detection is in progress.*/
-                        
+
                         if (expedite)
                                 condvar_signal(&rcu.expedite_now);
-                        
+
                         /* Wait for the GP to complete. */
                         errno_t ret = _condvar_wait_timeout_spinlock(&rcu.gp_ended, &rcu.gp_lock,
                                 SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
-                        
+
                         if (ret == EINTR) {
                                 spinlock_unlock(&rcu.gp_lock);
@@ -966 +966 @@
                 }
         }
-        
+
         upd_missed_gp_in_wait(rcu.completed_gp);
-        
+
         *completed_gp = rcu.completed_gp;
         spinlock_unlock(&rcu.gp_lock);
-        
+
         return true;
 }
@@ -978 +978 @@
 {
         DEFINE_CPU_MASK(reader_cpus);
-        
+
         cpu_mask_active(reader_cpus);
         rm_quiescent_cpus(reader_cpus);
-        
+
         while (!cpu_mask_is_none(reader_cpus)) {
                 /* Give cpus a chance to context switch (a QS) and batch callbacks. */
                 if(!gp_sleep(&expedite))
                         return false;
-                
+
                 rm_quiescent_cpus(reader_cpus);
                 sample_cpus(reader_cpus, reader_cpus);
         }
-        
+
         /* Update statistic. */
         if (expedite) {
                 ++rcu.stat_expedited_cnt;
         }
-        
+
         /*
          * All cpus have passed through a QS and see the most recent _rcu_cur_gp.
@@ -1032 +1032 @@
         assert(interrupts_disabled());
         cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
-        
+
         bool locked = RCU_CNT_INC <= THE->rcu_nesting;
         /* smp_call machinery makes the most current _rcu_cur_gp visible. */
         bool passed_qs = (CPU->rcu.last_seen_gp == _rcu_cur_gp);
-                
+
         if (locked && !passed_qs) {
                 /*
@@ -1062 +1062 @@
          */
         size_t nesting_cnt = local_atomic_exchange(&THE->rcu_nesting, 0);
-        
+
         /*
          * Ensures NMIs see .rcu_nesting without the WAS_PREEMPTED mark and
@@ -1068 +1068 @@
          */
         compiler_barrier();
-        
+
         /* Preempted a reader critical section for the first time. */
         if (RCU_CNT_INC <= nesting_cnt && !(nesting_cnt & RCU_WAS_PREEMPTED)) {
@@ -1074 +1074 @@
                 note_preempted_reader();
         }
-        
+
         /* Save the thread's nesting count when it is not running. */
         THREAD->rcu.nesting_cnt = nesting_cnt;
@@ -1110 +1110 @@
                 THREAD->priority = -1;
         }
-        
+
         upd_max_cbs_in_slice(CPU->rcu.arriving_cbs_cnt);
 }
@@ -1118 +1118 @@
 {
         assert(!rcu_read_locked());
-        
+
         /* Load the thread's saved nesting count from before it was preempted. */
         THE->rcu_nesting = THREAD->rcu.nesting_cnt;
@@ -1131 +1131 @@
 {
         assert(THE->rcu_nesting == 0);
-        
+
         /*
          * The thread forgot to exit its reader critical section.
@@ -1159 +1159 @@
 {
         assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
-        
+
         size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
         if (prev == RCU_WAS_PREEMPTED) {
@@ -1212 +1212 @@
                 return true;
         }
-        
+
         spinlock_lock(&rcu.gp_lock);
-        
+
         if (CPU->rcu.cur_cbs_gp <= rcu.completed_gp) {
                 *completed_gp = rcu.completed_gp;
@@ -1220 +1220 @@
                 return true;
         }
-        
+
         assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
         assert(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
-        
+
         /*
          * Notify the detector of how many GP ends we intend to wait for, so
@@ -1231 +1231 @@
         size_t remaining_gp_ends = (size_t) (CPU->rcu.next_cbs_gp - _rcu_cur_gp);
         req_detection(remaining_gp_ends + (arriving_cbs_empty() ? 0 : 1));
-        
+
         /*
          * Ask the detector to speed up GP detection if there are too many
@@ -1239 +1239 @@
                 if(0 == rcu.req_expedited_cnt)
                         condvar_signal(&rcu.expedite_now);
-                
+
                 /*
                  * Expedite only cub_cbs. If there really is a surge of callbacks
@@ -1250 +1250 @@
         /* Wait for cur_cbs_gp to end. */
         bool interrupted = cv_wait_for_gp(CPU->rcu.cur_cbs_gp);
-        
+
         *completed_gp = rcu.completed_gp;
         spinlock_unlock(&rcu.gp_lock);
-        
+
         if (!interrupted)
                 upd_missed_gp_in_wait(*completed_gp);
-        
+
         return !interrupted;
 }
@@ -1264 +1264 @@
 {
         assert(spinlock_locked(&rcu.gp_lock));
-        
+
         bool interrupted = false;
-        
+
         /* Wait until wait_on_gp ends. */
         while (rcu.completed_gp < wait_on_gp && !interrupted) {
@@ -1273 +1273 @@
                 interrupted = (ret == EINTR);
         }
-        
+
         return interrupted;
 }
@@ -1296 +1296 @@
 {
         spinlock_lock(&rcu.gp_lock);
-        
+
         while (wait_for_detect_req()) {
                 /*
@@ -1303 +1303 @@
                  */
                 start_new_gp();
-                
+
                 spinlock_unlock(&rcu.gp_lock);
-                
+
                 if (!wait_for_readers())
                         goto unlocked_out;
-                
+
                 spinlock_lock(&rcu.gp_lock);
 
@@ -1314 +1314 @@
                 end_cur_gp();
         }
-        
+
         spinlock_unlock(&rcu.gp_lock);
-        
+
 unlocked_out:
         return;
@@ -1325 +1325 @@
 {
         assert(spinlock_locked(&rcu.gp_lock));
-        
+
         bool interrupted = false;
-        
+
         while (0 == rcu.req_gp_end_cnt && !interrupted) {
                 int ret = _condvar_wait_timeout_spinlock(&rcu.req_gp_changed,
                         &rcu.gp_lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
-                
+
                 interrupted = (ret == EINTR);
         }
-        
+
         return !interrupted;
 }
@@ -1342 +1342 @@
 {
         assert(spinlock_locked(&rcu.gp_lock));
-        
+
         rcu.completed_gp = _rcu_cur_gp;
         --rcu.req_gp_end_cnt;
-        
+
         condvar_broadcast(&rcu.gp_ended);
 }
@@ -1353 +1353 @@
 {
         DEFINE_CPU_MASK(reading_cpus);
-        
+
         /* All running cpus have potential readers. */
         cpu_mask_active(reading_cpus);
@@ -1363 +1363 @@
         if (!gp_sleep())
                 return false;
-        
+
         /* Non-intrusively determine which cpus have yet to pass a QS. */
         rm_quiescent_cpus(reading_cpus);
-        
+
         /* Actively interrupt cpus delaying the current GP and demand a QS. */
         interrupt_delaying_cpus(reading_cpus);
-        
+
         /* Wait for the interrupted cpus to notify us that they reached a QS. */
         if (!wait_for_delaying_cpus())
@@ -1378 +1378 @@
          * monotonically descreases.
          */
-        
+
         /* Wait for the last reader in cur_preempted to notify us it is done. */
         if (!wait_for_preempt_reader())
                 return false;
-        
+
         return true;
 }
@@ -1397 +1397 @@
                         DETECT_SLEEP_MS * 1000, SYNCH_FLAGS_INTERRUPTIBLE);
         }
-        
+
         if (0 < rcu.req_expedited_cnt) {
                 --rcu.req_expedited_cnt;
@@ -1403 +1403 @@
                 ++rcu.stat_expedited_cnt;
         }
-        
+
         spinlock_unlock(&rcu.gp_lock);
-        
+
         return (ret != EINTR);
 }
@@ -1413 +1413 @@
 {
         atomic_set(&rcu.delaying_cpu_cnt, 0);
-        
+
         sample_cpus(cpu_mask, NULL);
 }
@@ -1426 +1426 @@
         assert(interrupts_disabled());
         assert(!CPU->rcu.is_delaying_gp);
-        
+
         /* Cpu did not pass a quiescent state yet. */
         if (CPU->rcu.last_seen_gp != _rcu_cur_gp) {
@@ -1440 +1440 @@
                         ACCESS_ONCE(CPU->rcu.is_delaying_gp) = true;
                         CPU->rcu.signal_unlock = true;
-                        
+
                         atomic_inc(&rcu.delaying_cpu_cnt);
                 } else {
@@ -1466 +1466 @@
                  */
         }
-        
+
         /*
          * smp_call() makes sure any changes propagate back to the caller.
@@ -1483 +1483 @@
                         return false;
         }
-        
+
         /* Update statistic. */
         rcu.stat_delayed_cnt += delaying_cpu_cnt;
-        
+
         return true;
 }
@@ -1506 +1506 @@
          */
         compiler_barrier();
-        
+
         /* Save the thread's nesting count when it is not running. */
         THREAD->rcu.nesting_cnt = CPU->rcu.nesting_cnt;
-        
+
         /* Preempted a reader critical section for the first time. */
         if (0 < THREAD->rcu.nesting_cnt && !THREAD->rcu.was_preempted) {
@@ -1515 +1515 @@
                 note_preempted_reader();
         }
-        
+
         /*
          * The preempted reader has been noted globally. There are therefore
@@ -1528 +1528 @@
          */
         CPU->rcu.nesting_cnt = 0;
-        
+
         /*
          * This cpu is holding up the current GP. Let the detector know
@@ -1553 +1553 @@
                 THREAD->priority = -1;
         }
-        
+
         upd_max_cbs_in_slice(CPU->rcu.arriving_cbs_cnt);
 }
@@ -1562 +1562 @@
         assert(PREEMPTION_DISABLED || interrupts_disabled());
         assert(0 == CPU->rcu.nesting_cnt);
-        
+
         /* Load the thread's saved nesting count from before it was preempted. */
         CPU->rcu.nesting_cnt = THREAD->rcu.nesting_cnt;
-        
+
         /*
          * Ensures NMI see the proper nesting count before .signal_unlock.
@@ -1572 +1572 @@
          */
         compiler_barrier();
-        
+
         /*
          * In the unlikely event that a NMI occurs between the loading of the
@@ -1594 +1594 @@
         assert(THREAD->state == Exiting);
         assert(PREEMPTION_DISABLED || interrupts_disabled());
-        
+
         /*
          * The thread forgot to exit its reader critical section.
@@ -1617 +1617 @@
 {
         assert(spinlock_locked(&rcu.gp_lock));
-        
+
         irq_spinlock_lock(&rcu.preempt_lock, true);
-        
+
         /* Start a new GP. Announce to readers that a quiescent state is needed. */
         ++_rcu_cur_gp;
-        
+
         /*
          * Readers preempted before the start of this GP (next_preempted)
@@ -1632 +1632 @@
          */
         list_concat(&rcu.cur_preempted, &rcu.next_preempted);
-        
+
         irq_spinlock_unlock(&rcu.preempt_lock, true);
 }
@@ -1694 +1694 @@
          */
         memory_barrier(); /* MB C */
-        
+
         cpu_mask_for_each(*cpu_mask, cpu_id) {
                 /*
@@ -1707 +1707 @@
                  */
                 bool cpu_acked_gp = (cpus[cpu_id].rcu.last_seen_gp == _rcu_cur_gp);
-                
+
                 /*
                  * Either the cpu is idle or it is exiting away from idle mode
@@ -1714 +1714 @@
                  */
                 bool cpu_idle = cpus[cpu_id].idle;
-                
+
                 if (cpu_acked_gp || cpu_idle) {
                         cpu_mask_reset(cpu_mask, cpu_id);
@@ -1736 +1736 @@
 {
         assert(CPU->rcu.cur_cbs_gp <= completed_gp);
-        
+
         size_t delta = (size_t)(completed_gp - CPU->rcu.cur_cbs_gp);
         CPU->rcu.stat_missed_gp_in_wait += delta;
@@ -1764 +1764 @@
 {
         irq_spinlock_lock(&rcu.preempt_lock, true);
-        
+
         assert(link_used(&THREAD->rcu.preempt_link));
 
@@ -1793 +1793 @@
         bool reader_exists = !list_empty(&rcu.cur_preempted);
         rcu.preempt_blocking_det = reader_exists;
-        
+
         irq_spinlock_unlock(&rcu.preempt_lock, true);
-        
+
         if (reader_exists) {
                 /* Update statistic. */
                 ++rcu.stat_preempt_blocking_cnt;
-                
+
                 return semaphore_down_interruptable(&rcu.remaining_readers);
         }
-        
+
         return true;
 }
@@ -1809 +1809 @@
 {
         rcu_cpu_data_t *cr = &CPU->rcu;
-        
+
         if (arriving_cbs_cnt > cr->last_arriving_cnt) {
                 size_t arrived_cnt = arriving_cbs_cnt - cr->last_arriving_cnt;
                 cr->stat_max_slice_cbs = max(arrived_cnt, cr->stat_max_slice_cbs);
         }
-        
+
         cr->last_arriving_cnt = arriving_cbs_cnt;
 }
@@ -1826 +1826 @@
          * are no locks to lock in order to get up-to-date values.
          */
-        
+
 #ifdef RCU_PREEMPT_PODZIMEK
         const char *algo = "podzimek-preempt-rcu";
@@ -1832 +1832 @@
         const char *algo = "a-preempt-rcu";
 #endif
-        
+
         printf("Config: expedite_threshold=%d, critical_threshold=%d,"
                 " detect_sleep=%dms, %s\n",
@@ -1843 +1843 @@
                 "running or not)\n", rcu.stat_preempt_blocking_cnt);
         printf("Smp calls:     %zu\n", rcu.stat_smp_call_cnt);
-        
+
         printf("Max arrived callbacks per GP and CPU:\n");
         for (unsigned int i = 0; i < config.cpu_count; ++i) {
@@ -1853 +1853 @@
                 printf(" %zu", cpus[i].rcu.stat_avg_cbs);
         }
-        
+
         printf("\nMax arrived callbacks per time slice and CPU:\n");
         for (unsigned int i = 0; i < config.cpu_count; ++i) {

kernel/generic/src/synch/smp_memory_barrier.c

@@ -56 +56 @@
                 smp_call(cpu_id, issue_mem_bar, NULL);
         }
-        
+
         return 0;
 }

kernel/generic/src/synch/spinlock.c

@@ -77 +77 @@
         size_t i = 0;
         bool deadlock_reported = false;
-        
+
         preemption_disable();
         while (test_and_set(&lock->val)) {
@@ -101 +101 @@
                 if (lock->name[0] == '*')
                         continue;
-                
+
                 if (i++ > DEADLOCK_THRESHOLD) {
                         printf("cpu%u: looping on spinlock %p:%s, "
@@ -107 +107 @@
                             (void *) CALLER, symtab_fmt_name_lookup(CALLER));
                         stack_trace();
-                        
+
                         i = 0;
                         deadlock_reported = true;
                 }
         }
-        
+
         if (deadlock_reported)
                 printf("cpu%u: not deadlocked\n", CPU->id);
-        
+
         /*
          * Prevent critical section code from bleeding out this way up.
@@ -131 +131 @@
 {
         ASSERT_SPINLOCK(spinlock_locked(lock), lock);
-        
+
         /*
          * Prevent critical section code from bleeding out this way down.
          */
         CS_LEAVE_BARRIER();
-        
+
         atomic_set(&lock->val, 0);
         preemption_enable();
@@ -157 +157 @@
         preemption_disable();
         bool ret = !test_and_set(&lock->val);
-        
+
         /*
          * Prevent critical section code from bleeding out this way up.
          */
         CS_ENTER_BARRIER();
-        
+
         if (!ret)
                 preemption_enable();
-        
+
         return ret;
 }
@@ -208 +208 @@
                 ipl_t ipl = interrupts_disable();
                 spinlock_lock(&(lock->lock));
-                
+
                 lock->guard = true;
                 lock->ipl = ipl;
         } else {
                 ASSERT_IRQ_SPINLOCK(interrupts_disabled(), lock);
-                
+
                 spinlock_lock(&(lock->lock));
                 ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
@@ -231 +231 @@
 {
         ASSERT_IRQ_SPINLOCK(interrupts_disabled(), lock);
-        
+
         if (irq_res) {
                 ASSERT_IRQ_SPINLOCK(lock->guard, lock);
-                
+
                 lock->guard = false;
                 ipl_t ipl = lock->ipl;
-                
+
                 spinlock_unlock(&(lock->lock));
                 interrupts_restore(ipl);
@@ -261 +261 @@
         ASSERT_IRQ_SPINLOCK(interrupts_disabled(), lock);
         bool ret = spinlock_trylock(&(lock->lock));
-        
+
         ASSERT_IRQ_SPINLOCK((!ret) || (!lock->guard), lock);
         return ret;
@@ -280 +280 @@
 {
         ASSERT_IRQ_SPINLOCK(interrupts_disabled(), unlock);
-        
+
         /* Pass guard from unlock to lock */
         bool guard = unlock->guard;
         ipl_t ipl = unlock->ipl;
         unlock->guard = false;
-        
+
         spinlock_unlock(&(unlock->lock));
         spinlock_lock(&(lock->lock));
-        
+
         ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
-        
+
         if (guard) {
                 lock->guard = true;
@@ -311 +311 @@
 {
         ASSERT_IRQ_SPINLOCK(interrupts_disabled(), unlock);
-        
+
         spinlock_lock(&(lock->lock));
         ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
-        
+
         /* Pass guard from unlock to lock */
         if (unlock->guard) {
@@ -321 +321 @@
                 unlock->guard = false;
         }
-        
+
         spinlock_unlock(&(unlock->lock));
 }

kernel/generic/src/synch/waitq.c

@@ -94 +94 @@
         bool do_wakeup = false;
         DEADLOCK_PROBE_INIT(p_wqlock);
-        
+
         irq_spinlock_lock(&threads_lock, false);
         if (!thread_exists(thread))
                 goto out;
-        
+
 grab_locks:
         irq_spinlock_lock(&thread->lock, false);
-        
+
         waitq_t *wq;
         if ((wq = thread->sleep_queue)) {  /* Assignment */
@@ -110 +110 @@
                         goto grab_locks;
                 }
-                
+
                 list_remove(&thread->wq_link);
                 thread->saved_context = thread->sleep_timeout_context;
@@ -117 +117 @@
                 irq_spinlock_unlock(&wq->lock, false);
         }
-        
+
         thread->timeout_pending = false;
         irq_spinlock_unlock(&thread->lock, false);
-        
+
         if (do_wakeup)
                 thread_ready(thread);
-        
+
 out:
         irq_spinlock_unlock(&threads_lock, false);
@@ -144 +144 @@
         bool do_wakeup = false;
         DEADLOCK_PROBE_INIT(p_wqlock);
-        
+
         /*
          * The thread is quaranteed to exist because
          * threads_lock is held.
          */
-        
+
 grab_locks:
         irq_spinlock_lock(&thread->lock, false);
-        
+
         waitq_t *wq;
         if ((wq = thread->sleep_queue)) {  /* Assignment */
@@ -162 +162 @@
                         return;
                 }
-                
+
                 if (!irq_spinlock_trylock(&wq->lock)) {
                         /* Avoid deadlock */
@@ -169 +169 @@
                         goto grab_locks;
                 }
-                
+
                 if ((thread->timeout_pending) &&
                     (timeout_unregister(&thread->sleep_timeout)))
                         thread->timeout_pending = false;
-                
+
                 list_remove(&thread->wq_link);
                 thread->saved_context = thread->sleep_interruption_context;
@@ -180 +180 @@
                 irq_spinlock_unlock(&wq->lock, false);
         }
-        
+
         irq_spinlock_unlock(&thread->lock, false);
-        
+
         if (do_wakeup)
                 thread_ready(thread);
@@ -198 +198 @@
 {
         irq_spinlock_lock(&wq->lock, true);
-        
+
         if (!list_empty(&wq->sleepers)) {
                 thread_t *thread = list_get_instance(list_first(&wq->sleepers),
                     thread_t, wq_link);
-                
+
                 irq_spinlock_lock(&thread->lock, false);
-                
+
                 assert(thread->sleep_interruptible);
-                
+
                 if ((thread->timeout_pending) &&
                     (timeout_unregister(&thread->sleep_timeout)))
                         thread->timeout_pending = false;
-                
+
                 list_remove(&thread->wq_link);
                 thread->saved_context = thread->sleep_interruption_context;
                 thread->sleep_queue = NULL;
-                
+
                 irq_spinlock_unlock(&thread->lock, false);
                 thread_ready(thread);
         }
-        
+
         irq_spinlock_unlock(&wq->lock, true);
 }
@@ -271 +271 @@
 {
         assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
-        
+
         ipl_t ipl = waitq_sleep_prepare(wq);
         bool nblocked;
@@ -296 +296 @@
 {
         ipl_t ipl;
-        
+
 restart:
         ipl = interrupts_disable();
-        
+
         if (THREAD) {  /* Needed during system initiailzation */
                 /*
@@ -310 +310 @@
                  */
                 irq_spinlock_lock(&THREAD->lock, false);
-                
+
                 if (THREAD->timeout_pending) {
                         irq_spinlock_unlock(&THREAD->lock, false);
@@ -316 +316 @@
                         goto restart;
                 }
-                
+
                 irq_spinlock_unlock(&THREAD->lock, false);
         }
-        
+
         irq_spinlock_lock(&wq->lock, false);
         return ipl;
@@ -354 +354 @@
                 irq_spinlock_unlock(&wq->lock, false);
         }
-        
+
         interrupts_restore(ipl);
 }
@@ -387 +387 @@
                 }
         }
-        
+
         /*
          * Now we are firmly decided to go to sleep.
@@ -393 +393 @@
          */
         irq_spinlock_lock(&THREAD->lock, false);
-        
+
         if (flags & SYNCH_FLAGS_INTERRUPTIBLE) {
                 /*
@@ -403 +403 @@
                         return EINTR;
                 }
-                
+
                 /*
                  * Set context that will be restored if the sleep
@@ -417 +417 @@
         } else
                 THREAD->sleep_interruptible = false;
-        
+
         if (usec) {
                 /* We use the timeout variant. */
@@ -426 +426 @@
                         return ETIMEOUT;
                 }
-                
+
                 THREAD->timeout_pending = true;
                 timeout_register(&THREAD->sleep_timeout, (uint64_t) usec,
                     waitq_sleep_timed_out, THREAD);
         }
-        
+
         list_append(&THREAD->wq_link, &wq->sleepers);
-        
+
         /*
          * Suspend execution.
@@ -440 +440 @@
         THREAD->state = Sleeping;
         THREAD->sleep_queue = wq;
-        
+
         /* Must be before entry to scheduler, because there are multiple
          * return vectors.
          */
         *blocked = true;
-        
+
         irq_spinlock_unlock(&THREAD->lock, false);
-        
+
         /* wq->lock is released in scheduler_separated_stack() */
         scheduler();
-        
+
         return EOK;
 }
@@ -511 +511 @@
 {
         assert(interrupts_disabled());
-        
+
         irq_spinlock_lock(&wq->lock, false);
         irq_spinlock_unlock(&wq->lock, false);
@@ -536 +536 @@
         assert(interrupts_disabled());
         assert(irq_spinlock_locked(&wq->lock));
-        
+
 loop:
         if (list_empty(&wq->sleepers)) {
@@ -542 +542 @@
                 if ((count) && (mode == WAKEUP_ALL))
                         wq->missed_wakeups--;
-                
+
                 return;
         }
-        
+
         count++;
         thread_t *thread = list_get_instance(list_first(&wq->sleepers),
             thread_t, wq_link);
-        
+
         /*
          * Lock the thread prior to removing it from the wq.
@@ -569 +569 @@
         irq_spinlock_lock(&thread->lock, false);
         list_remove(&thread->wq_link);
-        
+
         if ((thread->timeout_pending) &&
             (timeout_unregister(&thread->sleep_timeout)))
                 thread->timeout_pending = false;
-        
+
         thread->sleep_queue = NULL;
         irq_spinlock_unlock(&thread->lock, false);
-        
+
         thread_ready(thread);
-        
+
         if (mode == WAKEUP_ALL)
                 goto loop;

kernel/generic/src/synch/workqueue.c

@@ -59 +59 @@
          */
         IRQ_SPINLOCK_DECLARE(lock);
-        
+
         /* Activates a worker if new work arrives or if shutting down the queue. */
         condvar_t activate_worker;
-        
+
         /* Queue of work_items ready to be dispatched. */
         list_t queue;
-        
+
         /* List of worker threads. */
         list_t workers;
-        
+
         /* Number of work items queued. */
         size_t item_cnt;
-        
+
         /* Indicates the work queue is shutting down. */
         bool stopping;
@@ -84 +84 @@
         /* Number of blocked workers sleeping in work func() (ie not idle). */
         size_t blocked_worker_cnt;
-        
+
         /* Number of pending signal_worker_op() operations. */
         size_t pending_op_cnt;
-        
+
         link_t nb_link;
-        
+
 #ifdef CONFIG_DEBUG
         /* Magic cookie for integrity checks. Immutable. Accessed without lock. */
@@ -105 +105 @@
 /** Max number of work items per active worker before a new worker is activated.*/
 static const size_t max_items_per_worker = 8;
-        
+
 /** System wide work queue. */
 static struct work_queue g_work_queue;
@@ -157 +157 @@
          */
         booting = false;
-        
+
         nonblock_init();
-        
+
         if (!add_worker(&g_work_queue))
                 panic("Could not create a single global work queue worker!\n");
-        
+
 }
 
@@ -174 +174 @@
         /* Maximum concurrency without slowing down the system. */
         max_concurrent_workers = max(2, config.cpu_count);
-        
+
         workq_preinit(&g_work_queue, "kworkq");
 }
@@ -188 +188 @@
 {
         struct work_queue *workq = malloc(sizeof(struct work_queue), 0);
-        
+
         if (workq) {
                 if (workq_init(workq, name)) {
@@ -194 +194 @@
                         return workq;
                 }
-                
+
                 free(workq);
         }
-        
+
         return NULL;
 }
@@ -205 +205 @@
 {
         assert(!workq_corrupted(workq));
-        
+
         irq_spinlock_lock(&workq->lock, true);
         bool stopped = workq->stopping;
@@ -212 +212 @@
 #endif
         irq_spinlock_unlock(&workq->lock, true);
-        
+
         if (!stopped) {
                 workq_stop(workq);
@@ -218 +218 @@
                 assert(0 == running_workers);
         }
-        
+
 #ifdef CONFIG_DEBUG
         workq->cookie = 0;
 #endif
-        
+
         free(workq);
 }
@@ -232 +232 @@
         workq->cookie = WORKQ_MAGIC;
 #endif
-        
+
         irq_spinlock_initialize(&workq->lock, name);
         condvar_initialize(&workq->activate_worker);
-        
+
         list_initialize(&workq->queue);
         list_initialize(&workq->workers);
-        
+
         workq->item_cnt = 0;
         workq->stopping = false;
         workq->name = name;
-        
+
         workq->cur_worker_cnt = 1;
         workq->idle_worker_cnt = 0;
         workq->activate_pending = 0;
         workq->blocked_worker_cnt = 0;
-        
+
         workq->pending_op_cnt = 0;
         link_initialize(&workq->nb_link);
@@ -270 +270 @@
         thread_t *thread = thread_create(worker_thread, workq, TASK,
                 THREAD_FLAG_NONE, workq->name);
-        
+
         if (!thread) {
                 irq_spinlock_lock(&workq->lock, true);
-                
+
                 /* cur_worker_cnt proactively increased in signal_worker_logic() .*/
                 assert(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
-                
+
                 irq_spinlock_unlock(&workq->lock, true);
                 return false;
         }
-        
+
         /* Respect lock ordering. */
         irq_spinlock_lock(&thread->lock, true);
@@ -290 +290 @@
         if (!workq->stopping) {
                 success = true;
-                
+
                 /* Try to distribute workers among cpus right away. */
                 unsigned int cpu_id = (workq->cur_worker_cnt) % config.cpu_active;
-                
+
                 if (!cpus[cpu_id].active)
                         cpu_id = CPU->id;
@@ -312 +312 @@
                  */
                 success = false;
-                
+
                 /* cur_worker_cnt proactively increased in signal_worker() .*/
                 assert(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
         }
-        
+
         irq_spinlock_unlock(&workq->lock, false);
         irq_spinlock_unlock(&thread->lock, true);
@@ -324 +324 @@
                 thread_interrupt(thread);
         }
-                
+
         thread_ready(thread);
-        
+
         return success;
 }
@@ -337 +337 @@
 {
         assert(!workq_corrupted(workq));
-        
+
         interrupt_workers(workq);
         wait_for_workers(workq);
@@ -350 +350 @@
         assert(!workq->stopping);
         workq->stopping = true;
-        
+
         /* Respect lock ordering - do not hold workq->lock during broadcast. */
         irq_spinlock_unlock(&workq->lock, true);
-        
+
         condvar_broadcast(&workq->activate_worker);
 }
@@ -361 +361 @@
 {
         assert(!PREEMPTION_DISABLED);
-        
+
         irq_spinlock_lock(&workq->lock, true);
-        
+
         list_foreach_safe(workq->workers, cur_worker, next_worker) {
                 thread_t *worker = list_get_instance(cur_worker, thread_t, workq_link);
@@ -370 +370 @@
                 /* Wait without the lock. */
                 irq_spinlock_unlock(&workq->lock, true);
-                
+
                 thread_join(worker);
                 thread_detach(worker);
-                
+
                 irq_spinlock_lock(&workq->lock, true);
         }
-        
+
         assert(list_empty(&workq->workers));
-        
+
         /* Wait for deferred add_worker_op(), signal_worker_op() to finish. */
         while (0 < workq->cur_worker_cnt || 0 < workq->pending_op_cnt) {
                 irq_spinlock_unlock(&workq->lock, true);
-                
+
                 scheduler();
-                
+
                 irq_spinlock_lock(&workq->lock, true);
         }
-        
+
         irq_spinlock_unlock(&workq->lock, true);
 }
@@ -422 +422 @@
  *                  until func() is entered.
  * @param func      User supplied function to invoke in a worker thread.
- 
+
  * @return false if work queue is shutting down; function is not
  *               queued for further processing.
@@ -442 +442 @@
  *                  until func() is entered.
  * @param func      User supplied function to invoke in a worker thread.
- 
+
  * @return false if work queue is shutting down; function is not
  *               queued for further processing.
@@ -467 +467 @@
  * @param func      User supplied function to invoke in a worker thread.
  * @param can_block May adding this work item block?
- 
+
  * @return false if work queue is shutting down; function is not
  *               queued for further processing.
@@ -476 +476 @@
 {
         assert(!workq_corrupted(workq));
-        
+
         bool success = true;
         signal_op_t signal_op = NULL;
-        
+
         irq_spinlock_lock(&workq->lock, true);
-        
+
         if (workq->stopping) {
                 success = false;
@@ -489 +489 @@
                 ++workq->item_cnt;
                 success = true;
-                
+
                 if (!booting) {
                         signal_op = signal_worker_logic(workq, can_block);
@@ -499 +499 @@
                 }
         }
-        
+
         irq_spinlock_unlock(&workq->lock, true);
 
@@ -505 +505 @@
                 signal_op(workq);
         }
-        
+
         return success;
 }
@@ -515 +515 @@
         work_item->cookie = WORK_ITEM_MAGIC;
 #endif
-        
+
         link_initialize(&work_item->queue_link);
         work_item->func = func;
@@ -524 +524 @@
 {
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         /* Workers blocked are sleeping in the work function (ie not idle). */
         assert(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
         /* Idle workers are waiting for more work to arrive in condvar_wait. */
         assert(workq->idle_worker_cnt <= workq->cur_worker_cnt);
-        
+
         /* Idle + blocked workers == sleeping worker threads. */
         size_t sleeping_workers = workq->blocked_worker_cnt + workq->idle_worker_cnt;
-        
+
         assert(sleeping_workers <= workq->cur_worker_cnt);
         /* Workers pending activation are idle workers not yet given a time slice. */
         assert(workq->activate_pending <= workq->idle_worker_cnt);
-        
+
         /*
          * Workers actively running the work func() this very moment and
@@ -553 +553 @@
 {
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         /*
          * Workers actively running the work func() and are neither blocked nor
@@ -578 +578 @@
 
         condvar_signal(&workq->activate_worker);
-        
+
         irq_spinlock_lock(&workq->lock, true);
         assert(0 < workq->pending_op_cnt);
@@ -597 +597 @@
         assert(!workq_corrupted(workq));
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         /* Only signal workers if really necessary. */
         signal_op_t signal_op = NULL;
@@ -630 +630 @@
                         bool need_worker = (active < max_concurrent_workers)
                                 && (workq->cur_worker_cnt < max_worker_cnt);
-                        
+
                         if (need_worker && can_block) {
                                 signal_op = add_worker_op;
@@ -641 +641 @@
                                 ++workq->cur_worker_cnt;
                         }
-                        
+
                         /*
                          * We cannot create a new worker but we need one desperately
@@ -648 +648 @@
                         if (need_worker && !can_block && 0 == active) {
                                 assert(0 == workq->idle_worker_cnt);
-                                
+
                                 irq_spinlock_lock(&nonblock_adder.lock, true);
 
@@ -667 +667 @@
                 signal_op = NULL;
         }
-        
+
         return signal_op;
 }
@@ -682 +682 @@
                 return;
         }
-        
+
         assert(arg != NULL);
-        
+
         struct work_queue *workq = arg;
         work_t *work_item;
-        
+
         while (dequeue_work(workq, &work_item)) {
                 /* Copy the func field so func() can safely free work_item. */
@@ -700 +700 @@
 {
         assert(!workq_corrupted(workq));
-        
+
         irq_spinlock_lock(&workq->lock, true);
-        
+
         /* Check if we should exit if load is low. */
         if (!workq->stopping && worker_unnecessary(workq)) {
@@ -710 +710 @@
                 list_remove(&THREAD->workq_link);
                 irq_spinlock_unlock(&workq->lock, true);
-                
+
                 thread_detach(THREAD);
                 return false;
         }
-        
+
         bool stop = false;
-        
+
         /* Wait for work to arrive. */
         while (list_empty(&workq->queue) && !workq->stopping) {
                 cv_wait(workq);
-                
+
                 if (0 < workq->activate_pending)
                         --workq->activate_pending;
@@ -729 +729 @@
                 link_t *work_link = list_first(&workq->queue);
                 *pwork_item = list_get_instance(work_link, work_t, queue_link);
-                
+
 #ifdef CONFIG_DEBUG
                 assert(!work_item_corrupted(*pwork_item));
@@ -736 +736 @@
                 list_remove(work_link);
                 --workq->item_cnt;
-                
+
                 stop = false;
         } else {
@@ -744 +744 @@
                 stop = true;
         }
-        
+
         irq_spinlock_unlock(&workq->lock, true);
-        
+
         return !stop;
 }
@@ -754 +754 @@
 {
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         /* No work is pending. We don't need too many idle threads. */
         if (list_empty(&workq->queue)) {
@@ -775 +775 @@
         ++workq->idle_worker_cnt;
         THREAD->workq_idling = true;
-        
+
         /* Ignore lock ordering just here. */
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         _condvar_wait_timeout_irq_spinlock(&workq->activate_worker,
                 &workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
@@ -784 +784 @@
         assert(!workq_corrupted(workq));
         assert(irq_spinlock_locked(&workq->lock));
-        
+
         THREAD->workq_idling = false;
         --workq->idle_worker_cnt;
@@ -803 +803 @@
                 assert(THREAD != thread);
                 assert(!workq_corrupted(thread->workq));
-                
+
                 /* Protected by thread->lock */
                 thread->workq_blocked = false;
-                
+
                 irq_spinlock_lock(&thread->workq->lock, true);
                 --thread->workq->blocked_worker_cnt;
@@ -823 +823 @@
                 assert(!THREAD->workq_blocked);
                 assert(!workq_corrupted(THREAD->workq));
-                
+
                 THREAD->workq_blocked = true;
-                
+
                 irq_spinlock_lock(&THREAD->workq->lock, false);
 
                 ++THREAD->workq->blocked_worker_cnt;
-                
+
                 bool can_block = false;
                 signal_op_t op = signal_worker_logic(THREAD->workq, can_block);
-                
+
                 irq_spinlock_unlock(&THREAD->workq->lock, false);
-                
+
                 if (op) {
                         assert(add_worker_noblock_op == op || signal_worker_op == op);
@@ -856 +856 @@
         const char *load_str = worker_surplus ? "decreasing" :
                 (0 < workq->activate_pending) ? "increasing" : "stable";
-        
+
         irq_spinlock_unlock(&workq->lock, true);
-        
+
         printf(
                 "Configuration: max_worker_cnt=%zu, min_worker_cnt=%zu,\n"
@@ -893 +893 @@
 
         irq_spinlock_lock(&info->lock, true);
-        
+
         while (list_empty(&info->work_queues) && !stop) {
                 errno_t ret = _condvar_wait_timeout_irq_spinlock(&info->req_cv,
                         &info->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
-                
+
                 stop = (ret == EINTR);
         }
-        
+
         if (!stop) {
                 *pworkq = list_get_instance(list_first(&info->work_queues),
@@ -906 +906 @@
 
                 assert(!workq_corrupted(*pworkq));
-                
+
                 list_remove(&(*pworkq)->nb_link);
         }
-        
+
         irq_spinlock_unlock(&info->lock, true);
-        
+
         return !stop;
 }
@@ -919 +919 @@
         nonblock_adder_t *info = arg;
         struct work_queue *workq;
-        
+
         while (dequeue_add_req(info, &workq)) {
                 add_worker(workq);
@@ -931 +931 @@
         condvar_initialize(&nonblock_adder.req_cv);
         list_initialize(&nonblock_adder.work_queues);
-        
+
         nonblock_adder.thread = thread_create(thr_nonblock_add_worker,
                 &nonblock_adder, TASK, THREAD_FLAG_NONE, "kworkq-nb");
-        
+
         if (nonblock_adder.thread) {
                 thread_ready(nonblock_adder.thread);