← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to include/linux/list.h

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/linux/list.h
4
4
#include <linux/types.h>
5
5
#include <linux/stddef.h>
6
6
#include <linux/poison.h>
7
 
#include <linux/prefetch.h>
 
7
#include <linux/const.h>
8
8
 
9
9
/*
10
10
 * Simple doubly linked list implementation.
367
367
 * @head:       the head for your list.
368
368
 */
369
369
#define list_for_each(pos, head) \
370
 
        for (pos = (head)->next; prefetch(pos->next), pos != (head); \
371
 
                pos = pos->next)
 
370
        for (pos = (head)->next; pos != (head); pos = pos->next)
372
371
 
373
372
/**
374
373
 * __list_for_each      -       iterate over a list
375
374
 * @pos:        the &struct list_head to use as a loop cursor.
376
375
 * @head:       the head for your list.
377
376
 *
378
 
 * This variant differs from list_for_each() in that it's the
379
 
 * simplest possible list iteration code, no prefetching is done.
380
 
 * Use this for code that knows the list to be very short (empty
381
 
 * or 1 entry) most of the time.
 
377
 * This variant doesn't differ from list_for_each() any more.
 
378
 * We don't do prefetching in either case.
382
379
 */
383
380
#define __list_for_each(pos, head) \
384
381
        for (pos = (head)->next; pos != (head); pos = pos->next)
389
386
 * @head:       the head for your list.
390
387
 */
391
388
#define list_for_each_prev(pos, head) \
392
 
        for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
393
 
                pos = pos->prev)
 
389
        for (pos = (head)->prev; pos != (head); pos = pos->prev)
394
390
 
395
391
/**
396
392
 * list_for_each_safe - iterate over a list safe against removal of list entry
410
406
 */
411
407
#define list_for_each_prev_safe(pos, n, head) \
412
408
        for (pos = (head)->prev, n = pos->prev; \
413
 
             prefetch(pos->prev), pos != (head); \
 
409
             pos != (head); \
414
410
             pos = n, n = pos->prev)
415
411
 
416
412
/**
421
417
 */
422
418
#define list_for_each_entry(pos, head, member)                          \
423
419
        for (pos = list_entry((head)->next, typeof(*pos), member);      \
424
 
             prefetch(pos->member.next), &pos->member != (head);        \
 
420
             &pos->member != (head);    \
425
421
             pos = list_entry(pos->member.next, typeof(*pos), member))
426
422
 
427
423
/**
432
428
 */
433
429
#define list_for_each_entry_reverse(pos, head, member)                  \
434
430
        for (pos = list_entry((head)->prev, typeof(*pos), member);      \
435
 
             prefetch(pos->member.prev), &pos->member != (head);        \
 
431
             &pos->member != (head);    \
436
432
             pos = list_entry(pos->member.prev, typeof(*pos), member))
437
433
 
438
434
/**
457
453
 */
458
454
#define list_for_each_entry_continue(pos, head, member)                 \
459
455
        for (pos = list_entry(pos->member.next, typeof(*pos), member);  \
460
 
             prefetch(pos->member.next), &pos->member != (head);        \
 
456
             &pos->member != (head);    \
461
457
             pos = list_entry(pos->member.next, typeof(*pos), member))
462
458
 
463
459
/**
471
467
 */
472
468
#define list_for_each_entry_continue_reverse(pos, head, member)         \
473
469
        for (pos = list_entry(pos->member.prev, typeof(*pos), member);  \
474
 
             prefetch(pos->member.prev), &pos->member != (head);        \
 
470
             &pos->member != (head);    \
475
471
             pos = list_entry(pos->member.prev, typeof(*pos), member))
476
472
 
477
473
/**
483
479
 * Iterate over list of given type, continuing from current position.
484
480
 */
485
481
#define list_for_each_entry_from(pos, head, member)                     \
486
 
        for (; prefetch(pos->member.next), &pos->member != (head);      \
 
482
        for (; &pos->member != (head);  \
487
483
             pos = list_entry(pos->member.next, typeof(*pos), member))
488
484
 
489
485
/**
664
660
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
665
661
 
666
662
#define hlist_for_each(pos, head) \
667
 
        for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
668
 
             pos = pos->next)
 
663
        for (pos = (head)->first; pos ; pos = pos->next)
669
664
 
670
665
#define hlist_for_each_safe(pos, n, head) \
671
666
        for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
680
675
 */
681
676
#define hlist_for_each_entry(tpos, pos, head, member)                    \
682
677
        for (pos = (head)->first;                                        \
683
 
             pos && ({ prefetch(pos->next); 1;}) &&                      \
 
678
             pos &&                                                      \
684
679
                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
685
680
             pos = pos->next)
686
681
 
692
687
 */
693
688
#define hlist_for_each_entry_continue(tpos, pos, member)                 \
694
689
        for (pos = (pos)->next;                                          \
695
 
             pos && ({ prefetch(pos->next); 1;}) &&                      \
 
690
             pos &&                                                      \
696
691
                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
697
692
             pos = pos->next)
698
693
 
703
698
 * @member:     the name of the hlist_node within the struct.
704
699
 */
705
700
#define hlist_for_each_entry_from(tpos, pos, member)                     \
706
 
        for (; pos && ({ prefetch(pos->next); 1;}) &&                    \
 
701
        for (; pos &&                                                    \
707
702
                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
708
703
             pos = pos->next)
709
704