reactos/ntoskrnl/ex/list.c

   1 /* $Id: list.c,v 1.2 2000/10/07 13:41:50 dwelch 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
 141 STDCALL
 142 ExInterlockedPopEntrySList (
 143         PSLIST_HEADER   ListHead,
 144         PKSPIN_LOCK     Lock
 145         )
 146 {
 147    UNIMPLEMENTED;
 148 }
 149
 150
 151 PSINGLE_LIST_ENTRY
 152 STDCALL
 153 ExInterlockedPushEntrySList (
 154         PSLIST_HEADER           ListHead,
 155         PSINGLE_LIST_ENTRY      ListEntry,
 156         PKSPIN_LOCK             Lock
 157         )
 158 {
 159    UNIMPLEMENTED;
 160 }
 161
 162
 163 PSINGLE_LIST_ENTRY
 164 STDCALL
 165 ExInterlockedPopEntryList (
 166         PSINGLE_LIST_ENTRY      ListHead,
 167         PKSPIN_LOCK             Lock
 168         )
 169 {
 170    PSINGLE_LIST_ENTRY ret;
 171    KIRQL oldlvl;
 172
 173    KeAcquireSpinLock(Lock,&oldlvl);
 174    ret = PopEntryList(ListHead);
 175    KeReleaseSpinLock(Lock,oldlvl);
 176    return(ret);
 177 }
 178
 179
 180 PSINGLE_LIST_ENTRY
 181 STDCALL
 182 ExInterlockedPushEntryList (
 183         PSINGLE_LIST_ENTRY      ListHead,
 184         PSINGLE_LIST_ENTRY      ListEntry,
 185         PKSPIN_LOCK             Lock
 186         )
 187 {
 188    KIRQL oldlvl;
 189    PSINGLE_LIST_ENTRY ret;
 190
 191    KeAcquireSpinLock(Lock,&oldlvl);
 192    ret=ListHead->Next;
 193    PushEntryList(ListHead,ListEntry);
 194    KeReleaseSpinLock(Lock,oldlvl);
 195    return(ret);
 196 }
 197
 198 /* EOF */