Changeset feeac0d in mainline for kernel/generic


Ignore:
Timestamp:
2013-09-10T16:32:35Z (12 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4982d87
Parents:
e8d6ce2
Message:

Simplify use of list_foreach.

Location:
kernel/generic
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    re8d6ce2 rfeeac0d  
    6767        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
    6868
    69 #define list_foreach(list, iterator) \
    70         for (link_t *iterator = (list).head.next; \
    71             iterator != &(list).head; iterator = iterator->next)
     69#define list_foreach(list, member, itype, iterator) \
     70        for (itype *iterator = NULL; iterator == NULL; iterator =(itype *)1) \
     71            for (link_t *_link = (list).head.next; \
     72            iterator = list_get_instance(_link, itype, member), \
     73            _link != &(list).head; _link = _link->next)
    7274
    7375#define assert_link_not_used(link) \
    … …  
    184186 * @return Head item of the list.
    185187 * @return NULL if the list is empty.
    186  *
    187188 */
    188189static inline link_t *list_first(const list_t *list)
    … …  
    197198 * @return Head item of the list.
    198199 * @return NULL if the list is empty.
    199  *
    200200 */
    201201static inline link_t *list_last(list_t *list)
    202202{
    203203        return ((list->head.prev == &list->head) ? NULL : list->head.prev);
     204}
     205
     206/** Get next item in list.
     207 *
     208 * @param link Current item link
     209 * @param list List containing @a link
     210 *
     211 * @return Next item or NULL if @a link is the last item.
     212 */
     213static inline link_t *list_next(link_t *link, const list_t *list)
     214{
     215        return (link->next == &list->head) ? NULL : link->next;
     216}
     217
     218/** Get previous item in list.
     219 *
     220 * @param link Current item link
     221 * @param list List containing @a link
     222 *
     223 * @return Previous item or NULL if @a link is the first item.
     224 */
     225static inline link_t *list_prev(link_t *link, const list_t *list)
     226{
     227        return (link->prev == &list->head) ? NULL : link->prev;
    204228}
    205229
    … …  
    270294{
    271295        unsigned int cnt = 0;
    272        
    273         list_foreach(*list, link) {
     296        link_t *link;
     297       
     298        link = list_first(list);
     299        while (link != NULL) {
    274300                if (cnt == n)
    275301                        return link;
    276302               
    277303                cnt++;
     304                link = list_next(link, list);
    278305        }
    279306       

  • kernel/generic/src/adt/btree.c

    re8d6ce2 rfeeac0d  
    10311031       
    10321032        printf("Printing list of leaves:\n");
    1033         list_foreach(t->leaf_list, cur) {
    1034                 btree_node_t *node;
    1035                
    1036                 node = list_get_instance(cur, btree_node_t, leaf_link);
    1037                
     1033        list_foreach(t->leaf_list, leaf_link, btree_node_t, node) {
    10381034                ASSERT(node);
    10391035               

  • kernel/generic/src/adt/hash_table.c

    re8d6ce2 rfeeac0d  
    117117        ASSERT(chain < h->entries);
    118118       
    119         list_foreach(h->entry[chain], cur) {
     119        link_t *cur = list_first(&h->entry[chain]);
     120        while (cur != NULL) {
    120121                if (h->op->compare(key, h->max_keys, cur)) {
    121122                        /*
    … …  
    124125                        return cur;
    125126                }
     127                cur = list_next(cur, &h->entry[chain]);
    126128        }
    127129       

  • kernel/generic/src/adt/list.c

    re8d6ce2 rfeeac0d  
    101101        unsigned int count = 0;
    102102       
    103         list_foreach(*list, link) {
     103        link_t *link = list_first(list);
     104        while (link != NULL) {
    104105                count++;
     106                link = list_next(link, list);
    105107        }
    106108       

  • kernel/generic/src/console/cmd.c

    re8d6ce2 rfeeac0d  
    656656       
    657657        size_t len = 0;
    658         list_foreach(cmd_list, cur) {
    659                 cmd_info_t *hlp;
    660                 hlp = list_get_instance(cur, cmd_info_t, link);
    661                
     658        list_foreach(cmd_list, link, cmd_info_t, hlp) {
    662659                spinlock_lock(&hlp->lock);
    663660                if (str_length(hlp->name) > len)
    … …  
    672669        }
    673670       
    674         list_foreach(cmd_list, cur) {
    675                 cmd_info_t *hlp;
    676                 hlp = list_get_instance(cur, cmd_info_t, link);
    677                
     671        list_foreach(cmd_list, link, cmd_info_t, hlp) {
    678672                spinlock_lock(&hlp->lock);
    679673                printf("%-*s %s\n", _len, hlp->name, hlp->description);
    … …  
    912906        spinlock_lock(&cmd_lock);
    913907       
    914         list_foreach(cmd_list, cur) {
    915                 cmd_info_t *hlp;
    916                
    917                 hlp = list_get_instance(cur, cmd_info_t, link);
     908        list_foreach(cmd_list, link, cmd_info_t, hlp) {
    918909                spinlock_lock(&hlp->lock);
    919910               

  • kernel/generic/src/console/console.c

    re8d6ce2 rfeeac0d  
    125125static void stdout_write(outdev_t *dev, wchar_t ch)
    126126{
    127         list_foreach(dev->list, cur) {
    128                 outdev_t *sink = list_get_instance(cur, outdev_t, link);
     127        list_foreach(dev->list, link, outdev_t, sink) {
    129128                if ((sink) && (sink->op->write))
    130129                        sink->op->write(sink, ch);
    … …  
    134133static void stdout_redraw(outdev_t *dev)
    135134{
    136         list_foreach(dev->list, cur) {
    137                 outdev_t *sink = list_get_instance(cur, outdev_t, link);
     135        list_foreach(dev->list, link, outdev_t, sink) {
    138136                if ((sink) && (sink->op->redraw))
    139137                        sink->op->redraw(sink);

  • kernel/generic/src/console/kconsole.c

    re8d6ce2 rfeeac0d  
    118118         * Make sure the command is not already listed.
    119119         */
    120         list_foreach(cmd_list, cur) {
    121                 cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
    122                
     120        list_foreach(cmd_list, link, cmd_info_t, hlp) {
    123121                if (hlp == cmd) {
    124122                        /* The command is already there. */
    … …  
    612610        cmd_info_t *cmd = NULL;
    613611       
    614         list_foreach(cmd_list, cur) {
    615                 cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
     612        list_foreach(cmd_list, link, cmd_info_t, hlp) {
    616613                spinlock_lock(&hlp->lock);
    617614               

  • kernel/generic/src/ipc/ipc.c

    re8d6ce2 rfeeac0d  
    774774static void ipc_print_call_list(list_t *list)
    775775{
    776         list_foreach(*list, cur) {
    777                 call_t *call = list_get_instance(cur, call_t, ab_link);
    778                
     776        list_foreach(*list, ab_link, call_t, call) {
    779777#ifdef __32_BITS__
    780778                printf("%10p ", call);

  • kernel/generic/src/ipc/ipcrsc.c

    re8d6ce2 rfeeac0d  
    151151        irq_spinlock_lock(&TASK->answerbox.lock, true);
    152152       
    153         list_foreach(TASK->answerbox.dispatched_calls, lst) {
    154                 call_t *call = list_get_instance(lst, call_t, ab_link);
     153        list_foreach(TASK->answerbox.dispatched_calls, ab_link, call_t, call) {
    155154                if ((sysarg_t) call == callid) {
    156155                        result = call;

  • kernel/generic/src/lib/ra.c

    re8d6ce2 rfeeac0d  
    391391
    392392        irq_spinlock_lock(&arena->lock, true);
    393         list_foreach(arena->spans, cur) {
    394                 ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
    395 
     393        list_foreach(arena->spans, span_link, ra_span_t, span) {
    396394                base = ra_span_alloc(span, size, alignment);
    397395                if (base)
    … …  
    407405{
    408406        irq_spinlock_lock(&arena->lock, true);
    409         list_foreach(arena->spans, cur) {
    410                 ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
    411 
     407        list_foreach(arena->spans, span_link, ra_span_t, span) {
    412408                if (iswithin(span->base, span->size, base, size)) {
    413409                        ra_span_free(span, base, size);

  • kernel/generic/src/mm/as.c

    re8d6ce2 rfeeac0d  
    488488       
    489489        /* Eventually check the addresses behind each area */
    490         list_foreach(as->as_area_btree.leaf_list, cur) {
    491                 btree_node_t *node =
    492                     list_get_instance(cur, btree_node_t, leaf_link);
     490        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t, node) {
    493491               
    494492                for (btree_key_t i = 0; i < node->keys; i++) {
    … …  
    904902                 * reference from all frames found there.
    905903                 */
    906                 list_foreach(sh_info->pagemap.leaf_list, cur) {
    907                         btree_node_t *node
    908                             = list_get_instance(cur, btree_node_t, leaf_link);
     904                list_foreach(sh_info->pagemap.leaf_list, leaf_link,
     905                    btree_node_t, node) {
    909906                        btree_key_t i;
    910907                       
    … …  
    956953         * Visit only the pages mapped by used_space B+tree.
    957954         */
    958         list_foreach(area->used_space.leaf_list, cur) {
    959                 btree_node_t *node;
     955        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
     956            node) {
    960957                btree_key_t i;
    961958               
    962                 node = list_get_instance(cur, btree_node_t, leaf_link);
    963959                for (i = 0; i < node->keys; i++) {
    964960                        uintptr_t ptr = node->key[i];
    … …  
    12381234        size_t used_pages = 0;
    12391235       
    1240         list_foreach(area->used_space.leaf_list, cur) {
    1241                 btree_node_t *node
    1242                     = list_get_instance(cur, btree_node_t, leaf_link);
     1236        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
     1237            node) {
    12431238                btree_key_t i;
    12441239               
    … …  
    12641259        size_t frame_idx = 0;
    12651260       
    1266         list_foreach(area->used_space.leaf_list, cur) {
    1267                 btree_node_t *node = list_get_instance(cur, btree_node_t,
    1268                     leaf_link);
     1261        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
     1262            node) {
    12691263                btree_key_t i;
    12701264               
    … …  
    13161310        frame_idx = 0;
    13171311       
    1318         list_foreach(area->used_space.leaf_list, cur) {
    1319                 btree_node_t *node
    1320                     = list_get_instance(cur, btree_node_t, leaf_link);
     1312        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
     1313            node) {
    13211314                btree_key_t i;
    13221315               
    … …  
    21822175        size_t area_cnt = 0;
    21832176       
    2184         list_foreach(as->as_area_btree.leaf_list, cur) {
    2185                 btree_node_t *node =
    2186                     list_get_instance(cur, btree_node_t, leaf_link);
     2177        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
     2178            node) {
    21872179                area_cnt += node->keys;
    21882180        }
    … …  
    21952187        size_t area_idx = 0;
    21962188       
    2197         list_foreach(as->as_area_btree.leaf_list, cur) {
    2198                 btree_node_t *node =
    2199                     list_get_instance(cur, btree_node_t, leaf_link);
     2189        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
     2190            node) {
    22002191                btree_key_t i;
    22012192               
    … …  
    22312222       
    22322223        /* Print out info about address space areas */
    2233         list_foreach(as->as_area_btree.leaf_list, cur) {
    2234                 btree_node_t *node
    2235                     = list_get_instance(cur, btree_node_t, leaf_link);
     2224        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
     2225            node) {
    22362226                btree_key_t i;
    22372227               

  • kernel/generic/src/mm/backend_anon.c

    re8d6ce2 rfeeac0d  
    118118         */
    119119        mutex_lock(&area->sh_info->lock);
    120         list_foreach(area->used_space.leaf_list, cur) {
    121                 btree_node_t *node;
     120        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
     121            node) {
    122122                unsigned int i;
    123123               
    124                 node = list_get_instance(cur, btree_node_t, leaf_link);
    125124                for (i = 0; i < node->keys; i++) {
    126125                        uintptr_t base = node->key[i];

  • kernel/generic/src/mm/slab.c

    re8d6ce2 rfeeac0d  
    810810       
    811811        size_t frames = 0;
    812         list_foreach(slab_cache_list, cur) {
    813                 slab_cache_t *cache = list_get_instance(cur, slab_cache_t, link);
     812        list_foreach(slab_cache_list, link, slab_cache_t, cache) {
    814813                frames += _slab_reclaim(cache, flags);
    815814        }
    … …  
    936935        irq_spinlock_lock(&slab_cache_lock, false);
    937936       
    938         list_foreach(slab_cache_list, cur) {
    939                 slab_cache_t *slab = list_get_instance(cur, slab_cache_t, link);
     937        list_foreach(slab_cache_list, link, slab_cache_t, slab) {
    940938                if ((slab->flags & SLAB_CACHE_MAGDEFERRED) !=
    941939                    SLAB_CACHE_MAGDEFERRED)

  • kernel/generic/src/proc/scheduler.c

    re8d6ce2 rfeeac0d  
    739739                       
    740740                        printf("\trq[%u]: ", i);
    741                         list_foreach(cpus[cpu].rq[i].rq, cur) {
    742                                 thread_t *thread = list_get_instance(cur,
    743                                     thread_t, rq_link);
     741                        list_foreach(cpus[cpu].rq[i].rq, rq_link, thread_t,
     742                            thread) {
    744743                                printf("%" PRIu64 "(%s) ", thread->tid,
    745744                                    thread_states[thread->state]);

  • kernel/generic/src/proc/task.c

    re8d6ce2 rfeeac0d  
    452452       
    453453        /* Current values of threads */
    454         list_foreach(task->threads, cur) {
    455                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
    456                
     454        list_foreach(task->threads, th_link, thread_t, thread) {
    457455                irq_spinlock_lock(&thread->lock, false);
    458456               
    … …  
    484482         */
    485483       
    486         list_foreach(task->threads, cur) {
    487                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
     484        list_foreach(task->threads, th_link, thread_t, thread) {
    488485                bool sleeping = false;
    489486               

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

    re8d6ce2 rfeeac0d  
    274274        mutex_lock(&TASK->futexes_lock);
    275275
    276         list_foreach(TASK->futexes.leaf_list, cur) {
    277                 btree_node_t *node;
     276        list_foreach(TASK->futexes.leaf_list, leaf_link, btree_node_t, node) {
    278277                unsigned int i;
    279278               
    280                 node = list_get_instance(cur, btree_node_t, leaf_link);
    281279                for (i = 0; i < node->keys; i++) {
    282280                        futex_t *ftx;

  • kernel/generic/src/sysinfo/stats.c

    re8d6ce2 rfeeac0d  
    175175       
    176176        /* Walk the B+ tree and count pages */
    177         list_foreach(as->as_area_btree.leaf_list, cur) {
    178                 btree_node_t *node =
    179                     list_get_instance(cur, btree_node_t, leaf_link);
    180                
     177        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
     178            node) {
    181179                unsigned int i;
    182180                for (i = 0; i < node->keys; i++) {
    … …  
    218216       
    219217        /* Walk the B+ tree and count pages */
    220         list_foreach(as->as_area_btree.leaf_list, cur) {
    221                 btree_node_t *node =
    222                     list_get_instance(cur, btree_node_t, leaf_link);
    223                
     218        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t, node) {
    224219                unsigned int i;
    225220                for (i = 0; i < node->keys; i++) {

  • kernel/generic/src/udebug/udebug.c

    re8d6ce2 rfeeac0d  
    406406       
    407407        /* Finish debugging of all userspace threads */
    408         list_foreach(task->threads, cur) {
    409                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
    410                
     408        list_foreach(task->threads, th_link, thread_t, thread) {
    411409                mutex_lock(&thread->udebug.lock);
    412410               

  • kernel/generic/src/udebug/udebug_ops.c

    re8d6ce2 rfeeac0d  
    196196        /* Set udebug.active on all of the task's userspace threads. */
    197197       
    198         list_foreach(TASK->threads, cur) {
    199                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
    200                
     198        list_foreach(TASK->threads, th_link, thread_t, thread) {
    201199                mutex_lock(&thread->udebug.lock);
    202200                if (thread->uspace) {
    … …  
    389387       
    390388        /* FIXME: make sure the thread isn't past debug shutdown... */
    391         list_foreach(TASK->threads, cur) {
    392                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
    393                
     389        list_foreach(TASK->threads, th_link, thread_t, thread) {
    394390                irq_spinlock_lock(&thread->lock, false);
    395391                bool uspace = thread->uspace;
Note: See TracChangeset for help on using the changeset viewer.