reactos/ntoskrnl/ex/list.c

   1 /* $Id: list.c,v 1.3 2001/06/20 19:59:35 ekohl Exp $
   2  *
   3  * COPYRIGHT:           See COPYING in the top level directory
   4  * PROJECT:             ReactOS kernel
   5  * FILE:                ntoskrnl/ex/list.c
   6  * PURPOSE:             Manages double linked lists, single linked lists and
   7  *                      sequenced lists
   8  * PROGRAMMER:          David Welch (welch@mcmail.com)
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ddk/ntddk.h>
  14
  15 #define NDEBUG
  16 #include <internal/debug.h>
  17
  18 /* FUNCTIONS *************************************************************/
  19
  20
  21 PLIST_ENTRY STDCALL
  22 ExInterlockedInsertHeadList (
  23         PLIST_ENTRY     ListHead,
  24         PLIST_ENTRY     ListEntry,
  25         PKSPIN_LOCK     Lock
  26         )
  27 /*
  28  * FUNCTION: Inserts an entry at the head of a doubly linked list
  29  * ARGUMENTS:
  30  *          ListHead = Points to the head of the list
  31  *          ListEntry = Points to the entry to be inserted
  32  *          Lock = Caller supplied spinlock used to synchronise access
  33  * RETURNS: The previous head of the list
  34  */
  35 {
  36    PLIST_ENTRY Old;
  37    KIRQL oldlvl;
  38
  39    KeAcquireSpinLock(Lock,&oldlvl);
  40    if (IsListEmpty(ListHead))
  41      {
  42         Old = NULL;
  43      }
  44    else
  45      {
  46         Old = ListHead->Flink;
  47      }
  48    InsertHeadList(ListHead,ListEntry);
  49    KeReleaseSpinLock(Lock,oldlvl);
  50
  51    return(Old);
  52 }
  53
  54
  55 PLIST_ENTRY STDCALL
  56 ExInterlockedInsertTailList (
  57         PLIST_ENTRY     ListHead,
  58         PLIST_ENTRY     ListEntry,
  59         PKSPIN_LOCK     Lock
  60         )
  61 {
  62    PLIST_ENTRY Old;
  63    KIRQL oldlvl;
  64
  65    KeAcquireSpinLock(Lock,&oldlvl);
  66    if (IsListEmpty(ListHead))
  67      {
  68         Old = NULL;
  69      }
  70    else
  71      {
  72         Old = ListHead->Blink;
  73      }
  74    InsertTailList(ListHead,ListEntry);
  75    KeReleaseSpinLock(Lock,oldlvl);
  76
  77    return(Old);
  78 }
  79
  80
  81 PLIST_ENTRY STDCALL
  82 ExInterlockedRemoveHeadList (
  83         PLIST_ENTRY     Head,
  84         PKSPIN_LOCK     Lock
  85         )
  86 /*
  87  * FUNCTION: Removes the head of a double linked list
  88  * ARGUMENTS:
  89  *          Head = List head
  90  *          Lock = Lock for synchronizing access to the list
  91  * RETURNS: The removed entry
  92  */
  93 {
  94    PLIST_ENTRY ret;
  95    KIRQL oldlvl;
  96
  97    KeAcquireSpinLock(Lock,&oldlvl);
  98    if (IsListEmpty(Head))
  99      {
 100         ret = NULL;
 101      }
 102    else
 103      {
 104         ret = RemoveHeadList(Head);
 105      }
 106    KeReleaseSpinLock(Lock,oldlvl);
 107    return(ret);
 108 }
 109
 110 PLIST_ENTRY
 111 ExInterlockedRemoveTailList (
 112         PLIST_ENTRY     Head,
 113         PKSPIN_LOCK     Lock
 114         )
 115 /*
 116  * FUNCTION: Removes the tail of a double linked list
 117  * ARGUMENTS:
 118  *          Head = List head
 119  *          Lock = Lock for synchronizing access to the list
 120  * RETURNS: The removed entry
 121  */
 122 {
 123    PLIST_ENTRY ret;
 124    KIRQL oldlvl;
 125
 126    KeAcquireSpinLock(Lock,&oldlvl);
 127    if (IsListEmpty(Head))
 128      {
 129         ret = NULL;
 130      }
 131    else
 132      {
 133         ret = RemoveTailList(Head);
 134      }
 135    KeReleaseSpinLock(Lock,oldlvl);
 136    return(ret);
 137 }
 138
 139
 140 PSINGLE_LIST_ENTRY FASTCALL
 141 ExInterlockedPopEntrySList(PSLIST_HEADER ListHead,
 142                            PKSPIN_LOCK Lock)
 143 {
 144    UNIMPLEMENTED;
 145 }
 146
 147
 148 PSINGLE_LIST_ENTRY FASTCALL
 149 ExInterlockedPushEntrySList(PSLIST_HEADER ListHead,
 150                             PSINGLE_LIST_ENTRY ListEntry,
 151                             PKSPIN_LOCK Lock)
 152 {
 153    UNIMPLEMENTED;
 154 }
 155
 156
 157 PSINGLE_LIST_ENTRY
 158 STDCALL
 159 ExInterlockedPopEntryList (
 160         PSINGLE_LIST_ENTRY      ListHead,
 161         PKSPIN_LOCK             Lock
 162         )
 163 {
 164    PSINGLE_LIST_ENTRY ret;
 165    KIRQL oldlvl;
 166
 167    KeAcquireSpinLock(Lock,&oldlvl);
 168    ret = PopEntryList(ListHead);
 169    KeReleaseSpinLock(Lock,oldlvl);
 170    return(ret);
 171 }
 172
 173
 174 PSINGLE_LIST_ENTRY
 175 STDCALL
 176 ExInterlockedPushEntryList (
 177         PSINGLE_LIST_ENTRY      ListHead,
 178         PSINGLE_LIST_ENTRY      ListEntry,
 179         PKSPIN_LOCK             Lock
 180         )
 181 {
 182    KIRQL oldlvl;
 183    PSINGLE_LIST_ENTRY ret;
 184
 185    KeAcquireSpinLock(Lock,&oldlvl);
 186    ret=ListHead->Next;
 187    PushEntryList(ListHead,ListEntry);
 188    KeReleaseSpinLock(Lock,oldlvl);
 189    return(ret);
 190 }
 191
 192 /* EOF */