Changeset a35b458 in mainline for kernel/generic/src/synch

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

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

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

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

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

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