Changeset a35b458 in mainline for kernel/generic/src/synch/waitq.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (6 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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/synch/waitq.c

    r3061bc1 ra35b458  
    9494        bool do_wakeup = false;
    9595        DEADLOCK_PROBE_INIT(p_wqlock);
    96        
     96
    9797        irq_spinlock_lock(&threads_lock, false);
    9898        if (!thread_exists(thread))
    9999                goto out;
    100        
     100
    101101grab_locks:
    102102        irq_spinlock_lock(&thread->lock, false);
    103        
     103
    104104        waitq_t *wq;
    105105        if ((wq = thread->sleep_queue)) {  /* Assignment */
    … …  
    110110                        goto grab_locks;
    111111                }
    112                
     112
    113113                list_remove(&thread->wq_link);
    114114                thread->saved_context = thread->sleep_timeout_context;
    … …  
    117117                irq_spinlock_unlock(&wq->lock, false);
    118118        }
    119        
     119
    120120        thread->timeout_pending = false;
    121121        irq_spinlock_unlock(&thread->lock, false);
    122        
     122
    123123        if (do_wakeup)
    124124                thread_ready(thread);
    125        
     125
    126126out:
    127127        irq_spinlock_unlock(&threads_lock, false);
    … …  
    144144        bool do_wakeup = false;
    145145        DEADLOCK_PROBE_INIT(p_wqlock);
    146        
     146
    147147        /*
    148148         * The thread is quaranteed to exist because
    149149         * threads_lock is held.
    150150         */
    151        
     151
    152152grab_locks:
    153153        irq_spinlock_lock(&thread->lock, false);
    154        
     154
    155155        waitq_t *wq;
    156156        if ((wq = thread->sleep_queue)) {  /* Assignment */
    … …  
    162162                        return;
    163163                }
    164                
     164
    165165                if (!irq_spinlock_trylock(&wq->lock)) {
    166166                        /* Avoid deadlock */
    … …  
    169169                        goto grab_locks;
    170170                }
    171                
     171
    172172                if ((thread->timeout_pending) &&
    173173                    (timeout_unregister(&thread->sleep_timeout)))
    174174                        thread->timeout_pending = false;
    175                
     175
    176176                list_remove(&thread->wq_link);
    177177                thread->saved_context = thread->sleep_interruption_context;
    … …  
    180180                irq_spinlock_unlock(&wq->lock, false);
    181181        }
    182        
     182
    183183        irq_spinlock_unlock(&thread->lock, false);
    184        
     184
    185185        if (do_wakeup)
    186186                thread_ready(thread);
    … …  
    198198{
    199199        irq_spinlock_lock(&wq->lock, true);
    200        
     200
    201201        if (!list_empty(&wq->sleepers)) {
    202202                thread_t *thread = list_get_instance(list_first(&wq->sleepers),
    203203                    thread_t, wq_link);
    204                
     204
    205205                irq_spinlock_lock(&thread->lock, false);
    206                
     206
    207207                assert(thread->sleep_interruptible);
    208                
     208
    209209                if ((thread->timeout_pending) &&
    210210                    (timeout_unregister(&thread->sleep_timeout)))
    211211                        thread->timeout_pending = false;
    212                
     212
    213213                list_remove(&thread->wq_link);
    214214                thread->saved_context = thread->sleep_interruption_context;
    215215                thread->sleep_queue = NULL;
    216                
     216
    217217                irq_spinlock_unlock(&thread->lock, false);
    218218                thread_ready(thread);
    219219        }
    220        
     220
    221221        irq_spinlock_unlock(&wq->lock, true);
    222222}
    … …  
    271271{
    272272        assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
    273        
     273
    274274        ipl_t ipl = waitq_sleep_prepare(wq);
    275275        bool nblocked;
    … …  
    296296{
    297297        ipl_t ipl;
    298        
     298
    299299restart:
    300300        ipl = interrupts_disable();
    301        
     301
    302302        if (THREAD) {  /* Needed during system initiailzation */
    303303                /*
    … …  
    310310                 */
    311311                irq_spinlock_lock(&THREAD->lock, false);
    312                
     312
    313313                if (THREAD->timeout_pending) {
    314314                        irq_spinlock_unlock(&THREAD->lock, false);
    … …  
    316316                        goto restart;
    317317                }
    318                
     318
    319319                irq_spinlock_unlock(&THREAD->lock, false);
    320320        }
    321        
     321
    322322        irq_spinlock_lock(&wq->lock, false);
    323323        return ipl;
    … …  
    354354                irq_spinlock_unlock(&wq->lock, false);
    355355        }
    356        
     356
    357357        interrupts_restore(ipl);
    358358}
    … …  
    387387                }
    388388        }
    389        
     389
    390390        /*
    391391         * Now we are firmly decided to go to sleep.
    … …  
    393393         */
    394394        irq_spinlock_lock(&THREAD->lock, false);
    395        
     395
    396396        if (flags & SYNCH_FLAGS_INTERRUPTIBLE) {
    397397                /*
    … …  
    403403                        return EINTR;
    404404                }
    405                
     405
    406406                /*
    407407                 * Set context that will be restored if the sleep
    … …  
    417417        } else
    418418                THREAD->sleep_interruptible = false;
    419        
     419
    420420        if (usec) {
    421421                /* We use the timeout variant. */
    … …  
    426426                        return ETIMEOUT;
    427427                }
    428                
     428
    429429                THREAD->timeout_pending = true;
    430430                timeout_register(&THREAD->sleep_timeout, (uint64_t) usec,
    431431                    waitq_sleep_timed_out, THREAD);
    432432        }
    433        
     433
    434434        list_append(&THREAD->wq_link, &wq->sleepers);
    435        
     435
    436436        /*
    437437         * Suspend execution.
    … …  
    440440        THREAD->state = Sleeping;
    441441        THREAD->sleep_queue = wq;
    442        
     442
    443443        /* Must be before entry to scheduler, because there are multiple
    444444         * return vectors.
    445445         */
    446446        *blocked = true;
    447        
     447
    448448        irq_spinlock_unlock(&THREAD->lock, false);
    449        
     449
    450450        /* wq->lock is released in scheduler_separated_stack() */
    451451        scheduler();
    452        
     452
    453453        return EOK;
    454454}
    … …  
    511511{
    512512        assert(interrupts_disabled());
    513        
     513
    514514        irq_spinlock_lock(&wq->lock, false);
    515515        irq_spinlock_unlock(&wq->lock, false);
    … …  
    536536        assert(interrupts_disabled());
    537537        assert(irq_spinlock_locked(&wq->lock));
    538        
     538
    539539loop:
    540540        if (list_empty(&wq->sleepers)) {
    … …  
    542542                if ((count) && (mode == WAKEUP_ALL))
    543543                        wq->missed_wakeups--;
    544                
     544
    545545                return;
    546546        }
    547        
     547
    548548        count++;
    549549        thread_t *thread = list_get_instance(list_first(&wq->sleepers),
    550550            thread_t, wq_link);
    551        
     551
    552552        /*
    553553         * Lock the thread prior to removing it from the wq.
    … …  
    569569        irq_spinlock_lock(&thread->lock, false);
    570570        list_remove(&thread->wq_link);
    571        
     571
    572572        if ((thread->timeout_pending) &&
    573573            (timeout_unregister(&thread->sleep_timeout)))
    574574                thread->timeout_pending = false;
    575        
     575
    576576        thread->sleep_queue = NULL;
    577577        irq_spinlock_unlock(&thread->lock, false);
    578        
     578
    579579        thread_ready(thread);
    580        
     580
    581581        if (mode == WAKEUP_ALL)
    582582                goto loop;
Note: See TracChangeset for help on using the changeset viewer.