/* -*- Mode: C; tab-width: 4; indent-tabs-mode: 't; c-basic-offset: 4 -*-
*
* Name : $RCSfile: mmap.c $
*
* Copyright : 2001,2002 by Imagination Technologies Limited.
* All rights reserved.
* No part of this software, either material or conceptual
* may be copied or distributed, transmitted, transcribed,
* stored in a retrieval system or translated into any
* human or computer language in any form by any means,
* electronic, mechanical, manual or other-wise, or
* disclosed to third parties without the express written
* permission of:
* Imagination Technologies Limited,
* HomePark Industrial Estate,
* Kings Langley,
* Hertfordshire,
* WD4 8LZ,
* UK
*
* Description : Linux mmap interface
*
* Version : $Revision: 1.28 $
*
**********************************************************************/
#include <linux/version.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/wrapper.h>
#include <linux/slab.h>
#include <asm/io.h>
#include "virtmem.h"
#include "mmap.h"
#include "debug.h"
#include "hostfunc.h"
#ifdef SUPPORT_AGP
#include <linux/agp_backend.h>
/* external data */
extern int agpInitialized; /* have we setup agp? */
extern agp_kern_info agpInfo; /* agp bridge information */
#endif
#if HAVE_VMA == 1
#define VMA(vma) vma##,
#else
#define VMA(vma)
#endif
/* Prototypes */
static void AllocateTable();
static PKV_OFFSET_STRUCT FindAllocRec(unsigned long nOffset);
static PKV_OFFSET_STRUCT FindRegisteredArea(void *pkvAddress, unsigned long nLength);
/* Imported prototype from linux/hostfunc.c */
unsigned long ConvertLinToPhys(unsigned long LinAddr);
/* Device operation */
int pvr_mmap(struct file* pFile, struct vm_area_struct* ps_vma);
/* VM area operations */
void pvr_mmap_vopen(struct vm_area_struct* ps_vma);
void pvr_mmap_vclose(struct vm_area_struct* ps_vma);
/* Page fault handler */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
unsigned long pvr_mmap_vmmap(struct vm_area_struct* ps_vma, unsigned long dwAddress, int iAccess);
#else
struct page* pvr_mmap_vmmap(struct vm_area_struct* ps_vma, unsigned long dwAddress, int iAccess);
#endif
/* Memory operation structures */
static struct vm_operations_struct pvr_mmap_vmops =
{
open: pvr_mmap_vopen,
close: pvr_mmap_vclose,
nopage: pvr_mmap_vmmap
};
/* Static variables */
PKV_OFFSET_LOCKED_STRUCT psKVOffsetStruct=0;
static PKV_OFFSET_STRUCT psKVOffsetTable=0;
static PKV_OFFSET_STRUCT psNextAllocRec;
static unsigned long nNextOffset = 0;
/* Space to store a record of the offset table vmalloc info. */
static VIRT_ALLOC_REC OffsetTableAllocRec;
static inline pgprot_t pgprot_noncached(pgprot_t _prot)
{
unsigned long prot = pgprot_val(_prot);
#if defined(__i386__)
/* On PPro and successors, PCD alone doesn't always mean
uncached because of interactions with the MTRRs. PCD | PWT
means definitely uncached. */
if (boot_cpu_data.x86 > 3)
prot |= _PAGE_PCD | _PAGE_PWT;
#elif defined(ARM)
prot &= ~(L_PTE_CACHEABLE | L_PTE_BUFFERABLE);
#else
#error "mmap.c - pgprot_noncached - Unknown architecture."
#endif
return __pgprot(prot);
}
static unsigned pvr_map_block(struct vm_area_struct *ps_vma,
unsigned long dstAddr, unsigned long srcAddr,
unsigned long nBytes)
{
/* Attempt to remap contiguous page range */
int dwResult;
if (ps_vma->vm_flags & VM_IO)
{
dwResult = io_remap_page_range (
/*#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,7)*/
VMA(ps_vma)
/*#endif*/
dstAddr,
srcAddr,
nBytes,
ps_vma->vm_page_prot
);
#if 0
DPF("mmap.c - pvr_mmap: Mapped contiguous IO range.\n", nOffset);
#endif
}
else
{
dwResult = remap_page_range (
/*#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,7)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20))*/
VMA(ps_vma)
/*#endif*/
dstAddr,
srcAddr,
nBytes,
ps_vma->vm_page_prot
);
#if 0
DPF("mmap.c - pvr_mmap: Mapped contiguous RAM range.\n", nOffset);
#endif
}
return dwResult;
}
int pvr_mmap(struct file* pFile, struct vm_area_struct* ps_vma)
{
unsigned long nOffset, nBytes;
PKV_OFFSET_STRUCT psCurrentRec;
struct list_head *ptr = 0;
struct pvrProcRecord *processEntry = 0;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
nOffset = ps_vma->vm_offset;
#else
nOffset = ps_vma->vm_pgoff << PAGE_SHIFT;
#endif
if (nOffset & ~PAGE_MASK)
{
DPF("mmap.c - pvr_mmap : Error - offset not aligned: 0x%08X\n", nOffset);
return -ENXIO;
}
if (!nOffset && (ps_vma->vm_flags & VM_WRITE))
{
DPF("mmap.c - pvr_mmap : Error - writeable mapping to zero\n");
return -ENXIO;
}
nBytes = ps_vma->vm_end - ps_vma->vm_start;
/* Only support shared writeable mappings */
if (
(ps_vma->vm_flags & VM_WRITE) &&
!(ps_vma->vm_flags & VM_SHARED)
)
{
DPF("mmap.c - pvr_mmap : Error - Cannot mmap non-shareable writable areas.\n");
return -ENXIO;
}
/* Set IO flag for non-memory regions */
if ((nOffset >= __pa(high_memory)) || (pFile->f_flags & O_SYNC))
{
ps_vma->vm_flags |= VM_IO;
}
/* Do not allow this area to be swapped out */
#if 0 /* Original example used LOCKED, but RESERVED seems to be preferred */
ps_vma->vm_flags |= VM_LOCKED;
#endif
ps_vma->vm_flags |= VM_RESERVED;
/* Look up the entry in the allocation table */
psCurrentRec=FindAllocRec(nOffset);
ps_vma->vm_private_data = (void *)psCurrentRec;
if (psCurrentRec)
{
if (!psCurrentRec->bCached)
ps_vma->vm_page_prot = pgprot_noncached(ps_vma->vm_page_prot);
/* Determine whether this area is contiguous */
if ((psCurrentRec->eMapType == PVR_MMAP_CONTIG) ||
(psCurrentRec->eMapType == PVR_MMAP_AGP_SCATTER))
{
unsigned dwResult=0;
if (psCurrentRec->eMapType == PVR_MMAP_CONTIG)
{
unsigned long addr = psCurrentRec->pPhysAddr + (nOffset - psCurrentRec->nOffset);
dwResult = pvr_map_block(ps_vma, ps_vma->vm_start, addr, nBytes);
}
else
{
/* map in all the aperature blocks */
agp_memory *tmp;
unsigned long pg_offset = 0;
unsigned long addr = agpInfo.aper_base + (nOffset - psCurrentRec->nOffset);
LINBUFSTRUCT *pLinBufStruct = (LINBUFSTRUCT *)psCurrentRec->pkvPageAlignedAddress;
for (tmp = (agp_memory*)pLinBufStruct->pAGPList; tmp != NULL; tmp = tmp->next)
{
dwResult |= pvr_map_block(ps_vma,
ps_vma->vm_start + PAGE_SIZE * pg_offset,
addr + tmp->pg_start * PAGE_SIZE,
PAGE_SIZE * tmp->page_count);
pg_offset += tmp->page_count;
}
}
if (dwResult != 0)
{
DPF("mmap.c - pvr_mmap: Error - Failed to map contiguous pages.\n");
return -ENXIO;
}
else
{
/* Install the ops to make sure that the module count is maintained */
ps_vma->vm_ops = &pvr_mmap_vmops;
#if 0
DPF("mmap.c - pvr_mmap: Installed page fault handler.\n", nOffset);
#endif
}
}
else
{
/* Install a page fault handler */
ps_vma->vm_ops = &pvr_mmap_vmops;
}
}
else
{
DPF("mmap.c - pvr_mmap: Error - Attempted to mmap unregistered area at offset 0x%08X\n.\n", nOffset);
return -ENXIO;
}
/* Call the open routine to increment the usage count */
pvr_mmap_vopen(ps_vma);
DPF("mmap.c - pvr_mmap: Mapped area at offset 0x%08X\n", nOffset);
for (ptr = pvrProcList.next; ptr != &pvrProcList; ptr = ptr->next)
{
processEntry = list_entry(ptr, struct pvrProcRecord, list);
if (processEntry->pid == current->pid)
{
struct pvrMMAPRecord *mmapEntry;
mmapEntry = kmalloc(sizeof(struct pvrMMAPRecord), GFP_KERNEL);
mmapEntry->userAddress = ps_vma->vm_start;
mmapEntry->length = nBytes;
mmapEntry->kernelAddress = psCurrentRec->pkvPageAlignedAddress;
list_add_tail(&mmapEntry->list, &processEntry->mmapList);
break;
}
}
return 0;
}
void pvr_mmap_vopen(struct vm_area_struct* ps_vma)
{
static unsigned long nOpenCount = 0;
++nOpenCount;
DPF("Incrementing mmap use count. Call count: %lu\n", nOpenCount);
MOD_INC_USE_COUNT;
}
void pvr_mmap_vclose(struct vm_area_struct* ps_vma)
{
static unsigned long nCloseCount = 0;
++nCloseCount;
DPF("Decrementing mmap use count. Call count: %lu\n", nCloseCount);
#if 0 /* DEBUGGING START */
{
/* Determine the start address of the vma */
unsigned long dwAddress = ps_vma->vm_start;
/* Look for a corresponding mmap entry */
PKV_OFFSET_STRUCT psRec = FindRegisteredArea(dwAddress, sizeof(unsigned long));
if (psRec)
{
DPF("pvr_mmap_vclose: Offset 0x%08X matched kvaddr: 0x%08X\n", psRec->nOffset, dwAddress);
}
else
{
DPF("pvr_mmap_vclose: Failed to find offset table entry for kvaddr: 0x%08X\n", dwAddress);
}
}
#endif /* DEBUGGING END */
MOD_DEC_USE_COUNT;
}
/* The page fault handler has a different prototype for Kernels < 2.4 */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
unsigned long pvr_mmap_vmmap(struct vm_area_struct* ps_vma, unsigned long dwAddress, int iAccess)
#else
struct page* pvr_mmap_vmmap(struct vm_area_struct* ps_vma, unsigned long dwAddress, int iAccess)
#endif
{
unsigned long nOffset;
unsigned long nVirtAddress;
PKV_OFFSET_STRUCT psCurrentRec;
struct page *pPage;
/* Calculate the offset within the vmalloc allocation */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
nOffset = dwAddress - ps_vma->vm_start + ps_vma->vm_offset;
#else
nOffset = dwAddress - ps_vma->vm_start + (ps_vma->vm_pgoff<<PAGE_SHIFT);
#endif
/* Find the corresponding allocation record */
psCurrentRec = (PKV_OFFSET_STRUCT)ps_vma->vm_private_data;
if (psCurrentRec)
{
if (psCurrentRec->eMapType == PVR_MMAP_SCATTER)
{
LINBUFSTRUCT *pLinBufStruct = (LINBUFSTRUCT *)psCurrentRec->pkvPageAlignedAddress;
unsigned long pageIndex = (nOffset - psCurrentRec->nOffset)/PAGE_SIZE;
if (pageIndex < pLinBufStruct->dwPagesCommitted)
nVirtAddress = pLinBufStruct->pageList[pageIndex];
else
nVirtAddress = 0;
DPF("pvr_mmap SCATTER index %d nVirtAddress %08X phys %08X (%08X - %08X)\n",
pageIndex, nVirtAddress, virt_to_bus(nVirtAddress), *(unsigned long *)nVirtAddress,
*((unsigned long *)nVirtAddress+1));
pPage = virt_to_page(nVirtAddress);
}
else
{
nVirtAddress = psCurrentRec->pkvPageAlignedAddress +
(nOffset - psCurrentRec->nOffset);
/* Convert Kernel Virtual address to page */
pPage = ConvertKVToPage(nVirtAddress);
}
}
else
{
DPF("mmap.c - pvr_mmap_vmmap: Error - Failed to find allocation record.\n");
pPage = 0;
}
/* Check for a valid translation */
if (pPage == 0UL)
{
DPF("mmap.c - pvr_mmap_vmmap: Error - Page fault out of range.\n");
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
return 0UL;
#else
return pPage;
#endif
}
DPF("mmap.c - pvr_mmap_vmmap: Page fault handled for offset: 0x%08X (KSeg: 0x%08X)\n", nOffset, nVirtAddress);
/* Note that we don't do a get_page() here, as the pages we're
* mapping in have the reserve bit set. On such pages linux
* will not drop the ref count during the unmap (see
* __free_pages in linux/mm/page_alloc.c), so we ended up
* leaking all the pages mapped through the nopage mapper. */
return pPage;
}
/*
// pvr_mmap_register_area - registers an area in the offset table
*/
void pvr_mmap_register_area(void* pkvArea, unsigned long nBytes,
PVR_MMAP_TYPE eMapType, unsigned long bCached)
{
if (psKVOffsetTable==0)
{
AllocateTable();
}
if (psKVOffsetTable && (FindRegisteredArea(pkvArea, nBytes)==0))
{
if ((eMapType == PVR_MMAP_SCATTER) || (eMapType == PVR_MMAP_AGP_SCATTER))
psNextAllocRec->pkvPageAlignedAddress = (unsigned long)pkvArea;
else
psNextAllocRec->pkvPageAlignedAddress = (unsigned long)pkvArea & PAGE_MASK;
psNextAllocRec->nLength = (nBytes + PAGE_SIZE-1) & PAGE_MASK;
psNextAllocRec->eMapType = eMapType;
psNextAllocRec->bCached = bCached;
psNextAllocRec->nOffset = nNextOffset;
if (eMapType == PVR_MMAP_CONTIG)
psNextAllocRec->pPhysAddr = ConvertLinToPhys((unsigned long)pkvArea & PAGE_MASK);
else
psNextAllocRec->pPhysAddr = 0;
#if 0 /* DEBUG START */
DPF("pvr_mmap_register_area: Virt:0x%08lX, Offset:0x%08lX, Length:0x%08lX\n",
psNextAllocRec->pkvPageAlignedAddress, psNextAllocRec->nOffset, psNextAllocRec->nLength);
DPF("Area registered at entry: %d\n",
((unsigned long)psNextAllocRec-(unsigned long)psKVOffsetTable)/sizeof(KV_OFFSET_STRUCT));
#endif /* DEBUG END */
nNextOffset += psNextAllocRec->nLength + PAGE_SIZE;
++psNextAllocRec;
/* Terminate table */
psNextAllocRec->nOffset = 0;
}
}
/*
// pvr_mmap_remove_registered_area - Removes an area from the offset table
*/
void pvr_mmap_remove_registered_area(void* pkvMemArea)
{
int bSuccess = FALSE;
int i, j;
unsigned long nMaxOffset = 0;
int nMaxOffsetIndex = 0;
if (psKVOffsetTable)
{
for (i=0; i==0 || (psKVOffsetTable[i].nOffset != 0); ++i)
{
if (psKVOffsetTable[i].pkvPageAlignedAddress == (unsigned long)pkvMemArea)
{
/* Found record - overwrite it with the last one in the table */
PKV_OFFSET_STRUCT psLastRecord = psNextAllocRec - 1;
#if 0 /* DEBUG START */
DPF("pvr_mmap_remove_registered_area: Virt:0x%08lX, Offset:0x%08lX, Length:0x%08lX\n",
psKVOffsetTable[i].pkvPageAlignedAddress, psKVOffsetTable[i].nOffset, psKVOffsetTable[i].nLength);
#endif /* DEBUG END */
/* look for record with highest offset */
for (j=0; (j==0) || (psKVOffsetTable[j].nOffset != 0); j++)
{
if (psKVOffsetTable[j].nOffset > nMaxOffset)
{
nMaxOffset = psKVOffsetTable[j].nOffset;
nMaxOffsetIndex = j;
}
}
/* if deleting the highest offset entry, reduce the running offset */
if (i == nMaxOffsetIndex)
{
/* look for record with highest offset (other than us) */
nMaxOffset = 0;
nMaxOffsetIndex = 0;
for (j=0; (j==0) || (psKVOffsetTable[j].nOffset != 0); j++)
{
unsigned long offset = psKVOffsetTable[j].nOffset;
if ((i != j) && (offset > nMaxOffset))
{
nMaxOffset = offset;
nMaxOffsetIndex = j;
}
}
if (i)
nNextOffset =
psKVOffsetTable[nMaxOffsetIndex].nOffset +
psKVOffsetTable[nMaxOffsetIndex].nLength +
PAGE_SIZE;
else
nNextOffset = 0;
}
if (psLastRecord != &psKVOffsetTable[i])
{
/* Copy the last record over the one to be deleted */
psKVOffsetTable[i] = *psLastRecord;
}
/* Erase the last record */
psLastRecord->nOffset = 0;
psLastRecord->pkvPageAlignedAddress = 0;
psLastRecord->nLength = 0;
psLastRecord->pPhysAddr = 0;
psLastRecord->eMapType = -1;
/* Allow it to be re-used */
--psNextAllocRec;
/* Indicate success */
bSuccess = TRUE;
/* No need to continue looking */
break;
}
}
if (!bSuccess)
{
DPF("mmap.c - pvr_mmap_remove_registered_area: Failed to remove area at 0x%08X\n", pkvMemArea);
}
}
else
{
DPF("mmap.c - pvr_mmap_remove_registered_area: Offset table missing - failed to remove area at 0x%08X\n", pkvMemArea);
}
}
/*
// FindAllocRec - Locates a record in the offset table by offset
*/
static PKV_OFFSET_STRUCT FindAllocRec(unsigned long nOffset)
{
PKV_OFFSET_STRUCT pStruct = 0;
unsigned int i;
for (i=0; (&psKVOffsetTable[i]) != psNextAllocRec; ++i)
{
if (
(psKVOffsetTable[i].nOffset <= nOffset) &&
(psKVOffsetTable[i].nOffset + psKVOffsetTable[i].nLength > nOffset)
)
{
pStruct = &psKVOffsetTable[i];
break;
}
}
return pStruct;
}
/*
// FindRegisteredArea - Locates a record in the offset table which covers the specified area
*/
static PKV_OFFSET_STRUCT FindRegisteredArea(void *pkvAddress, unsigned long nLength)
{
PKV_OFFSET_STRUCT pStruct = 0;
unsigned long addr = (unsigned long)pkvAddress;
unsigned int i;
if (psKVOffsetTable)
{
for (i=0; (&psKVOffsetTable[i]) != psNextAllocRec; ++i)
{
if ((((psKVOffsetTable[i].eMapType == PVR_MMAP_SCATTER) ||
(psKVOffsetTable[i].eMapType == PVR_MMAP_AGP_SCATTER)) &&
(psKVOffsetTable[i].pkvPageAlignedAddress == addr))
||
(((psKVOffsetTable[i].eMapType != PVR_MMAP_SCATTER) &&
(psKVOffsetTable[i].eMapType != PVR_MMAP_AGP_SCATTER)) &&
(psKVOffsetTable[i].pkvPageAlignedAddress <= addr) &&
(psKVOffsetTable[i].pkvPageAlignedAddress + psKVOffsetTable[i].nLength >= addr + nLength)))
{
return &psKVOffsetTable[i];
}
}
}
return NULL;
}
unsigned long pvr_mmap_user_to_kern(unsigned long nUserAddress)
{
struct list_head *ptr = 0;
struct pvrProcRecord *processEntry = 0;
struct pvrMMAPRecord *mmapEntry = 0;
unsigned long pkvAddress = 0;
for (ptr = pvrProcList.next; ptr != &pvrProcList; ptr = ptr->next)
{
processEntry = list_entry(ptr, struct pvrProcRecord, list);
if (processEntry->pid == current->pid)
{
struct list_head *mptr;
for (mptr = processEntry->mmapList.next; mptr != &processEntry->mmapList; mptr = mptr->next)
{
mmapEntry = list_entry(mptr, struct pvrMMAPRecord, list);
if ((mmapEntry->userAddress <= nUserAddress) &&
(mmapEntry->userAddress + mmapEntry->length > nUserAddress))
{
pkvAddress = mmapEntry->kernelAddress + (nUserAddress - mmapEntry->userAddress);
break;
}
}
break;
}
}
return pkvAddress;
}
/*
// AllocateTable - Allocates space for the offset table and
// reserves it to allow it to be re-mapped to user space.
// Also registers the table within itself, at offset zero.
*/
static void AllocateTable()
{
void* pkvAddress;
unsigned long pkvPageAlignedAddress;
unsigned long pkvPageAddress;
unsigned long *lockAddress;
unsigned long nBytes = KVOFFSET_TABLE_SIZE + PAGE_SIZE - 1;
pkvAddress = vmalloc(nBytes);
memset(pkvAddress, 0, nBytes);
if (pkvAddress)
{
/* Determine a page aligned pointer */
pkvPageAlignedAddress = ((unsigned long)pkvAddress + PAGE_SIZE - 1) & PAGE_MASK;
/* Reserve those pages to allow them to be re-mapped to user space */
for (
pkvPageAddress = pkvPageAlignedAddress;
pkvPageAddress < pkvPageAlignedAddress + nBytes;
pkvPageAddress += PAGE_SIZE
)
{
mem_map_reserve(ConvertKVToPage(pkvPageAddress));
}
/* Record the allocation */
OffsetTableAllocRec.pkvMem = (unsigned long)pkvAddress;
OffsetTableAllocRec.pkvPageAlignedMem = pkvPageAlignedAddress;
OffsetTableAllocRec.nBytes = nBytes;
OffsetTableAllocRec.pNext = NULL;
/* Initialise the table pointers */
psKVOffsetStruct = (void *)pkvPageAlignedAddress;
psKVOffsetTable = psKVOffsetStruct->pKVOffsetTable;
/* lock needs to go in a seperate page to be writeable from user */
lockAddress = vmalloc(PAGE_SIZE);
mem_map_reserve(ConvertKVToPage((unsigned long)lockAddress));
*lockAddress = 0;
psKVOffsetStruct->lockAddress = lockAddress;
psNextAllocRec = &psKVOffsetTable[0];
/* Register the table within itself to allow it to be remapped */
psNextAllocRec->pkvPageAlignedAddress = (unsigned long)psKVOffsetStruct;
psNextAllocRec->nOffset = 0;
psNextAllocRec->nLength = (KVOFFSET_TABLE_SIZE + PAGE_SIZE - 1) & PAGE_MASK;
psNextAllocRec->eMapType = PVR_MMAP_VIRTUAL;
DPF("mmap.c - AllocateTable: KVOffsetTable allocated at 0x%08X, size 0x%08X\n", pkvPageAlignedAddress, psNextAllocRec->nLength);
nNextOffset += psNextAllocRec->nLength + PAGE_SIZE;
++psNextAllocRec;
/* Terminate offset table */
psNextAllocRec->nOffset = 0;
pvr_mmap_register_area(lockAddress, PAGE_SIZE, PVR_MMAP_VIRTUAL, TRUE);
}
}
/*
// DeallocateTable - 'Unreserves' the memory allocated for the table and frees it up
*/
void DeallocateTable(void)
{
void *pkvAddress;
unsigned long pkvPageAlignedAddress;
unsigned long pkvPageAddress;
unsigned long nBytes = KVOFFSET_TABLE_SIZE + PAGE_SIZE - 1;
pkvAddress = (void *)OffsetTableAllocRec.pkvMem;
if (!psKVOffsetStruct)
return;
pvr_mmap_remove_registered_area(psKVOffsetStruct->lockAddress);
pvr_mmap_remove_registered_area(psKVOffsetStruct);
if (pkvAddress)
{
/* Determine a page aligned pointer */
pkvPageAlignedAddress = ((unsigned long)pkvAddress + PAGE_SIZE - 1) & PAGE_MASK;
/* Unreserve those pages to allow them to be freed */
for (
pkvPageAddress = pkvPageAlignedAddress;
pkvPageAddress < pkvPageAlignedAddress + nBytes;
pkvPageAddress += PAGE_SIZE
)
{
mem_map_unreserve(ConvertKVToPage(pkvPageAddress));
}
mem_map_unreserve(ConvertKVToPage((unsigned long)psKVOffsetStruct->lockAddress));
vfree(psKVOffsetStruct->lockAddress);
vfree(pkvAddress);
DPF("mmap.c - DeallocateTable: KVOffsetTable successfully deallocated\n");
}
else
{
DPF("mmap.c - DeallocateTable: Failed to deallocate KVOffsetTable\n");
}
psKVOffsetTable = 0;
}
|
