Changeset 55b77d9 in mainline for kernel/generic/src


Ignore:
Timestamp:
2011-06-17T20:39:16Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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/generic/src
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • 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.