Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 55b77d9 in mainline


Ignore:
Timestamp:
2011-06-17T20:39:16Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
8f164724
Parents:
98caf49
Message:

Separate list_t typedef from link_t (kernel part).

  • list_t represents lists
  • Use list_first(), list_last(), list_empty() where appropriate
  • Use list_foreach() where possible
  • Replace improper uses of list_prepend() with list_insert_after()
  • Replace improper uses of list_append() with list_insert_before()
Location:
kernel
Files:
39 edited

Legend:

Unmodified
Added
Removed
  • kernel/genarch/src/mm/asid.c

    r98caf49 r55b77d9  
    9797                 * inactive address space.
    9898                 */
    99                 ASSERT(!list_empty(&inactive_as_with_asid_head));
    100                 tmp = inactive_as_with_asid_head.next;
     99                tmp = list_first(&inactive_as_with_asid_list);
     100                ASSERT(tmp != NULL);
    101101                list_remove(tmp);
    102102               
  • kernel/generic/include/adt/btree.h

    r98caf49 r55b77d9  
    8989typedef struct {
    9090        btree_node_t *root;     /**< B-tree root node pointer. */
    91         link_t leaf_head;       /**< Leaf-level list head. */
     91        list_t leaf_list;       /**< List of leaves. */
    9292} btree_t;
    9393
  • kernel/generic/include/adt/hash_table.h

    r98caf49 r55b77d9  
    6868/** Hash table structure. */
    6969typedef struct {
    70         link_t *entry;
     70        list_t *entry;
    7171        size_t entries;
    7272        size_t max_keys;
  • kernel/generic/include/adt/list.h

    r98caf49 r55b77d9  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    3940#include <trace.h>
    4041
    41 /** Doubly linked list head and link type. */
     42/** Doubly linked list link. */
    4243typedef struct link {
    4344        struct link *prev;  /**< Pointer to the previous item in the list. */
     
    4546} link_t;
    4647
     48/** Doubly linked list. */
     49typedef struct list {
     50        link_t head;  /**< List head. Does not have any data. */
     51} list_t;
     52
    4753/** Declare and initialize statically allocated list.
    4854 *
     
    5157 */
    5258#define LIST_INITIALIZE(name) \
    53         link_t name = { \
    54                 .prev = &name, \
    55                 .next = &name \
     59        list_t name = { \
     60                .head = { \
     61                        .prev = &(name).head, \
     62                        .next = &(name).head \
     63                } \
    5664        }
    5765
     
    6068
    6169#define list_foreach(list, iterator) \
    62         for (link_t *iterator = (list).next; \
    63             iterator != &(list); iterator = iterator->next)
     70        for (link_t *iterator = (list).head.next; \
     71            iterator != &(list).head; iterator = iterator->next)
    6472
    6573/** Initialize doubly-linked circular list link
     
    8088 * Initialize doubly-linked circular list.
    8189 *
    82  * @param list Pointer to link_t structure representing the list.
    83  *
    84  */
    85 NO_TRACE static inline void list_initialize(link_t *list)
    86 {
    87         list->prev = list;
    88         list->next = list;
     90 * @param list Pointer to list_t structure.
     91 *
     92 */
     93NO_TRACE static inline void list_initialize(list_t *list)
     94{
     95        list->head.prev = &list->head;
     96        list->head.next = &list->head;
     97}
     98
     99/** Insert item before another item in doubly-linked circular list.
     100 *
     101 */
     102static inline void list_insert_before(link_t *lnew, link_t *lold)
     103{
     104        lnew->next = lold;
     105        lnew->prev = lold->prev;
     106        lold->prev->next = lnew;
     107        lold->prev = lnew;
     108}
     109
     110/** Insert item after another item in doubly-linked circular list.
     111 *
     112 */
     113static inline void list_insert_after(link_t *lnew, link_t *lold)
     114{
     115        lnew->prev = lold;
     116        lnew->next = lold->next;
     117        lold->next->prev = lnew;
     118        lold->next = lnew;
    89119}
    90120
     
    94124 *
    95125 * @param link Pointer to link_t structure to be added.
    96  * @param list Pointer to link_t structure representing the list.
    97  *
    98  */
    99 NO_TRACE static inline void list_prepend(link_t *link, link_t *list)
    100 {
    101         link->next = list->next;
    102         link->prev = list;
    103         list->next->prev = link;
    104         list->next = link;
     126 * @param list Pointer to list_t structure.
     127 *
     128 */
     129NO_TRACE static inline void list_prepend(link_t *link, list_t *list)
     130{
     131        list_insert_after(link, &list->head);
    105132}
    106133
     
    110137 *
    111138 * @param link Pointer to link_t structure to be added.
    112  * @param list Pointer to link_t structure representing the list.
    113  *
    114  */
    115 NO_TRACE static inline void list_append(link_t *link, link_t *list)
    116 {
    117         link->prev = list->prev;
    118         link->next = list;
    119         list->prev->next = link;
    120         list->prev = link;
    121 }
    122 
    123 /** Insert item before another item in doubly-linked circular list.
    124  *
    125  */
    126 static inline void list_insert_before(link_t *link, link_t *list)
    127 {
    128         list_append(link, list);
    129 }
    130 
    131 /** Insert item after another item in doubly-linked circular list.
    132  *
    133  */
    134 static inline void list_insert_after(link_t *link, link_t *list)
    135 {
    136         list_prepend(list, link);
     139 * @param list Pointer to list_t structure.
     140 *
     141 */
     142NO_TRACE static inline void list_append(link_t *link, list_t *list)
     143{
     144        list_insert_before(link, &list->head);
    137145}
    138146
     
    156164 * Query emptiness of doubly-linked circular list.
    157165 *
    158  * @param list Pointer to link_t structure representing the list.
    159  *
    160  */
    161 NO_TRACE static inline int list_empty(link_t *list)
    162 {
    163         return (list->next == list);
    164 }
    165 
    166 /** Get head item of a list.
    167  *
    168  * @param list Pointer to link_t structure representing the list.
     166 * @param list Pointer to lins_t structure.
     167 *
     168 */
     169NO_TRACE static inline int list_empty(list_t *list)
     170{
     171        return (list->head.next == &list->head);
     172}
     173
     174/** Get first item in list.
     175 *
     176 * @param list Pointer to list_t structure.
    169177 *
    170178 * @return Head item of the list.
     
    172180 *
    173181 */
    174 static inline link_t *list_head(link_t *list)
    175 {
    176         return ((list->next == list) ? NULL : list->next);
     182static inline link_t *list_first(list_t *list)
     183{
     184        return ((list->head.next == &list->head) ? NULL : list->head.next);
     185}
     186
     187/** Get last item in list.
     188 *
     189 * @param list Pointer to list_t structure.
     190 *
     191 * @return Head item of the list.
     192 * @return NULL if the list is empty.
     193 *
     194 */
     195static inline link_t *list_last(list_t *list)
     196{
     197        return ((list->head.prev == &list->head) ? NULL : list->head.prev);
    177198}
    178199
     
    231252}
    232253
    233 /** Get n-th item of a list.
     254/** Get n-th item in a list.
    234255 *
    235256 * @param list Pointer to link_t structure representing the list.
     
    240261 *
    241262 */
    242 static inline link_t *list_nth(link_t *list, unsigned int n)
     263static inline link_t *list_nth(list_t *list, unsigned int n)
    243264{
    244265        unsigned int cnt = 0;
     
    254275}
    255276
    256 extern int list_member(const link_t *, const link_t *);
    257 extern void list_concat(link_t *, link_t *);
    258 extern unsigned int list_count(const link_t *);
     277extern int list_member(const link_t *, const list_t *);
     278extern void list_concat(list_t *, list_t *);
     279extern unsigned int list_count(const list_t *);
    259280
    260281#endif
  • kernel/generic/include/console/chardev.h

    r98caf49 r55b77d9  
    8888        /** Fields suitable for multiplexing. */
    8989        link_t link;
    90         link_t list;
     90        list_t list;
    9191       
    9292        /** Implementation of outdev operations. */
  • kernel/generic/include/console/kconsole.h

    r98caf49 r55b77d9  
    9191
    9292SPINLOCK_EXTERN(cmd_lock);
    93 extern link_t cmd_head;
     93extern list_t cmd_list;
    9494
    9595extern void kconsole_init(void);
  • kernel/generic/include/cpu.h

    r98caf49 r55b77d9  
    5959       
    6060        IRQ_SPINLOCK_DECLARE(timeoutlock);
    61         link_t timeout_active_head;
     61        list_t timeout_active_list;
    6262       
    6363        /**
  • kernel/generic/include/ipc/ipc.h

    r98caf49 r55b77d9  
    166166       
    167167        /** Phones connected to this answerbox. */
    168         link_t connected_phones;
     168        list_t connected_phones;
    169169        /** Received calls. */
    170         link_t calls;
    171         link_t dispatched_calls;  /* Should be hash table in the future */
     170        list_t calls;
     171        list_t dispatched_calls;  /* Should be hash table in the future */
    172172       
    173173        /** Answered calls. */
    174         link_t answers;
     174        list_t answers;
    175175       
    176176        IRQ_SPINLOCK_DECLARE(irq_lock);
    177177       
    178178        /** Notifications from IRQ handlers. */
    179         link_t irq_notifs;
     179        list_t irq_notifs;
    180180        /** IRQs with notifications to this answerbox. */
    181         link_t irq_head;
     181        list_t irq_list;
    182182} answerbox_t;
    183183
     
    243243extern void ipc_backsend_err(phone_t *, call_t *, sysarg_t);
    244244extern void ipc_answerbox_slam_phones(answerbox_t *, bool);
    245 extern void ipc_cleanup_call_list(link_t *);
     245extern void ipc_cleanup_call_list(list_t *);
    246246
    247247extern void ipc_print_task(task_id_t);
  • kernel/generic/include/mm/as.h

    r98caf49 r55b77d9  
    254254
    255255extern as_operations_t *as_operations;
    256 extern link_t inactive_as_with_asid_head;
     256extern list_t inactive_as_with_asid_list;
    257257
    258258extern void as_init(void);
  • kernel/generic/include/mm/buddy.h

    r98caf49 r55b77d9  
    7272        /** Maximal order of block which can be stored by buddy system. */
    7373        uint8_t max_order;
    74         link_t *order;
     74        list_t *order;
    7575        buddy_system_operations_t *op;
    7676        /** Pointer to be used by the implementation. */
  • kernel/generic/include/mm/slab.h

    r98caf49 r55b77d9  
    111111       
    112112        /* Slabs */
    113         link_t full_slabs;     /**< List of full slabs */
    114         link_t partial_slabs;  /**< List of partial slabs */
     113        list_t full_slabs;     /**< List of full slabs */
     114        list_t partial_slabs;  /**< List of partial slabs */
    115115        SPINLOCK_DECLARE(slablock);
    116116        /* Magazines */
    117         link_t magazines;  /**< List o full magazines */
     117        list_t magazines;  /**< List o full magazines */
    118118        SPINLOCK_DECLARE(maglock);
    119119       
  • kernel/generic/include/proc/scheduler.h

    r98caf49 r55b77d9  
    4848typedef struct {
    4949        IRQ_SPINLOCK_DECLARE(lock);
    50         link_t rq_head;              /**< List of ready threads. */
    51         size_t n;                    /**< Number of threads in rq_ready. */
     50        list_t rq;                      /**< List of ready threads. */
     51        size_t n;                       /**< Number of threads in rq_ready. */
    5252} runq_t;
    5353
  • kernel/generic/include/proc/task.h

    r98caf49 r55b77d9  
    7373        char name[TASK_NAME_BUFLEN];
    7474        /** List of threads contained in this task. */
    75         link_t th_head;
     75        list_t threads;
    7676        /** Address space. */
    7777        as_t *as;
     
    9494        stats_ipc_t ipc_info;   /**< IPC statistics */
    9595        /** List of synchronous answerboxes. */
    96         link_t sync_box_head;
     96        list_t sync_boxes;
    9797       
    9898#ifdef CONFIG_UDEBUG
  • kernel/generic/include/synch/waitq.h

    r98caf49 r55b77d9  
    6363       
    6464        /** List of sleeping threads for which there was no missed_wakeup. */
    65         link_t head;
     65        list_t sleepers;
    6666} waitq_t;
    6767
  • kernel/generic/src/adt/btree.c

    r98caf49 r55b77d9  
    108108void btree_create(btree_t *t)
    109109{
    110         list_initialize(&t->leaf_head);
     110        list_initialize(&t->leaf_list);
    111111        t->root = (btree_node_t *) slab_alloc(btree_node_slab, 0);
    112112        node_initialize(t->root);
    113         list_append(&t->root->leaf_link, &t->leaf_head);
     113        list_append(&t->root->leaf_link, &t->leaf_list);
    114114}
    115115
     
    588588               
    589589                if (LEAF_NODE(node)) {
    590                         list_prepend(&rnode->leaf_link, &node->leaf_link);
     590                        list_insert_after(&rnode->leaf_link, &node->leaf_link);
    591591                }
    592592               
     
    953953        ASSERT(LEAF_NODE(node));
    954954       
    955         if (node->leaf_link.prev != &t->leaf_head)
     955        if (node->leaf_link.prev != &t->leaf_list.head)
    956956                return list_get_instance(node->leaf_link.prev, btree_node_t, leaf_link);
    957957        else
     
    972972        ASSERT(LEAF_NODE(node));
    973973       
    974         if (node->leaf_link.next != &t->leaf_head)
     974        if (node->leaf_link.next != &t->leaf_list.head)
    975975                return list_get_instance(node->leaf_link.next, btree_node_t, leaf_link);
    976976        else
     
    987987        size_t i;
    988988        int depth = t->root->depth;
    989         link_t head, *cur;
     989        list_t list;
    990990       
    991991        printf("Printing B-tree:\n");
    992         list_initialize(&head);
    993         list_append(&t->root->bfs_link, &head);
     992        list_initialize(&list);
     993        list_append(&t->root->bfs_link, &list);
    994994       
    995995        /*
     
    997997         * Levels are distinguished from one another by node->depth.
    998998         */
    999         while (!list_empty(&head)) {
     999        while (!list_empty(&list)) {
    10001000                link_t *hlp;
    10011001                btree_node_t *node;
    10021002               
    1003                 hlp = head.next;
    1004                 ASSERT(hlp != &head);
     1003                hlp = list_first(&list);
     1004                ASSERT(hlp != NULL);
    10051005                node = list_get_instance(hlp, btree_node_t, bfs_link);
    10061006                list_remove(hlp);
     
    10181018                        printf("%" PRIu64 "%s", node->key[i], i < node->keys - 1 ? "," : "");
    10191019                        if (node->depth && node->subtree[i]) {
    1020                                 list_append(&node->subtree[i]->bfs_link, &head);
     1020                                list_append(&node->subtree[i]->bfs_link, &list);
    10211021                        }
    10221022                }
    10231023               
    10241024                if (node->depth && node->subtree[i])
    1025                         list_append(&node->subtree[i]->bfs_link, &head);
     1025                        list_append(&node->subtree[i]->bfs_link, &list);
    10261026               
    10271027                printf(")");
     
    10311031       
    10321032        printf("Printing list of leaves:\n");
    1033         for (cur = t->leaf_head.next; cur != &t->leaf_head; cur = cur->next) {
     1033        list_foreach(t->leaf_list, cur) {
    10341034                btree_node_t *node;
    10351035               
  • kernel/generic/src/adt/hash_table.c

    r98caf49 r55b77d9  
    6262        ASSERT(max_keys > 0);
    6363       
    64         h->entry = (link_t *) malloc(m * sizeof(link_t), 0);
     64        h->entry = (list_t *) malloc(m * sizeof(list_t), 0);
    6565        if (!h->entry)
    6666                panic("Cannot allocate memory for hash table.");
    6767       
    68         memsetb(h->entry, m * sizeof(link_t), 0);
     68        memsetb(h->entry, m * sizeof(list_t), 0);
    6969       
    7070        for (i = 0; i < m; i++)
     
    107107link_t *hash_table_find(hash_table_t *h, sysarg_t key[])
    108108{
    109         link_t *cur;
    110109        size_t chain;
    111110       
     
    118117        ASSERT(chain < h->entries);
    119118       
    120         for (cur = h->entry[chain].next; cur != &h->entry[chain]; cur = cur->next) {
     119        list_foreach(h->entry[chain], cur) {
    121120                if (h->op->compare(key, h->max_keys, cur)) {
    122121                        /*
     
    141140{
    142141        size_t chain;
    143         link_t *cur;
    144142       
    145143        ASSERT(h);
     
    150148       
    151149        if (keys == h->max_keys) {
     150                link_t *cur;
    152151       
    153152                /*
     
    169168         */
    170169        for (chain = 0; chain < h->entries; chain++) {
    171                 for (cur = h->entry[chain].next; cur != &h->entry[chain]; cur = cur->next) {
     170                list_foreach(h->entry[chain], cur) {
    172171                        if (h->op->compare(key, keys, cur)) {
    173172                                link_t *hlp;
  • kernel/generic/src/adt/list.c

    r98caf49 r55b77d9  
    4343/** Check for membership
    4444 *
    45  * Check whether link is contained in the list head.
    46  * The membership is defined as pointer equivalence.
     45 * Check whether link is contained in a list.
     46 * Membership is defined as pointer equivalence.
    4747 *
    48  * @param link Item to look for.
    49  * @param head List to look in.
     48 * @param link  Item to look for.
     49 * @param list  List to look in.
    5050 *
    5151 * @return true if link is contained in head, false otherwise.
    5252 *
    5353 */
    54 int list_member(const link_t *link, const link_t *head)
     54int list_member(const link_t *link, const list_t *list)
    5555{
    5656        bool found = false;
    57         link_t *hlp = head->next;
     57        link_t *hlp = list->head.next;
    5858       
    59         while (hlp != head) {
     59        while (hlp != &list->head) {
    6060                if (hlp == link) {
    6161                        found = true;
     
    6868}
    6969
    70 
    7170/** Concatenate two lists
    7271 *
    73  * Concatenate lists head1 and head2, producing a single
    74  * list head1 containing items from both (in head1, head2
    75  * order) and empty list head2.
     72 * Concatenate lists @a list1 and @a list2, producing a single
     73 * list @a list1 containing items from both (in @a list1, @a list2
     74 * order) and empty list @a list2.
    7675 *
    77  * @param head1 First list and concatenated output
    78  * @param head2 Second list and empty output.
     76 * @param list1         First list and concatenated output
     77 * @param list2         Second list and empty output.
    7978 *
    8079 */
    81 void list_concat(link_t *head1, link_t *head2)
     80void list_concat(list_t *list1, list_t *list2)
    8281{
    83         if (list_empty(head2))
     82        if (list_empty(list2))
    8483                return;
    8584
    86         head2->next->prev = head1->prev;
    87         head2->prev->next = head1;     
    88         head1->prev->next = head2->next;
    89         head1->prev = head2->prev;
    90         list_initialize(head2);
     85        list2->head.next->prev = list1->head.prev;
     86        list2->head.prev->next = &list1->head;
     87        list1->head.prev->next = list2->head.next;
     88        list1->head.prev = list2->head.prev;
     89        list_initialize(list2);
    9190}
    9291
  • kernel/generic/src/console/cmd.c

    r98caf49 r55b77d9  
    573573        spinlock_lock(&cmd_lock);
    574574       
    575         link_t *cur;
    576575        size_t len = 0;
    577         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
     576        list_foreach(cmd_list, cur) {
    578577                cmd_info_t *hlp;
    579578                hlp = list_get_instance(cur, cmd_info_t, link);
     
    591590        }
    592591       
    593         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
     592        list_foreach(cmd_list, cur) {
    594593                cmd_info_t *hlp;
    595594                hlp = list_get_instance(cur, cmd_info_t, link);
     
    646645int cmd_desc(cmd_arg_t *argv)
    647646{
    648         link_t *cur;
    649        
    650647        spinlock_lock(&cmd_lock);
    651648       
    652         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
     649        list_foreach(cmd_list, cur) {
    653650                cmd_info_t *hlp;
    654651               
  • kernel/generic/src/console/console.c

    r98caf49 r55b77d9  
    124124static void stdout_write(outdev_t *dev, wchar_t ch, bool silent)
    125125{
    126         link_t *cur;
    127        
    128         for (cur = dev->list.next; cur != &dev->list; cur = cur->next) {
     126        list_foreach(dev->list, cur) {
    129127                outdev_t *sink = list_get_instance(cur, outdev_t, link);
    130128                if ((sink) && (sink->op->write))
     
    135133static void stdout_redraw(outdev_t *dev)
    136134{
    137         link_t *cur;
    138        
    139         for (cur = dev->list.next; cur != &dev->list; cur = cur->next) {
     135        list_foreach(dev->list, cur) {
    140136                outdev_t *sink = list_get_instance(cur, outdev_t, link);
    141137                if ((sink) && (sink->op->redraw))
  • kernel/generic/src/console/kconsole.c

    r98caf49 r55b77d9  
    8484
    8585SPINLOCK_INITIALIZE(cmd_lock);  /**< Lock protecting command list. */
    86 LIST_INITIALIZE(cmd_head);      /**< Command list. */
     86LIST_INITIALIZE(cmd_list);      /**< Command list. */
    8787
    8888static wchar_t history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
     
    113113bool cmd_register(cmd_info_t *cmd)
    114114{
    115         link_t *cur;
    116        
    117115        spinlock_lock(&cmd_lock);
    118116       
     
    120118         * Make sure the command is not already listed.
    121119         */
    122         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
     120        list_foreach(cmd_list, cur) {
    123121                cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
    124122               
     
    153151         * Now the command can be added.
    154152         */
    155         list_append(&cmd->link, &cmd_head);
     153        list_append(&cmd->link, &cmd_list);
    156154       
    157155        spinlock_unlock(&cmd_lock);
     
    176174       
    177175        if (*startpos == NULL)
    178                 *startpos = cmd_head.next;
    179        
    180         for (; *startpos != &cmd_head; *startpos = (*startpos)->next) {
     176                *startpos = cmd_list.head.next;
     177       
     178        for (; *startpos != &cmd_list.head; *startpos = (*startpos)->next) {
    181179                cmd_info_t *hlp = list_get_instance(*startpos, cmd_info_t, link);
    182180               
     
    559557       
    560558        cmd_info_t *cmd = NULL;
    561         link_t *cur;
    562        
    563         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
     559       
     560        list_foreach(cmd_list, cur) {
    564561                cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
    565562                spinlock_lock(&hlp->lock);
  • kernel/generic/src/cpu/cpu.c

    r98caf49 r55b77d9  
    8282                        for (j = 0; j < RQ_COUNT; j++) {
    8383                                irq_spinlock_initialize(&cpus[i].rq[j].lock, "cpus[].rq[].lock");
    84                                 list_initialize(&cpus[i].rq[j].rq_head);
     84                                list_initialize(&cpus[i].rq[j].rq);
    8585                        }
    8686                }
  • kernel/generic/src/ipc/ipc.c

    r98caf49 r55b77d9  
    128128        list_initialize(&box->answers);
    129129        list_initialize(&box->irq_notifs);
    130         list_initialize(&box->irq_head);
     130        list_initialize(&box->irq_list);
    131131        box->task = task;
    132132}
     
    183183         */
    184184        irq_spinlock_lock(&TASK->lock, true);
    185         list_append(&sync_box->sync_box_link, &TASK->sync_box_head);
     185        list_append(&sync_box->sync_box_link, &TASK->sync_boxes);
    186186        irq_spinlock_unlock(&TASK->lock, true);
    187187       
     
    450450                irq_spinlock_lock(&box->irq_lock, false);
    451451               
    452                 request = list_get_instance(box->irq_notifs.next, call_t, link);
     452                request = list_get_instance(list_first(&box->irq_notifs),
     453                    call_t, link);
    453454                list_remove(&request->link);
    454455               
     
    459460               
    460461                /* Handle asynchronous answers */
    461                 request = list_get_instance(box->answers.next, call_t, link);
     462                request = list_get_instance(list_first(&box->answers),
     463                    call_t, link);
    462464                list_remove(&request->link);
    463465                atomic_dec(&request->data.phone->active_calls);
     
    467469               
    468470                /* Handle requests */
    469                 request = list_get_instance(box->calls.next, call_t, link);
     471                request = list_get_instance(list_first(&box->calls),
     472                    call_t, link);
    470473                list_remove(&request->link);
    471474               
     
    494497 *
    495498 */
    496 void ipc_cleanup_call_list(link_t *lst)
     499void ipc_cleanup_call_list(list_t *lst)
    497500{
    498501        while (!list_empty(lst)) {
    499                 call_t *call = list_get_instance(lst->next, call_t, link);
     502                call_t *call = list_get_instance(list_first(lst), call_t, link);
    500503                if (call->buffer)
    501504                        free(call->buffer);
     
    526529        irq_spinlock_lock(&box->lock, true);
    527530        while (!list_empty(&box->connected_phones)) {
    528                 phone = list_get_instance(box->connected_phones.next,
     531                phone = list_get_instance(list_first(&box->connected_phones),
    529532                    phone_t, link);
    530533                if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
     
    606609        /* Wait for all answers to interrupted synchronous calls to arrive */
    607610        ipl_t ipl = interrupts_disable();
    608         while (!list_empty(&TASK->sync_box_head)) {
    609                 answerbox_t *box = list_get_instance(TASK->sync_box_head.next,
    610                     answerbox_t, sync_box_link);
     611        while (!list_empty(&TASK->sync_boxes)) {
     612                answerbox_t *box = list_get_instance(
     613                    list_first(&TASK->sync_boxes), answerbox_t, sync_box_link);
    611614               
    612615                list_remove(&box->sync_box_link);
     
    743746#endif
    744747       
    745         link_t *cur;
    746        
    747748        printf(" --- incomming calls ---\n");
    748         for (cur = task->answerbox.calls.next; cur != &task->answerbox.calls;
    749             cur = cur->next) {
     749        list_foreach(task->answerbox.calls, cur) {
    750750                call_t *call = list_get_instance(cur, call_t, link);
    751751               
     
    767767       
    768768        printf(" --- dispatched calls ---\n");
    769         for (cur = task->answerbox.dispatched_calls.next;
    770             cur != &task->answerbox.dispatched_calls;
    771             cur = cur->next) {
     769        list_foreach(task->answerbox.dispatched_calls, cur) {
    772770                call_t *call = list_get_instance(cur, call_t, link);
    773771               
     
    789787       
    790788        printf(" --- incoming answers ---\n");
    791         for (cur = task->answerbox.answers.next;
    792             cur != &task->answerbox.answers;
    793             cur = cur->next) {
     789        list_foreach(task->answerbox.answers, cur) {
    794790                call_t *call = list_get_instance(cur, call_t, link);
    795791               
  • kernel/generic/src/ipc/ipcrsc.c

    r98caf49 r55b77d9  
    146146call_t *get_call(sysarg_t callid)
    147147{
    148         link_t *lst;
    149148        call_t *result = NULL;
    150149       
    151150        irq_spinlock_lock(&TASK->answerbox.lock, true);
    152         for (lst = TASK->answerbox.dispatched_calls.next;
    153             lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
     151       
     152        list_foreach(TASK->answerbox.dispatched_calls, lst) {
    154153                call_t *call = list_get_instance(lst, call_t, link);
    155154                if ((sysarg_t) call == callid) {
  • kernel/generic/src/ipc/irq.c

    r98caf49 r55b77d9  
    200200       
    201201        hash_table_insert(&irq_uspace_hash_table, key, &irq->link);
    202         list_append(&irq->notif_cfg.link, &box->irq_head);
     202        list_append(&irq->notif_cfg.link, &box->irq_list);
    203203       
    204204        irq_spinlock_unlock(&box->irq_lock, false);
     
    282282        irq_spinlock_lock(&box->irq_lock, false);
    283283       
    284         while (box->irq_head.next != &box->irq_head) {
     284        while (!list_empty(&box->irq_list)) {
    285285                DEADLOCK_PROBE_INIT(p_irqlock);
    286286               
    287                 irq_t *irq = list_get_instance(box->irq_head.next, irq_t,
     287                irq_t *irq = list_get_instance(list_first(&box->irq_list), irq_t,
    288288                    notif_cfg.link);
    289289               
  • kernel/generic/src/mm/as.c

    r98caf49 r55b77d9  
    9494 *
    9595 * This lock protects:
    96  * - inactive_as_with_asid_head list
     96 * - inactive_as_with_asid_list
    9797 * - as->asid for each as of the as_t type
    9898 * - asids_allocated counter
     
    105105 * that have valid ASID.
    106106 */
    107 LIST_INITIALIZE(inactive_as_with_asid_head);
     107LIST_INITIALIZE(inactive_as_with_asid_list);
    108108
    109109/** Kernel address space. */
     
    235235        bool cond = true;
    236236        while (cond) {
    237                 ASSERT(!list_empty(&as->as_area_btree.leaf_head));
     237                ASSERT(!list_empty(&as->as_area_btree.leaf_list));
    238238               
    239239                btree_node_t *node =
    240                     list_get_instance(as->as_area_btree.leaf_head.next,
     240                    list_get_instance(list_first(&as->as_area_btree.leaf_list),
    241241                    btree_node_t, leaf_link);
    242242               
     
    602602                bool cond = true;
    603603                while (cond) {
    604                         ASSERT(!list_empty(&area->used_space.leaf_head));
     604                        ASSERT(!list_empty(&area->used_space.leaf_list));
    605605                       
    606606                        btree_node_t *node =
    607                             list_get_instance(area->used_space.leaf_head.prev,
     607                            list_get_instance(list_last(&area->used_space.leaf_list),
    608608                            btree_node_t, leaf_link);
    609609                       
     
    727727        if (--sh_info->refcount == 0) {
    728728                dealloc = true;
    729                 link_t *cur;
    730729               
    731730                /*
     
    733732                 * reference from all frames found there.
    734733                 */
    735                 for (cur = sh_info->pagemap.leaf_head.next;
    736                     cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
     734                list_foreach(sh_info->pagemap.leaf_list, cur) {
    737735                        btree_node_t *node
    738736                            = list_get_instance(cur, btree_node_t, leaf_link);
     
    786784         * Visit only the pages mapped by used_space B+tree.
    787785         */
    788         link_t *cur;
    789         for (cur = area->used_space.leaf_head.next;
    790             cur != &area->used_space.leaf_head; cur = cur->next) {
     786        list_foreach(area->used_space.leaf_list, cur) {
    791787                btree_node_t *node;
    792788                btree_key_t i;
     
    10651061         */
    10661062        size_t used_pages = 0;
    1067         link_t *cur;
    1068        
    1069         for (cur = area->used_space.leaf_head.next;
    1070             cur != &area->used_space.leaf_head; cur = cur->next) {
     1063       
     1064        list_foreach(area->used_space.leaf_list, cur) {
    10711065                btree_node_t *node
    10721066                    = list_get_instance(cur, btree_node_t, leaf_link);
     
    10941088        size_t frame_idx = 0;
    10951089       
    1096         for (cur = area->used_space.leaf_head.next;
    1097             cur != &area->used_space.leaf_head; cur = cur->next) {
     1090        list_foreach(area->used_space.leaf_list, cur) {
    10981091                btree_node_t *node = list_get_instance(cur, btree_node_t,
    10991092                    leaf_link);
     
    11471140        frame_idx = 0;
    11481141       
    1149         for (cur = area->used_space.leaf_head.next;
    1150             cur != &area->used_space.leaf_head; cur = cur->next) {
     1142        list_foreach(area->used_space.leaf_list, cur) {
    11511143                btree_node_t *node
    11521144                    = list_get_instance(cur, btree_node_t, leaf_link);
     
    13341326                       
    13351327                        list_append(&old_as->inactive_as_with_asid_link,
    1336                             &inactive_as_with_asid_head);
     1328                            &inactive_as_with_asid_list);
    13371329                }
    13381330               
     
    20272019       
    20282020        /* Eventually check the addresses behind each area */
    2029         link_t *cur;
    2030         for (cur = AS->as_area_btree.leaf_head.next;
    2031             (ret == 0) && (cur != &AS->as_area_btree.leaf_head);
    2032             cur = cur->next) {
     2021        list_foreach(AS->as_area_btree.leaf_list, cur) {
     2022                if (ret != 0)
     2023                        break;
     2024
    20332025                btree_node_t *node =
    20342026                    list_get_instance(cur, btree_node_t, leaf_link);
     
    20722064       
    20732065        size_t area_cnt = 0;
    2074         link_t *cur;
    2075        
    2076         for (cur = as->as_area_btree.leaf_head.next;
    2077             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     2066       
     2067        list_foreach(as->as_area_btree.leaf_list, cur) {
    20782068                btree_node_t *node =
    20792069                    list_get_instance(cur, btree_node_t, leaf_link);
     
    20882078        size_t area_idx = 0;
    20892079       
    2090         for (cur = as->as_area_btree.leaf_head.next;
    2091             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     2080        list_foreach(as->as_area_btree.leaf_list, cur) {
    20922081                btree_node_t *node =
    20932082                    list_get_instance(cur, btree_node_t, leaf_link);
     
    21252114       
    21262115        /* Print out info about address space areas */
    2127         link_t *cur;
    2128         for (cur = as->as_area_btree.leaf_head.next;
    2129             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     2116        list_foreach(as->as_area_btree.leaf_list, cur) {
    21302117                btree_node_t *node
    21312118                    = list_get_instance(cur, btree_node_t, leaf_link);
  • kernel/generic/src/mm/backend_anon.c

    r98caf49 r55b77d9  
    9797void anon_share(as_area_t *area)
    9898{
    99         link_t *cur;
    100 
    10199        ASSERT(mutex_locked(&area->as->lock));
    102100        ASSERT(mutex_locked(&area->lock));
     
    106104         */
    107105        mutex_lock(&area->sh_info->lock);
    108         for (cur = area->used_space.leaf_head.next;
    109             cur != &area->used_space.leaf_head; cur = cur->next) {
     106        list_foreach(area->used_space.leaf_list, cur) {
    110107                btree_node_t *node;
    111108                unsigned int i;
  • kernel/generic/src/mm/backend_elf.c

    r98caf49 r55b77d9  
    139139         */
    140140        if (area->flags & AS_AREA_WRITE) {
    141                 node = list_get_instance(area->used_space.leaf_head.next,
     141                node = list_get_instance(list_first(&area->used_space.leaf_list),
    142142                    btree_node_t, leaf_link);
    143143        } else {
     
    153153         */
    154154        mutex_lock(&area->sh_info->lock);
    155         for (cur = &node->leaf_link; cur != &area->used_space.leaf_head;
     155        for (cur = &node->leaf_link; cur != &area->used_space.leaf_list.head;
    156156            cur = cur->next) {
    157157                unsigned int i;
  • kernel/generic/src/mm/buddy.c

    r98caf49 r55b77d9  
    8282         * Use memory after our own structure.
    8383         */
    84         b->order = (link_t *) (&b[1]);
     84        b->order = (list_t *) (&b[1]);
    8585       
    8686        for (i = 0; i <= max_order; i++)
     
    176176         * the request can be immediatelly satisfied.
    177177         */
    178         if (!list_empty(&b->order[i])) {
    179                 res = b->order[i].next;
     178        res = list_first(&b->order[i]);
     179        if (res != NULL) {
    180180                list_remove(res);
    181181                b->op->mark_busy(b, res);
  • kernel/generic/src/mm/slab.c

    r98caf49 r55b77d9  
    317317                spinlock_lock(&cache->slablock);
    318318        } else {
    319                 slab = list_get_instance(cache->partial_slabs.next, slab_t,
    320                     link);
     319                slab = list_get_instance(list_first(&cache->partial_slabs),
     320                    slab_t, link);
    321321                list_remove(&slab->link);
    322322        }
     
    360360        if (!list_empty(&cache->magazines)) {
    361361                if (first)
    362                         cur = cache->magazines.next;
     362                        cur = list_first(&cache->magazines);
    363363                else
    364                         cur = cache->magazines.prev;
     364                        cur = list_last(&cache->magazines);
    365365               
    366366                mag = list_get_instance(cur, slab_magazine_t, link);
     
    812812       
    813813        size_t frames = 0;
    814         link_t *cur;
    815         for (cur = slab_cache_list.next; cur != &slab_cache_list;
    816             cur = cur->next) {
     814        list_foreach(slab_cache_list, cur) {
    817815                slab_cache_t *cache = list_get_instance(cur, slab_cache_t, link);
    818816                frames += _slab_reclaim(cache, flags);
     
    861859                link_t *cur;
    862860                size_t i;
    863                 for (i = 0, cur = slab_cache_list.next;
    864                     (i < skip) && (cur != &slab_cache_list);
     861                for (i = 0, cur = slab_cache_list.head.next;
     862                    (i < skip) && (cur != &slab_cache_list.head);
    865863                    i++, cur = cur->next);
    866864               
    867                 if (cur == &slab_cache_list) {
     865                if (cur == &slab_cache_list.head) {
    868866                        irq_spinlock_unlock(&slab_cache_lock, true);
    869867                        break;
     
    940938        irq_spinlock_lock(&slab_cache_lock, false);
    941939       
    942         link_t *cur;
    943         for (cur = slab_cache_list.next; cur != &slab_cache_list;
    944             cur = cur->next) {
     940        list_foreach(slab_cache_list, cur) {
    945941                slab_cache_t *slab = list_get_instance(cur, slab_cache_t, link);
    946942                if ((slab->flags & SLAB_CACHE_MAGDEFERRED) !=
  • kernel/generic/src/proc/scheduler.c

    r98caf49 r55b77d9  
    237237                 * Take the first thread from the queue.
    238238                 */
    239                 thread_t *thread =
    240                     list_get_instance(CPU->rq[i].rq_head.next, thread_t, rq_link);
     239                thread_t *thread = list_get_instance(
     240                    list_first(&CPU->rq[i].rq), thread_t, rq_link);
    241241                list_remove(&thread->rq_link);
    242242               
     
    273273static void relink_rq(int start)
    274274{
    275         link_t head;
    276        
    277         list_initialize(&head);
     275        list_t list;
     276       
     277        list_initialize(&list);
    278278        irq_spinlock_lock(&CPU->lock, false);
    279279       
     
    284284                       
    285285                        irq_spinlock_lock(&CPU->rq[i + 1].lock, false);
    286                         list_concat(&head, &CPU->rq[i + 1].rq_head);
     286                        list_concat(&list, &CPU->rq[i + 1].rq);
    287287                        size_t n = CPU->rq[i + 1].n;
    288288                        CPU->rq[i + 1].n = 0;
     
    292292                       
    293293                        irq_spinlock_lock(&CPU->rq[i].lock, false);
    294                         list_concat(&CPU->rq[i].rq_head, &head);
     294                        list_concat(&CPU->rq[i].rq, &list);
    295295                        CPU->rq[i].n += n;
    296296                        irq_spinlock_unlock(&CPU->rq[i].lock, false);
     
    616616                       
    617617                        /* Search rq from the back */
    618                         link_t *link = cpu->rq[rq].rq_head.prev;
    619                        
    620                         while (link != &(cpu->rq[rq].rq_head)) {
     618                        link_t *link = cpu->rq[rq].rq.head.prev;
     619                       
     620                        while (link != &(cpu->rq[rq].rq.head)) {
    621621                                thread = (thread_t *) list_get_instance(link,
    622622                                    thread_t, rq_link);
     
    740740                       
    741741                        printf("\trq[%u]: ", i);
    742                         link_t *cur;
    743                         for (cur = cpus[cpu].rq[i].rq_head.next;
    744                             cur != &(cpus[cpu].rq[i].rq_head);
    745                             cur = cur->next) {
    746                                 thread_t *thread = list_get_instance(cur, thread_t, rq_link);
     742                        list_foreach(cpus[cpu].rq[i].rq, cur) {
     743                                thread_t *thread = list_get_instance(cur,
     744                                    thread_t, rq_link);
    747745                                printf("%" PRIu64 "(%s) ", thread->tid,
    748746                                    thread_states[thread->state]);
  • kernel/generic/src/proc/task.c

    r98caf49 r55b77d9  
    155155        mutex_initialize(&task->futexes_lock, MUTEX_PASSIVE);
    156156       
    157         list_initialize(&task->th_head);
    158         list_initialize(&task->sync_box_head);
     157        list_initialize(&task->threads);
     158        list_initialize(&task->sync_boxes);
    159159       
    160160        ipc_answerbox_init(&task->answerbox, task);
     
    435435       
    436436        /* Current values of threads */
    437         link_t *cur;
    438         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
     437        list_foreach(task->threads, cur) {
    439438                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    440439               
     
    468467         */
    469468       
    470         link_t *cur;
    471         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
     469        list_foreach(task->threads, cur) {
    472470                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    473471                bool sleeping = false;
  • kernel/generic/src/proc/thread.c

    r98caf49 r55b77d9  
    260260         */
    261261       
    262         list_append(&thread->rq_link, &cpu->rq[i].rq_head);
     262        list_append(&thread->rq_link, &cpu->rq[i].rq);
    263263        cpu->rq[i].n++;
    264264        irq_spinlock_unlock(&(cpu->rq[i].lock), true);
     
    423423                atomic_inc(&task->lifecount);
    424424       
    425         list_append(&thread->th_link, &task->th_head);
     425        list_append(&thread->th_link, &task->threads);
    426426       
    427427        irq_spinlock_pass(&task->lock, &threads_lock);
  • kernel/generic/src/synch/futex.c

    r98caf49 r55b77d9  
    272272void futex_cleanup(void)
    273273{
    274         link_t *cur;
    275        
    276274        mutex_lock(&futex_ht_lock);
    277275        mutex_lock(&TASK->futexes_lock);
    278276
    279         for (cur = TASK->futexes.leaf_head.next;
    280             cur != &TASK->futexes.leaf_head; cur = cur->next) {
     277        list_foreach(TASK->futexes.leaf_list, cur) {
    281278                btree_node_t *node;
    282279                unsigned int i;
  • kernel/generic/src/synch/waitq.c

    r98caf49 r55b77d9  
    6969{
    7070        irq_spinlock_initialize(&wq->lock, "wq.lock");
    71         list_initialize(&wq->head);
     71        list_initialize(&wq->sleepers);
    7272        wq->missed_wakeups = 0;
    7373}
     
    196196        irq_spinlock_lock(&wq->lock, true);
    197197       
    198         if (!list_empty(&wq->head)) {
    199                 thread_t *thread = list_get_instance(wq->head.next, thread_t, wq_link);
     198        if (!list_empty(&wq->sleepers)) {
     199                thread_t *thread = list_get_instance(list_first(&wq->sleepers),
     200                    thread_t, wq_link);
    200201               
    201202                irq_spinlock_lock(&thread->lock, false);
     
    407408        }
    408409       
    409         list_append(&THREAD->wq_link, &wq->head);
     410        list_append(&THREAD->wq_link, &wq->sleepers);
    410411       
    411412        /*
     
    464465       
    465466loop:
    466         if (list_empty(&wq->head)) {
     467        if (list_empty(&wq->sleepers)) {
    467468                wq->missed_wakeups++;
    468469                if ((count) && (mode == WAKEUP_ALL))
     
    473474       
    474475        count++;
    475         thread_t *thread = list_get_instance(wq->head.next, thread_t, wq_link);
     476        thread_t *thread = list_get_instance(list_first(&wq->sleepers),
     477            thread_t, wq_link);
    476478       
    477479        /*
  • kernel/generic/src/sysinfo/stats.c

    r98caf49 r55b77d9  
    173173       
    174174        /* Walk the B+ tree and count pages */
    175         link_t *cur;
    176         for (cur = as->as_area_btree.leaf_head.next;
    177             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     175        list_foreach(as->as_area_btree.leaf_list, cur) {
    178176                btree_node_t *node =
    179177                    list_get_instance(cur, btree_node_t, leaf_link);
     
    218216       
    219217        /* Walk the B+ tree and count pages */
    220         link_t *cur;
    221         for (cur = as->as_area_btree.leaf_head.next;
    222             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     218        list_foreach(as->as_area_btree.leaf_list, cur) {
    223219                btree_node_t *node =
    224220                    list_get_instance(cur, btree_node_t, leaf_link);
  • kernel/generic/src/time/clock.c

    r98caf49 r55b77d9  
    163163               
    164164                link_t *cur;
    165                 while ((cur = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
    166                         timeout_t *timeout = list_get_instance(cur, timeout_t, link);
     165                while ((cur = list_first(&CPU->timeout_active_list)) != NULL) {
     166                        timeout_t *timeout = list_get_instance(cur, timeout_t,
     167                            link);
    167168                       
    168169                        irq_spinlock_lock(&timeout->lock, false);
  • kernel/generic/src/time/timeout.c

    r98caf49 r55b77d9  
    5454{
    5555        irq_spinlock_initialize(&CPU->timeoutlock, "cpu.timeoutlock");
    56         list_initialize(&CPU->timeout_active_head);
     56        list_initialize(&CPU->timeout_active_list);
    5757}
    5858
     
    119119        timeout_t *target = NULL;
    120120        link_t *cur;
    121         for (cur = CPU->timeout_active_head.next;
    122             cur != &CPU->timeout_active_head; cur = cur->next) {
     121        for (cur = CPU->timeout_active_list.head.next;
     122            cur != &CPU->timeout_active_list.head; cur = cur->next) {
    123123                target = list_get_instance(cur, timeout_t, link);
    124124                irq_spinlock_lock(&target->lock, false);
     
    135135        /* Avoid using cur->prev directly */
    136136        link_t *prev = cur->prev;
    137         list_prepend(&timeout->link, prev);
     137        list_insert_after(&timeout->link, prev);
    138138       
    139139        /*
     
    146146         * Decrease ticks of timeout's immediate succesor by timeout->ticks.
    147147         */
    148         if (cur != &CPU->timeout_active_head) {
     148        if (cur != &CPU->timeout_active_list.head) {
    149149                irq_spinlock_lock(&target->lock, false);
    150150                target->ticks -= timeout->ticks;
     
    184184        /*
    185185         * Now we know for sure that timeout hasn't been activated yet
    186          * and is lurking in timeout->cpu->timeout_active_head queue.
     186         * and is lurking in timeout->cpu->timeout_active_list.
    187187         */
    188188       
    189189        link_t *cur = timeout->link.next;
    190         if (cur != &timeout->cpu->timeout_active_head) {
     190        if (cur != &timeout->cpu->timeout_active_list.head) {
    191191                timeout_t *tmp = list_get_instance(cur, timeout_t, link);
    192192                irq_spinlock_lock(&tmp->lock, false);
  • kernel/generic/src/udebug/udebug.c

    r98caf49 r55b77d9  
    406406       
    407407        /* Finish debugging of all userspace threads */
    408         link_t *cur;
    409         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
     408        list_foreach(task->threads, cur) {
    410409                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    411410               
  • kernel/generic/src/udebug/udebug_ops.c

    r98caf49 r55b77d9  
    196196        /* Set udebug.active on all of the task's userspace threads. */
    197197       
    198         link_t *cur;
    199         for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
     198        list_foreach(TASK->threads, cur) {
    200199                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    201200               
     
    390389       
    391390        /* FIXME: make sure the thread isn't past debug shutdown... */
    392         link_t *cur;
    393         for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
     391        list_foreach(TASK->threads, cur) {
    394392                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    395393               
Note: See TracChangeset for help on using the changeset viewer.