Changeset a35b458 in mainline for kernel/generic/include


Ignore:
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/include
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/adt/avl.h

    r3061bc1 ra35b458  
    6969         */
    7070        struct avltree_node *lft;
    71        
     71
    7272        /**
    7373         * Pointer to the right descendant of this node.
    … …  
    7777         */
    7878        struct avltree_node *rgt;
    79        
     79
    8080        /** Pointer to the parent node. Root node has NULL parent. */
    8181        struct avltree_node *par;
    82        
     82
    8383        /** Node's key. */
    8484        avltree_key_t key;
    85        
     85
    8686        /**
    8787         * Difference between the heights of the left and the right subtree of

  • kernel/generic/include/adt/bitmap.h

    r3061bc1 ra35b458  
    5454        if (element >= bitmap->elements)
    5555                return;
    56        
     56
    5757        size_t byte = element / BITMAP_ELEMENT;
    5858        uint8_t mask = 1 << (element & BITMAP_REMAINER);
    59        
     59
    6060        if (value) {
    6161                bitmap->bits[byte] |= mask;
    … …  
    7070        if (element >= bitmap->elements)
    7171                return 0;
    72        
     72
    7373        size_t byte = element / BITMAP_ELEMENT;
    7474        uint8_t mask = 1 << (element & BITMAP_REMAINER);
    75        
     75
    7676        return !!((bitmap->bits)[byte] & mask);
    7777}

  • kernel/generic/include/adt/btree.h

    r3061bc1 ra35b458  
    6060         */
    6161        void *value[BTREE_MAX_KEYS + 1];
    62        
     62
    6363        /**
    6464         * Pointers to descendants of this node sorted according to the key

  • kernel/generic/include/adt/cht.h

    r3061bc1 ra35b458  
    9595        /** Item specific operations. */
    9696        cht_ops_t *op;
    97        
     97
    9898        /** Buckets currently in use. */
    9999        cht_buckets_t *b;
    … …  
    120120         */
    121121        atomic_t resize_reqs;
    122        
     122
    123123        /** Number of items in the table that have not been logically deleted. */
    124124        atomic_t item_cnt;

  • kernel/generic/include/adt/hash_table.h

    r3061bc1 ra35b458  
    5151        /** Returns the hash of the key stored in the item (ie its lookup key). */
    5252        size_t (*hash)(const ht_link_t *item);
    53        
     53
    5454        /** Returns the hash of the key. */
    5555        size_t (*key_hash)(void *key);
    56        
     56
    5757        /** True if the items are equal (have the same lookup keys). */
    5858        bool (*equal)(const ht_link_t *item1, const ht_link_t *item2);

  • kernel/generic/include/adt/list.h

    r3061bc1 ra35b458  
    231231                link->prev->next = link->next;
    232232        }
    233        
     233
    234234        link_initialize(link);
    235235}
    … …  
    314314        part1->prev->next = part2;
    315315        part2->prev->next = part1;
    316        
     316
    317317        link_t *hlp = part1->prev;
    318        
     318
    319319        part1->prev = part2->prev;
    320320        part2->prev = hlp;
    … …  
    378378{
    379379        unsigned long cnt = 0;
    380        
     380
    381381        link_t *link = list_first(list);
    382382        while (link != NULL) {
    383383                if (cnt == n)
    384384                        return link;
    385                
     385
    386386                cnt++;
    387387                link = list_next(link, list);
    388388        }
    389        
     389
    390390        return NULL;
    391391}

  • kernel/generic/include/bitops.h

    r3061bc1 ra35b458  
    5454{
    5555        uint8_t n = 0;
    56        
     56
    5757        if (arg >> 16) {
    5858                arg >>= 16;
    5959                n += 16;
    6060        }
    61        
     61
    6262        if (arg >> 8) {
    6363                arg >>= 8;
    6464                n += 8;
    6565        }
    66        
     66
    6767        if (arg >> 4) {
    6868                arg >>= 4;
    6969                n += 4;
    7070        }
    71        
     71
    7272        if (arg >> 2) {
    7373                arg >>= 2;
    7474                n += 2;
    7575        }
    76        
     76
    7777        if (arg >> 1)
    7878                n += 1;
    79        
     79
    8080        return n;
    8181}
    … …  
    8989{
    9090        uint8_t n = 0;
    91        
     91
    9292        if (arg >> 32) {
    9393                arg >>= 32;
    9494                n += 32;
    9595        }
    96        
     96
    9797        return n + fnzb32((uint32_t) arg);
    9898}

  • kernel/generic/include/config.h

    r3061bc1 ra35b458  
    8282        /** Number of processors that are up and running. */
    8383        volatile size_t cpu_active;
    84        
     84
    8585        uintptr_t base;
    8686        /** Size of memory in bytes taken by kernel and stack. */
    8787        size_t kernel_size;
    88        
     88
    8989        /** Base adddress of initial stack. */
    9090        uintptr_t stack_base;
    9191        /** Size of initial stack. */
    9292        size_t stack_size;
    93        
     93
    9494        bool identity_configured;
    9595        /** Base address of the kernel identity mapped memory. */
    … …  
    9797        /** Size of the kernel identity mapped memory. */
    9898        size_t identity_size;
    99        
     99
    100100        bool non_identity_configured;
    101        
     101
    102102        /** End of physical memory. */
    103103        uint64_t physmem_end;

  • kernel/generic/include/console/chardev.h

    r3061bc1 ra35b458  
    5656        /** Read character directly from device, assume interrupts disabled. */
    5757        wchar_t (* poll)(struct indev *);
    58        
     58
    5959        /** Signal out-of-band condition. */
    6060        void (* signal)(struct indev *, indev_signal_t);
    … …  
    6565        const char *name;
    6666        waitq_t wq;
    67        
     67
    6868        /** Protects everything below. */
    6969        IRQ_SPINLOCK_DECLARE(lock);
    7070        wchar_t buffer[INDEV_BUFLEN];
    7171        size_t counter;
    72        
     72
    7373        /** Implementation of indev operations. */
    7474        indev_operations_t *op;
    … …  
    8383        /** Write character to output. */
    8484        void (* write)(struct outdev *, wchar_t);
    85        
     85
    8686        /** Redraw any previously cached characters. */
    8787        void (* redraw)(struct outdev *);
    88        
     88
    8989        /** Scroll up in the device cache. */
    9090        void (* scroll_up)(struct outdev *);
    91        
     91
    9292        /** Scroll down in the device cache. */
    9393        void (* scroll_down)(struct outdev *);
    … …  
    9797typedef struct outdev {
    9898        const char *name;
    99        
     99
    100100        /** Protects everything below. */
    101101        SPINLOCK_DECLARE(lock);
    102        
     102
    103103        /** Fields suitable for multiplexing. */
    104104        link_t link;
    105105        list_t list;
    106        
     106
    107107        /** Implementation of outdev operations. */
    108108        outdev_operations_t *op;

  • kernel/generic/include/cpu.h

    r3061bc1 ra35b458  
    5454typedef struct cpu {
    5555        IRQ_SPINLOCK_DECLARE(lock);
    56        
     56
    5757        tlb_shootdown_msg_t tlb_messages[TLB_MESSAGE_QUEUE_LEN];
    5858        size_t tlb_messages_count;
    59        
     59
    6060        context_t saved_context;
    61        
     61
    6262        atomic_t nrdy;
    6363        runq_t rq[RQ_COUNT];
    6464        volatile size_t needs_relink;
    65        
     65
    6666        IRQ_SPINLOCK_DECLARE(timeoutlock);
    6767        list_t timeout_active_list;
    68        
     68
    6969        /**
    7070         * When system clock loses a tick, it is
    … …  
    7575         */
    7676        size_t missed_clock_ticks;
    77        
     77
    7878        /**
    7979         * Processor cycle accounting.
    … …  
    8383        uint64_t idle_cycles;
    8484        uint64_t busy_cycles;
    85        
     85
    8686        /**
    8787         * Processor ID assigned by kernel.
    8888         */
    8989        unsigned int id;
    90        
     90
    9191        bool active;
    9292        volatile bool tlb_active;
    93        
     93
    9494        uint16_t frequency_mhz;
    9595        uint32_t delay_loop_const;
    96        
     96
    9797        cpu_arch_t arch;
    98        
     98
    9999        struct thread *fpu_owner;
    100        
     100
    101101        /**
    102102         * SMP calls to invoke on this CPU.
    … …  
    104104        SPINLOCK_DECLARE(smp_calls_lock);
    105105        list_t smp_pending_calls;
    106        
     106
    107107        /** RCU per-cpu data. Uses own locking. */
    108108        rcu_cpu_data_t rcu;
    109        
     109
    110110        /**
    111111         * Stack used by scheduler when there is no running thread.

  • kernel/generic/include/ddi/ddi.h

    r3061bc1 ra35b458  
    4444typedef struct {
    4545        link_t link;      /**< Linked list link */
    46        
     46
    4747        uintptr_t pbase;  /**< Physical base of the area. */
    4848        pfn_t frames;     /**< Number of frames in the area. */

  • kernel/generic/include/ddi/irq.h

    r3061bc1 ra35b458  
    9393        /** Hash table link. */
    9494        ht_link_t link;
    95        
     95
    9696        /** Lock protecting everything in this structure
    9797         *  except the link member. When both the IRQ
    … …  
    100100         */
    101101        IRQ_SPINLOCK_DECLARE(lock);
    102        
     102
    103103        /** Send EOI before processing the interrupt.
    104104         *  This is essential for timer interrupt which
    … …  
    108108         */
    109109        bool preack;
    110        
     110
    111111        /** Actual IRQ number. -1 if not yet assigned. */
    112112        inr_t inr;
    … …  
    119119        /** Instance argument for the handler and the claim function. */
    120120        void *instance;
    121        
     121
    122122        /** Clear interrupt routine. */
    123123        cir_t cir;
    124124        /** First argument to the clear interrupt routine. */
    125125        void *cir_arg;
    126        
     126
    127127        /** Notification configuration structure. */
    128128        ipc_notif_cfg_t notif_cfg;

  • kernel/generic/include/ipc/event.h

    r3061bc1 ra35b458  
    4848typedef struct {
    4949        SPINLOCK_DECLARE(lock);
    50        
     50
    5151        /** Answerbox for notifications. */
    5252        answerbox_t *answerbox;
    … …  
    5555        /** Counter. */
    5656        size_t counter;
    57        
     57
    5858        /** Masked flag. */
    5959        bool masked;

  • kernel/generic/include/ipc/ipc.h

    r3061bc1 ra35b458  
    7777        /** Answerbox is active until it enters cleanup. */
    7878        bool active;
    79        
     79
    8080        struct task *task;
    81        
     81
    8282        waitq_t wq;
    83        
     83
    8484        /** Phones connected to this answerbox. */
    8585        list_t connected_phones;
    … …  
    8787        list_t calls;
    8888        list_t dispatched_calls;  /* Should be hash table in the future */
    89        
     89
    9090        /** Answered calls. */
    9191        list_t answers;
    92        
     92
    9393        IRQ_SPINLOCK_DECLARE(irq_lock);
    94        
     94
    9595        /** Notifications from IRQ handlers. */
    9696        list_t irq_notifs;
    … …  
    126126        /** Answerbox link. */
    127127        link_t ab_link;
    128        
     128
    129129        unsigned int flags;
    130130
    … …  
    145145        /** True if the call is in the active list. */
    146146        bool active;
    147        
     147
    148148        /**
    149149         * Identification of the caller.
    … …  
    151151         */
    152152        struct task *sender;
    153        
     153
    154154        /*
    155155         * Answerbox that will receive the answer.
    … …  
    161161        /** Phone which was used to send the call. */
    162162        phone_t *caller_phone;
    163        
     163
    164164        /** Private data to internal IPC. */
    165165        sysarg_t priv;
    166        
     166
    167167        /** Data passed from/to userspace. */
    168168        ipc_data_t data;

  • kernel/generic/include/macros.h

    r3061bc1 ra35b458  
    6262        if (sz2)
    6363                return ((s1 >= s2) && (s1 <= e2));
    64        
     64
    6565        if (sz1)
    6666                return ((s2 >= s1) && (s2 <= e1));
    … …  
    8787        if (sz1 == 0)
    8888                return (s1 == s2) && (sz2 == 0);
    89        
     89
    9090        e1 = s1 + sz1 - 1;
    9191        if (sz2 == 0)
    9292                return (s1 <= s2) && (s2 <= e1);
    93        
     93
    9494        e2 = s2 + sz2 - 1;
    9595

  • kernel/generic/include/mm/as.h

    r3061bc1 ra35b458  
    9494        /** Protected by asidlock. */
    9595        link_t inactive_as_with_asid_link;
    96        
     96
    9797        /**
    9898         * Number of processors on which this
    … …  
    101101         */
    102102        size_t cpu_refcount;
    103        
     103
    104104        /** Address space identifier.
    105105         *
    … …  
    109109         */
    110110        asid_t asid;
    111        
     111
    112112        /** Number of references (i.e. tasks that reference this as). */
    113113        atomic_t refcount;
    114        
     114
    115115        mutex_t lock;
    116        
     116
    117117        /** B+tree of address space areas. */
    118118        btree_t as_area_btree;
    119        
     119
    120120        /** Non-generic content. */
    121121        as_genarch_t genarch;
    122        
     122
    123123        /** Architecture specific content. */
    124124        as_arch_t arch;
    … …  
    178178                elf_segment_header_t *segment;
    179179        };
    180        
     180
    181181        /** phys_backend members */
    182182        struct {
    … …  
    200200typedef struct {
    201201        mutex_t lock;
    202        
     202
    203203        /** Containing address space. */
    204204        as_t *as;
    205        
     205
    206206        /** Memory flags. */
    207207        unsigned int flags;
    208        
     208
    209209        /** Address space area attributes. */
    210210        unsigned int attributes;
    211        
     211
    212212        /** Number of pages in the area. */
    213213        size_t pages;
    214        
     214
    215215        /** Number of resident pages in the area. */
    216216        size_t resident;
    217        
     217
    218218        /** Base address of this area. */
    219219        uintptr_t base;
    220        
     220
    221221        /** Map of used space. */
    222222        btree_t used_space;
    223        
     223
    224224        /**
    225225         * If the address space area is shared. this is
    … …  
    227227         */
    228228        share_info_t *sh_info;
    229        
     229
    230230        /** Memory backend backing this address space area. */
    231231        struct mem_backend *backend;
    232        
     232
    233233        /** Data to be used by the backend. */
    234234        mem_backend_data_t backend_data;

  • kernel/generic/include/mm/frame.h

    r3061bc1 ra35b458  
    9797        /** Frame_no of the first frame in the frames array */
    9898        pfn_t base;
    99        
     99
    100100        /** Size of zone */
    101101        size_t count;
    102        
     102
    103103        /** Number of free frame_t structures */
    104104        size_t free_count;
    105        
     105
    106106        /** Number of busy frame_t structures */
    107107        size_t busy_count;
    108        
     108
    109109        /** Type of the zone */
    110110        zone_flags_t flags;
    111        
     111
    112112        /** Frame bitmap */
    113113        bitmap_t bitmap;
    114        
     114
    115115        /** Array of frame_t structures in this zone */
    116116        frame_t *frames;

  • kernel/generic/include/mm/slab.h

    r3061bc1 ra35b458  
    8686typedef struct {
    8787        const char *name;
    88        
     88
    8989        link_t link;
    90        
     90
    9191        /* Configuration */
    92        
     92
    9393        /** Size of slab position - align_up(sizeof(obj)) */
    9494        size_t size;
    95        
     95
    9696        errno_t (*constructor)(void *obj, unsigned int kmflag);
    9797        size_t (*destructor)(void *obj);
    98        
     98
    9999        /** Flags changing behaviour of cache */
    100100        unsigned int flags;
    101        
     101
    102102        /* Computed values */
    103103        size_t frames;   /**< Number of frames to be allocated */
    104104        size_t objects;  /**< Number of objects that fit in */
    105        
     105
    106106        /* Statistics */
    107107        atomic_t allocated_slabs;
    … …  
    110110        /** How many magazines in magazines list */
    111111        atomic_t magazine_counter;
    112        
     112
    113113        /* Slabs */
    114114        list_t full_slabs;     /**< List of full slabs */
    … …  
    118118        list_t magazines;  /**< List o full magazines */
    119119        IRQ_SPINLOCK_DECLARE(maglock);
    120        
     120
    121121        /** CPU cache */
    122122        slab_mag_cache_t *mag_cache;

  • kernel/generic/include/printf/printf_core.h

    r3061bc1 ra35b458  
    4343        /* String output function, returns number of printed characters or EOF */
    4444        int (*str_write)(const char *, size_t, void *);
    45        
     45
    4646        /* Wide string output function, returns number of printed characters or EOF */
    4747        int (*wstr_write)(const wchar_t *, size_t, void *);
    48        
     48
    4949        /* User data - output stream specification, state, locks, etc. */
    5050        void *data;

  • kernel/generic/include/proc/task.h

    r3061bc1 ra35b458  
    7373        /** Task's linkage for the tasks_tree AVL tree. */
    7474        avltree_node_t tasks_tree_node;
    75        
     75
    7676        /** Task lock.
    7777         *
    … …  
    8080         */
    8181        IRQ_SPINLOCK_DECLARE(lock);
    82        
     82
    8383        char name[TASK_NAME_BUFLEN];
    8484        /** List of threads contained in this task. */
    … …  
    9090        /** Task security container. */
    9191        container_id_t container;
    92        
     92
    9393        /** Number of references (i.e. threads). */
    9494        atomic_t refcount;
    9595        /** Number of threads that haven't exited yet. */
    9696        atomic_t lifecount;
    97        
     97
    9898        /** Task permissions. */
    9999        perm_t perms;
    … …  
    101101        /** Capabilities */
    102102        cap_info_t *cap_info;
    103        
     103
    104104        /* IPC stuff */
    105105
    … …  
    120120        /** IPC statistics */
    121121        stats_ipc_t ipc_info;
    122        
     122
    123123#ifdef CONFIG_UDEBUG
    124124        /** Debugging stuff. */
    125125        udebug_task_t udebug;
    126        
     126
    127127        /** Kernel answerbox. */
    128128        kbox_t kb;
    129129#endif /* CONFIG_UDEBUG */
    130        
     130
    131131        /** Architecture specific task data. */
    132132        task_arch_t arch;
    133        
     133
    134134        struct futex_cache {
    135135                /** CHT mapping virtual addresses of futex variables to futex objects.*/
    … …  
    141141                work_t destroy_work;
    142142        } *futexes;
    143        
     143
    144144        /** Accumulated accounting. */
    145145        uint64_t ucycles;

  • kernel/generic/include/proc/thread.h

    r3061bc1 ra35b458  
    7575        link_t wq_link;  /**< Wait queue link. */
    7676        link_t th_link;  /**< Links to threads within containing task. */
    77        
     77
    7878        /** Threads linkage to the threads_tree. */
    7979        avltree_node_t threads_tree_node;
    80        
     80
    8181        /** Lock protecting thread structure.
    8282         *
    … …  
    8484         */
    8585        IRQ_SPINLOCK_DECLARE(lock);
    86        
     86
    8787        char name[THREAD_NAME_BUFLEN];
    88        
     88
    8989        /** Function implementing the thread. */
    9090        void (*thread_code)(void *);
    9191        /** Argument passed to thread_code() function. */
    9292        void *thread_arg;
    93        
     93
    9494        /**
    9595         * From here, the stored context is restored
    … …  
    9797         */
    9898        context_t saved_context;
    99        
     99
    100100        /**
    101101         * From here, the stored timeout context
    … …  
    103103         */
    104104        context_t sleep_timeout_context;
    105        
     105
    106106        /**
    107107         * From here, the stored interruption context
    … …  
    109109         */
    110110        context_t sleep_interruption_context;
    111        
     111
    112112        /** If true, the thread can be interrupted from sleep. */
    113113        bool sleep_interruptible;
    … …  
    118118        /** Flag signalling sleep timeout in progress. */
    119119        volatile bool timeout_pending;
    120        
     120
    121121        /**
    122122         * True if this thread is executing copy_from_uspace().
    … …  
    124124         */
    125125        bool in_copy_from_uspace;
    126        
     126
    127127        /**
    128128         * True if this thread is executing copy_to_uspace().
    … …  
    130130         */
    131131        bool in_copy_to_uspace;
    132        
     132
    133133        /**
    134134         * If true, the thread will not go to sleep at all and will call
    … …  
    136136         */
    137137        bool interrupted;
    138        
     138
    139139        /** If true, thread_join_timeout() cannot be used on this thread. */
    140140        bool detached;
    … …  
    143143        /** Link used in the joiner_head list. */
    144144        link_t joiner_link;
    145        
     145
    146146        fpu_context_t *saved_fpu_context;
    147147        bool fpu_context_exists;
    148        
     148
    149149        /*
    150150         * Defined only if thread doesn't run.
    … …  
    153153         */
    154154        bool fpu_context_engaged;
    155        
     155
    156156        /* The thread will not be migrated if nomigrate is non-zero. */
    157157        unsigned int nomigrate;
    158        
     158
    159159        /** Thread state. */
    160160        state_t state;
    161        
     161
    162162        /** Thread CPU. */
    163163        cpu_t *cpu;
    … …  
    170170        /** Thread is executed in user space. */
    171171        bool uspace;
    172        
     172
    173173        /** Ticks before preemption. */
    174174        uint64_t ticks;
    175        
     175
    176176        /** Thread accounting. */
    177177        uint64_t ucycles;
    … …  
    181181        /** Thread doesn't affect accumulated accounting. */
    182182        bool uncounted;
    183        
     183
    184184        /** Thread's priority. Implemented as index to CPU->rq */
    185185        int priority;
    … …  
    195195        /** True if the worker will block in order to become idle. Use workq->lock. */
    196196        bool workq_idling;
    197        
     197
    198198        /** RCU thread related data. Protected by its own locks. */
    199199        rcu_thread_data_t rcu;
    200        
     200
    201201        /** Architecture-specific data. */
    202202        thread_arch_t arch;
    203        
     203
    204204        /** Thread's kernel stack. */
    205205        uint8_t *kstack;
    206        
     206
    207207#ifdef CONFIG_UDEBUG
    208208        /**
    … …  
    211211         */
    212212        bool btrace;
    213        
     213
    214214        /** Debugging stuff */
    215215        udebug_thread_t udebug;

  • kernel/generic/include/synch/rcu.h

    r3061bc1 ra35b458  
    147147        compiler_barrier();
    148148        THE->rcu_nesting -= RCU_CNT_INC;
    149        
     149
    150150        if (RCU_WAS_PREEMPTED == THE->rcu_nesting) {
    151151                _rcu_preempted_unlock();
    … …  
    164164{
    165165        assert(PREEMPTION_DISABLED || interrupts_disabled());
    166        
     166
    167167        /*
    168168         * A new GP was started since the last time we passed a QS.
    … …  
    225225        assert(CPU);
    226226        preemption_disable();
    227        
     227
    228228        if (0 == --CPU->rcu.nesting_cnt) {
    229229                _rcu_record_qs();
    230                
     230
    231231                /*
    232232                 * The thread was preempted while in a critical section or
    … …  
    238238                }
    239239        }
    240        
     240
    241241        preemption_enable();
    242242}

  • kernel/generic/include/synch/rcu_types.h

    r3061bc1 ra35b458  
    7070         */
    7171        bool is_delaying_gp;
    72        
     72
    7373        /** True if we should signal the detector that we exited a reader section.
    7474         *
    … …  
    8585        size_t nesting_cnt;
    8686#endif
    87        
     87
    8888        /** Callbacks to invoke once the current grace period ends, ie cur_cbs_gp.
    8989         * Accessed by the local reclaimer only.
    … …  
    118118         */
    119119        rcu_gp_t next_cbs_gp;
    120        
     120
    121121        /** Positive if there are callbacks pending in arriving_cbs. */
    122122        semaphore_t arrived_flag;
    123        
     123
    124124        /** The reclaimer should expedite GPs for cbs in arriving_cbs. */
    125125        bool expedite_arriving;
    126        
     126
    127127        /** Protected by global rcu.barrier_mtx. */
    128128        rcu_item_t barrier_item;
    129        
     129
    130130        /** Interruptable attached reclaimer thread. */
    131131        struct thread *reclaimer_thr;
    132        
     132
    133133        /* Some statistics. */
    134134        size_t stat_max_cbs;
    … …  
    150150
    151151#ifdef RCU_PREEMPT_PODZIMEK
    152        
     152
    153153        /** True if the thread was preempted in a reader section.
    154154         *
    … …  
    160160        bool was_preempted;
    161161#endif
    162        
     162
    163163        /** Preempted threads link. Access with rcu.prempt_lock.*/
    164164        link_t preempt_link;

  • kernel/generic/include/synch/spinlock.h

    r3061bc1 ra35b458  
    4747typedef struct spinlock {
    4848        atomic_t val;
    49        
     49
    5050#ifdef CONFIG_DEBUG_SPINLOCK
    5151        const char *name;
    … …  
    130130         */
    131131        CS_LEAVE_BARRIER();
    132        
     132
    133133        atomic_set(&lock->val, 0);
    134134        preemption_enable();

  • kernel/generic/include/synch/waitq.h

    r3061bc1 ra35b458  
    5555         */
    5656        IRQ_SPINLOCK_DECLARE(lock);
    57        
     57
    5858        /**
    5959         * Number of waitq_wakeup() calls that didn't find a thread to wake up.
    … …  
    6161         */
    6262        int missed_wakeups;
    63        
     63
    6464        /** List of sleeping threads for which there was no missed_wakeup. */
    6565        list_t sleepers;

  • kernel/generic/include/synch/workqueue.h

    r3061bc1 ra35b458  
    4949        link_t queue_link;
    5050        work_func_t func;
    51        
     51
    5252#ifdef CONFIG_DEBUG
    5353        /* Magic number for integrity checks. */

  • kernel/generic/include/sysinfo/sysinfo.h

    r3061bc1 ra35b458  
    137137typedef struct sysinfo_item {
    138138        char *name;                           /**< Item name */
    139        
     139
    140140        sysinfo_item_val_type_t val_type;     /**< Item value type */
    141141        sysinfo_item_val_t val;               /**< Item value */
    142        
     142
    143143        sysinfo_subtree_type_t subtree_type;  /**< Subtree type */
    144144        sysinfo_subtree_t subtree;            /**< Subtree */
    145        
     145
    146146        struct sysinfo_item *next;            /**< Sibling item */
    147147} sysinfo_item_t;

  • kernel/generic/include/time/timeout.h

    r3061bc1 ra35b458  
    4444typedef struct {
    4545        IRQ_SPINLOCK_DECLARE(lock);
    46        
     46
    4747        /** Link to the list of active timeouts on THE->cpu */
    4848        link_t link;

  • kernel/generic/include/udebug/udebug.h

    r3061bc1 ra35b458  
    5858        mutex_t lock;
    5959        char *lock_owner;
    60        
     60
    6161        udebug_task_state_t dt_state;
    6262        call_t *begin_call;
    … …  
    7171        /** Synchronize debug ops on this thread / access to this structure. */
    7272        mutex_t lock;
    73        
     73
    7474        waitq_t go_wq;
    7575        call_t *go_call;
    7676        sysarg_t syscall_args[6];
    7777        istate_t *uspace_state;
    78        
     78
    7979        /** What type of event are we stopped in or 0 if none. */
    8080        udebug_event_t cur_event;
Note: See TracChangeset for help on using the changeset viewer.