reactos/ntoskrnl/mm/region.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001, 2002 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id: region.c,v 1.3 2002/09/08 10:23:36 chorns Exp $
  20  *
  21  * PROJECT:     ReactOS kernel
  22  * FILE:        ntoskrnl/mm/region.c
  23  * PROGRAMMER:  David Welch
  24  * PURPOSE:
  25  */
  26
  27 /* INCLUDE *****************************************************************/
  28
  29 #include <ddk/ntddk.h>
  30 #include <internal/mm.h>
  31 #include <internal/ob.h>
  32 #include <internal/io.h>
  33 #include <internal/ps.h>
  34 #include <internal/pool.h>
  35 #include <ntos/minmax.h>
  36
  37 #define NDEBUG
  38 #include <internal/debug.h>
  39
  40 /* GLOBALS *******************************************************************/
  41
  42 #define TAG_MM_REGION    TAG('M', 'R', 'G', 'N')
  43
  44 /* FUNCTIONS *****************************************************************/
  45
  46 VOID STATIC
  47 InsertAfterEntry(PLIST_ENTRY Previous,
  48                  PLIST_ENTRY Entry)
  49 /*
  50  * FUNCTION: Insert a list entry after another entry in the list
  51  */
  52 {
  53    Previous->Flink->Blink = Entry;
  54
  55    Entry->Flink = Previous->Flink;
  56    Entry->Blink = Previous;
  57
  58    Previous->Flink = Entry;
  59 }
  60
  61 PMM_REGION STATIC
  62 MmSplitRegion(PMM_REGION InitialRegion, PVOID InitialBaseAddress,
  63               PVOID StartAddress, ULONG Length, ULONG NewType,
  64               ULONG NewProtect, PMADDRESS_SPACE AddressSpace,
  65               PMM_ALTER_REGION_FUNC AlterFunc)
  66 {
  67   PMM_REGION NewRegion1;
  68   PMM_REGION NewRegion2;
  69   ULONG InternalLength;
  70
  71   /* Allocate this in front otherwise the failure case is too difficult. */
  72   NewRegion2 = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_REGION),
  73                                      TAG_MM_REGION);
  74   if (NewRegion2 == NULL)
  75     {
  76       return(NULL);
  77     }
  78
  79   /* Create the new region. */
  80   NewRegion1 = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_REGION),
  81                                      TAG_MM_REGION);
  82   if (NewRegion1 == NULL)
  83     {
  84       ExFreePool(NewRegion2);
  85       return(NULL);
  86     }
  87   NewRegion1->Type = NewType;
  88   NewRegion1->Protect = NewProtect;
  89   InternalLength = (InitialBaseAddress + InitialRegion->Length) - StartAddress;
  90   InternalLength = min(InternalLength, Length);
  91   NewRegion1->Length = InternalLength;
  92   InsertAfterEntry(&InitialRegion->RegionListEntry,
  93                    &NewRegion1->RegionListEntry);
  94
  95   /*
  96    * Call our helper function to do the changes on the addresses contained
  97    * in the initial region.
  98    */
  99   AlterFunc(AddressSpace, StartAddress, InternalLength, InitialRegion->Type,
 100             InitialRegion->Protect, NewType, NewProtect);
 101
 102   /*
 103    * If necessary create a new region for the portion of the initial region
 104    * beyond the range of addresses to alter.
 105    */
 106   if ((InitialBaseAddress + InitialRegion->Length) > (StartAddress + Length))
 107     {
 108       NewRegion2->Type = InitialRegion->Type;
 109       NewRegion2->Protect = InitialRegion->Protect;
 110       NewRegion2->Length = (InitialBaseAddress + InitialRegion->Length) -
 111         (StartAddress + Length);
 112       InsertAfterEntry(&NewRegion1->RegionListEntry,
 113                        &NewRegion2->RegionListEntry);
 114     }
 115   else
 116     {
 117       ExFreePool(NewRegion2);
 118     }
 119
 120   /* Either remove or shrink the initial region. */
 121   if (InitialBaseAddress == StartAddress)
 122     {
 123       RemoveEntryList(&InitialRegion->RegionListEntry);
 124       ExFreePool(InitialRegion);
 125     }
 126   else
 127     {
 128       InitialRegion->Length = StartAddress - InitialBaseAddress;
 129     }
 130
 131   return(NewRegion1);
 132 }
 133
 134 NTSTATUS
 135 MmAlterRegion(PMADDRESS_SPACE AddressSpace, PVOID BaseAddress,
 136               PLIST_ENTRY RegionListHead, PVOID StartAddress, ULONG Length,
 137               ULONG NewType, ULONG NewProtect, PMM_ALTER_REGION_FUNC AlterFunc)
 138 {
 139   PMM_REGION InitialRegion;
 140   PVOID InitialBaseAddress;
 141   PMM_REGION NewRegion;
 142   PLIST_ENTRY CurrentEntry;
 143   PMM_REGION CurrentRegion;
 144   PVOID CurrentBaseAddress;
 145   ULONG RemainingLength;
 146
 147   /*
 148    * Find the first region containing part of the range of addresses to
 149    * be altered.
 150    */
 151   InitialRegion = MmFindRegion(BaseAddress, RegionListHead, StartAddress,
 152                                &InitialBaseAddress);
 153   if ((StartAddress + Length) >
 154       (InitialBaseAddress + InitialRegion->Length))
 155     {
 156       RemainingLength = (StartAddress + Length) -
 157         (InitialBaseAddress + InitialRegion->Length);
 158     }
 159   else
 160     {
 161       RemainingLength = 0;
 162     }
 163   /*
 164    * If necessary then split the region into the affected and unaffected parts.
 165    */
 166   if (InitialRegion->Type != NewType || InitialRegion->Protect != NewProtect)
 167     {
 168       NewRegion = MmSplitRegion(InitialRegion, InitialBaseAddress,
 169                                 StartAddress, Length, NewType, NewProtect,
 170                                 AddressSpace, AlterFunc);
 171       if (NewRegion == NULL)
 172         {
 173           return(STATUS_NO_MEMORY);
 174         }
 175     }
 176   else
 177     {
 178       NewRegion = InitialRegion;
 179     }
 180
 181   /*
 182    * Free any complete regions that are containing in the range of addresses
 183    * and call the helper function to actually do the changes.
 184    */
 185   CurrentEntry = NewRegion->RegionListEntry.Flink;
 186   CurrentBaseAddress = StartAddress + NewRegion->Length;
 187   while (RemainingLength > 0 && CurrentRegion->Length <= RemainingLength)
 188     {
 189       CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION,
 190                                         RegionListEntry);
 191       CurrentEntry = CurrentEntry->Flink;
 192       if (CurrentRegion->Type != NewType &&
 193           CurrentRegion->Protect != NewProtect)
 194         {
 195           AlterFunc(AddressSpace, CurrentBaseAddress, CurrentRegion->Length,
 196                     CurrentRegion->Type, CurrentRegion->Protect,
 197                     NewType, NewProtect);
 198         }
 199       CurrentBaseAddress += CurrentRegion->Length;
 200       NewRegion->Length += CurrentRegion->Length;
 201       RemainingLength -= CurrentRegion->Length;
 202       RemoveEntryList(&CurrentRegion->RegionListEntry);
 203       ExFreePool(CurrentRegion);
 204     }
 205
 206   /*
 207    * Split any final region.
 208    */
 209   if (RemainingLength > 0)
 210     {
 211       CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION,
 212                                         RegionListEntry);
 213       if (CurrentRegion->Type != NewType &&
 214           CurrentRegion->Protect != NewProtect)
 215         {
 216           AlterFunc(AddressSpace, CurrentBaseAddress, CurrentRegion->Length,
 217                     CurrentRegion->Type, CurrentRegion->Protect,
 218                     NewType, NewProtect);
 219         }
 220       NewRegion->Length += RemainingLength;
 221       CurrentRegion->Length -= RemainingLength;
 222     }
 223
 224   /*
 225    * If the region after the new region has the same type then merge them.
 226    */
 227   if (NewRegion->RegionListEntry.Flink != RegionListHead)
 228     {
 229       CurrentEntry = NewRegion->RegionListEntry.Flink;
 230       CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION,
 231                                         RegionListEntry);
 232       if (CurrentRegion->Type == NewRegion->Type &&
 233           CurrentRegion->Protect == NewRegion->Protect)
 234         {
 235           NewRegion->Length += CurrentRegion->Length;
 236           RemoveEntryList(&CurrentRegion->RegionListEntry);
 237           ExFreePool(CurrentRegion);
 238         }
 239     }
 240
 241   /*
 242    * If the region before the new region has the same type then merge them.
 243    */
 244   if (NewRegion->RegionListEntry.Blink != RegionListHead)
 245     {
 246       CurrentEntry = NewRegion->RegionListEntry.Blink;
 247       CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION,
 248                                         RegionListEntry);
 249       if (CurrentRegion->Type == NewRegion->Type &&
 250           CurrentRegion->Protect == NewRegion->Protect)
 251         {
 252           NewRegion->Length += CurrentRegion->Length;
 253           RemoveEntryList(&CurrentRegion->RegionListEntry);
 254           ExFreePool(CurrentRegion);
 255         }
 256     }
 257
 258   return(STATUS_SUCCESS);
 259 }
 260
 261 VOID
 262 MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
 263                    ULONG Protect)
 264 {
 265   PMM_REGION Region;
 266
 267   Region = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_REGION),
 268                                  TAG_MM_REGION);
 269   Region->Type = Type;
 270   Region->Protect = Protect;
 271   Region->Length = Length;
 272   InitializeListHead(RegionListHead);
 273   InsertHeadList(RegionListHead, &Region->RegionListEntry);
 274 }
 275
 276 PMM_REGION
 277 MmFindRegion(PVOID BaseAddress, PLIST_ENTRY RegionListHead, PVOID Address,
 278              PVOID* RegionBaseAddress)
 279 {
 280   PLIST_ENTRY current_entry;
 281   PMM_REGION current;
 282   PVOID StartAddress = BaseAddress;
 283
 284   current_entry = RegionListHead->Flink;
 285   while (current_entry != RegionListHead)
 286     {
 287       current = CONTAINING_RECORD(current_entry, MM_REGION, RegionListEntry);
 288
 289       if (StartAddress <= Address &&
 290           (StartAddress + current->Length) > Address)
 291         {
 292           if (RegionBaseAddress != NULL)
 293             {
 294               *RegionBaseAddress = StartAddress;
 295             }
 296           return(current);
 297         }
 298
 299       current_entry = current_entry->Flink;
 300       StartAddress += current->Length;
 301     }
 302   return(NULL);
 303 }