drivers/gpu/drm/img-rogue/ri_server.c

/*************************************************************************/ /*!
@File			ri_server.c
@Title          Resource Information (RI) server implementation
@Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
@Description	Resource Information (RI) server functions
@License        Dual MIT/GPLv2

The contents of this file are subject to the MIT license as set out below.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 ("GPL") in which case the provisions
of GPL are applicable instead of those above.

If you wish to allow use of your version of this file only under the terms of
GPL, and not to allow others to use your version of this file under the terms
of the MIT license, indicate your decision by deleting the provisions above
and replace them with the notice and other provisions required by GPL as set
out in the file called "GPL-COPYING" included in this distribution. If you do
not delete the provisions above, a recipient may use your version of this file
under the terms of either the MIT license or GPL.

This License is also included in this distribution in the file called
"MIT-COPYING".

EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ /**************************************************************************/


#include <stdarg.h>
#include "allocmem.h"
#include "pvr_debug.h"
#include "pvrsrv_error.h"
#include "osfunc.h"

#include "srvkm.h"
#include "lock.h"
/* services/server/include/ */
#include "ri_server.h"

/* services/include/shared/ */
#include "hash.h"
/* services/shared/include/ */
#include "dllist.h"

#include "pmr.h"

#if defined(PVR_RI_DEBUG)

#define USE_RI_LOCK 	1

/*
 * Initial size use for Hash table.
 * (Used to index the RI list entries).
 */
#define _RI_INITIAL_HASH_TABLE_SIZE	64

/*
 * Values written to the 'valid' field of
 * RI structures when created and cleared
 * prior to being destroyed.
 * The code can then check this value
 * before accessing the provided pointer
 * contents as a valid RI structure.
 */
#define _VALID_RI_LIST_ENTRY 	0x66bccb66
#define _VALID_RI_SUBLIST_ENTRY	0x77cddc77
#define _INVALID				0x00000000

/*
 * If this define is set to 1, details of
 * the linked lists (addresses, prev/next
 * ptrs, etc) are also output when function
 * RIDumpList() is called
 */
#define _DUMP_LINKEDLIST_INFO		0


typedef IMG_UINT64 _RI_BASE_T;

/*
 *  Length of string used for process name
 */
#define TASK_COMM_LEN 				16
/*
 *  Length of string used for process ID
 */
#define TASK_PID_LEN 				11
/*
 *  Length of string used for "[{PID}:_{process_name}]"
 */
#define RI_PROC_TAG_CHAR_LEN 		(1+TASK_PID_LEN+2+TASK_COMM_LEN+1)

/*
 *  Length of string used for address
 */
#define RI_ADDR_CHAR_LEN			12
/*
 *  Length of string used for size
 */
#define RI_SIZE_CHAR_LEN			12
/*
 *  Length of string used for "{Imported from PID nnnnnnnnnn}"
 */
#define RI_IMPORT_TAG_CHAR_LEN 		32
/*
 *  Total length of string returned to debugfs
 *  {0xaddr}_{annotation_text}_{0xsize}_{import_tag}
 */
#define RI_MAX_DEBUGFS_ENTRY_LEN	(RI_ADDR_CHAR_LEN+1+RI_MAX_TEXT_LEN+1+RI_SIZE_CHAR_LEN+1+RI_IMPORT_TAG_CHAR_LEN+1)
/*
 *  Total length of string output to _RIOutput()
 *  for MEMDESC RI sub-list entries
 *  {0xaddr}_{annotation_text}_[{PID}:_{process_name}]_{0xsize}_bytes_{import_tag}
 */
#define RI_MAX_MEMDESC_RI_ENTRY_LEN	(RI_ADDR_CHAR_LEN+1+RI_MAX_TEXT_LEN+1+RI_PROC_TAG_CHAR_LEN+1+RI_SIZE_CHAR_LEN+7+RI_IMPORT_TAG_CHAR_LEN+1)
/*
 *  Total length of string output to _RIOutput()
 *  for PMR RI list entries
 *  {annotation_text}_{pmr_handle}_suballocs:{num_suballocs}_{0xsize}
 */
#define RI_MAX_PMR_RI_ENTRY_LEN		(RI_MAX_TEXT_LEN+1+RI_ADDR_CHAR_LEN+11+10+1+RI_SIZE_CHAR_LEN)


/*
 * Structure used to make linked sublist of
 * memory allocations (MEMDESC)
 */
struct _RI_SUBLIST_ENTRY_
{
	DLLIST_NODE				sListNode;
	struct _RI_LIST_ENTRY_	*psRI;
	IMG_UINT32 				valid;
	IMG_BOOL				bIsImport;
	IMG_BOOL				bIsExportable;
	IMG_BOOL				bIsPinned;
	IMG_PID					pid;
	IMG_CHAR				ai8ProcName[TASK_COMM_LEN];
	IMG_DEV_VIRTADDR 		sVAddr;
	IMG_UINT64				ui64Offset;
	IMG_UINT64				ui64Size;
	IMG_UINT64				ui64BackedSize;
	IMG_CHAR				ai8TextB[RI_MAX_TEXT_LEN+1];
	DLLIST_NODE				sProcListNode;
};

/*
 * Structure used to make linked list of
 * PMRs. Sublists of allocations (MEMDESCs) made
 * from these PMRs are chained off these entries.
 */
struct _RI_LIST_ENTRY_
{
	DLLIST_NODE				sListNode;
	DLLIST_NODE				sSubListFirst;
	IMG_UINT32 				valid;
	PMR						*hPMR;
	IMG_UINT64 				ui64LogicalSize;
	IMG_PID					pid;
	IMG_CHAR				ai8ProcName[TASK_COMM_LEN];
	IMG_CHAR				ai8TextA[RI_MAX_TEXT_LEN+1];
	IMG_UINT16 				ui16SubListCount;
	IMG_UINT16 				ui16MaxSubListCount;
};

typedef struct _RI_LIST_ENTRY_ RI_LIST_ENTRY;
typedef struct _RI_SUBLIST_ENTRY_ RI_SUBLIST_ENTRY;

static IMG_UINT16 	g_ui16RICount = 0;
static HASH_TABLE 	*g_pRIHashTable = NULL;
static IMG_UINT16 	g_ui16ProcCount = 0;
static HASH_TABLE 	*g_pProcHashTable = NULL;

static POS_LOCK		g_hRILock;
/*
 * Flag used to indicate if RILock should be destroyed when final PMR entry
 * is deleted, i.e. if RIDeInitKM() has already been called before that point
 * but the handle manager has deferred deletion of RI entries.
 */
static IMG_BOOL 	bRIDeInitDeferred = IMG_FALSE;

/*
 *  Used as head of linked-list of PMR RI entries -
 *  this is useful when we wish to iterate all PMR
 *  list entries (when we don't have a PMR ref)
 */
static DLLIST_NODE	sListFirst;

/* Function used to produce string containing info for MEMDESC RI entries (used for both debugfs and kernel log output) */
static void _GenerateMEMDESCEntryString(RI_SUBLIST_ENTRY *psRISubEntry, IMG_BOOL bDebugFs, IMG_UINT16 ui16MaxStrLen, IMG_CHAR *pszEntryString);

static PVRSRV_ERROR _DumpAllEntries (uintptr_t k, uintptr_t v);
static PVRSRV_ERROR _DeleteAllEntries (uintptr_t k, uintptr_t v);
static PVRSRV_ERROR _DeleteAllProcEntries (uintptr_t k, uintptr_t v);
static PVRSRV_ERROR _DumpList(PMR *hPMR, IMG_PID pid);
#define _RIOutput(x) PVR_LOG(x)

IMG_INTERNAL IMG_UINT32
_ProcHashFunc (size_t uKeySize, void *pKey, IMG_UINT32 uHashTabLen);
IMG_INTERNAL IMG_UINT32
_ProcHashFunc (size_t uKeySize, void *pKey, IMG_UINT32 uHashTabLen)
{
	IMG_UINT32 *p = (IMG_UINT32 *)pKey;
	IMG_UINT32 uKeyLen = uKeySize / sizeof(IMG_UINT32);
	IMG_UINT32 ui;
	IMG_UINT32 uHashKey = 0;

	PVR_UNREFERENCED_PARAMETER(uHashTabLen);

	for (ui = 0; ui < uKeyLen; ui++)
	{
		IMG_UINT32 uHashPart = *p++;

		uHashPart += (uHashPart << 12);
		uHashPart ^= (uHashPart >> 22);
		uHashPart += (uHashPart << 4);
		uHashPart ^= (uHashPart >> 9);
		uHashPart += (uHashPart << 10);
		uHashPart ^= (uHashPart >> 2);
		uHashPart += (uHashPart << 7);
		uHashPart ^= (uHashPart >> 12);

		uHashKey += uHashPart;
	}

	return uHashKey;
}
IMG_INTERNAL IMG_BOOL
_ProcHashComp (size_t uKeySize, void *pKey1, void *pKey2);
IMG_INTERNAL IMG_BOOL
_ProcHashComp (size_t uKeySize, void *pKey1, void *pKey2)
{
	IMG_UINT32 *p1 = (IMG_UINT32 *)pKey1;
	IMG_UINT32 *p2 = (IMG_UINT32 *)pKey2;
	IMG_UINT32 uKeyLen = uKeySize / sizeof(IMG_UINT32);
	IMG_UINT32 ui;

	for (ui = 0; ui < uKeyLen; ui++)
	{
		if (*p1++ != *p2++)
			return IMG_FALSE;
	}

	return IMG_TRUE;
}

static void _RILock(void)
{
#if (USE_RI_LOCK == 1)
	OSLockAcquire(g_hRILock);
#endif
}

static void _RIUnlock(void)
{
#if (USE_RI_LOCK == 1)
	OSLockRelease(g_hRILock);
#endif
}

PVRSRV_ERROR RIInitKM(void)
{
	PVRSRV_ERROR eError = PVRSRV_OK;

	bRIDeInitDeferred = IMG_FALSE;
#if (USE_RI_LOCK == 1)
	eError = OSLockCreate(&g_hRILock, LOCK_TYPE_PASSIVE);
	if (eError != PVRSRV_OK)
	{
		PVR_DPF((PVR_DBG_ERROR, "%s: OSLockCreate failed (returned %d)",__func__,eError));
	}
#endif
	return eError;
}
void RIDeInitKM(void)
{
#if (USE_RI_LOCK == 1)
	if (g_ui16RICount > 0)
	{
		PVR_DPF((PVR_DBG_WARNING, "%s: called with %d entries remaining - deferring OSLockDestroy()",__func__,g_ui16RICount));
		bRIDeInitDeferred = IMG_TRUE;
	}
	else
	{
		OSLockDestroy(g_hRILock);
	}
#endif
}

/*!
******************************************************************************

 @Function	RIWritePMREntryKM

 @Description
            Writes a new Resource Information list entry.
            The new entry will be inserted at the head of the list of
            PMR RI entries and assigned the values provided.

 @input     hPMR - Reference (handle) to the PMR to which this reference relates
 @input     ai8TextA - String describing this PMR (may be null)
 @input     uiLogicalSize - Size of PMR

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIWritePMREntryKM(PMR *hPMR,
					   	       IMG_UINT32 ui32TextASize,
					   	       const IMG_CHAR *psz8TextA,
					   	       IMG_UINT64 ui64LogicalSize)
{
	uintptr_t hashData = 0;
	PMR			*pPMRHashKey = hPMR;
	IMG_PCHAR pszText = (IMG_PCHAR)psz8TextA;
	RI_LIST_ENTRY *psRIEntry = NULL;


	/* if Hash table has not been created, create it now */
	if (!g_pRIHashTable)
	{
		g_pRIHashTable = HASH_Create_Extended(_RI_INITIAL_HASH_TABLE_SIZE, sizeof(PMR*), HASH_Func_Default, HASH_Key_Comp_Default);
		g_pProcHashTable = HASH_Create_Extended(_RI_INITIAL_HASH_TABLE_SIZE, sizeof(IMG_PID), _ProcHashFunc, _ProcHashComp);
	}
	if (!g_pRIHashTable || !g_pProcHashTable)
	{
		/* Error - no memory to allocate for Hash table(s) */
		return PVRSRV_ERROR_OUT_OF_MEMORY;
	}
	if (!hPMR)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	else
	{
		/* Acquire RI Lock */
		_RILock();

		/* look-up hPMR in Hash Table */
		hashData = HASH_Retrieve_Extended (g_pRIHashTable, (void *)&pPMRHashKey);
		psRIEntry = (RI_LIST_ENTRY *)hashData;
		if (!psRIEntry)
		{
			/*
			 * If failed to find a matching existing entry, create a new one
			 */
			psRIEntry = (RI_LIST_ENTRY *)OSAllocZMem(sizeof(RI_LIST_ENTRY));
			if (!psRIEntry)
			{
				/* Release RI Lock */
				_RIUnlock();
				/* Error - no memory to allocate for new RI entry */
				return PVRSRV_ERROR_OUT_OF_MEMORY;
			}
			else
			{
				/*
				 * Add new RI Entry
				 */
				if (g_ui16RICount == 0)
				{
					/* Initialise PMR entry linked-list head */
					dllist_init(&sListFirst);
				}
				g_ui16RICount++;

				dllist_init (&(psRIEntry->sSubListFirst));
				psRIEntry->ui16SubListCount = 0;
				psRIEntry->ui16MaxSubListCount = 0;
				psRIEntry->valid = _VALID_RI_LIST_ENTRY;
				psRIEntry->pid = OSGetCurrentClientProcessIDKM();
				OSSNPrintf((IMG_CHAR *)psRIEntry->ai8ProcName, TASK_COMM_LEN, "%s", OSGetCurrentClientProcessNameKM());
				/* Add PMR entry to linked-list of PMR entries */
				dllist_init (&(psRIEntry->sListNode));
				dllist_add_to_tail(&sListFirst,(PDLLIST_NODE)&(psRIEntry->sListNode));
			}

			if (pszText)
			{
				if (ui32TextASize > RI_MAX_TEXT_LEN)
					ui32TextASize = RI_MAX_TEXT_LEN;

				/* copy ai8TextA field data */
				OSSNPrintf((IMG_CHAR *)psRIEntry->ai8TextA, ui32TextASize+1, "%s", pszText);

				/* ensure string is NUL-terminated */
				psRIEntry->ai8TextA[ui32TextASize] = '\0';
			}
			else
			{
				/* ensure string is NUL-terminated */
				psRIEntry->ai8TextA[0] = '\0';
			}
			psRIEntry->hPMR = hPMR;
			psRIEntry->ui64LogicalSize = ui64LogicalSize;

			/* Create index entry in Hash Table */
			HASH_Insert_Extended (g_pRIHashTable, (void *)&pPMRHashKey, (uintptr_t)psRIEntry);

			/* Store phRIHandle in PMR structure, so it can delete the associated RI entry when it destroys the PMR */
			PMRStoreRIHandle(hPMR, psRIEntry);
		}
		/* Release RI Lock */
		_RIUnlock();
	}
	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIWriteMEMDESCEntryKM

 @Description
            Writes a new Resource Information sublist entry.
            The new entry will be inserted at the head of the sublist of
            the indicated PMR list entry, and assigned the values provided.

 @input     hPMR - Reference (handle) to the PMR to which this MEMDESC RI entry relates
 @input     ai8TextB - String describing this secondary reference (may be null)
 @input     uiOffset - Offset from the start of the PMR at which this allocation begins
 @input     uiSize - Size of this allocation
 @input     ui64BackedSize - How much of uiSize is actually physically backed?
 @input     bIsImport - Flag indicating if this is an allocation or an import
 @input     bIsExportable - Flag indicating if this allocation is exportable
 @output    phRIHandle - Handle to the created RI entry

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIWriteMEMDESCEntryKM(PMR *hPMR,
					   	   	   	   IMG_UINT32 ui32TextBSize,
					   	   	   	   const IMG_CHAR *psz8TextB,
					   	   	   	   IMG_UINT64 ui64Offset,
					   	   	   	   IMG_UINT64 ui64Size,
					   	   	   	   IMG_UINT64 ui64BackedSize,
					   	   	   	   IMG_BOOL bIsImport,
					   	   	   	   IMG_BOOL bIsExportable,
					   	   	   	   RI_HANDLE *phRIHandle)
{
	uintptr_t hashData = 0;
	PMR 		*pPMRHashKey = hPMR;
	IMG_PID		pid;
	IMG_PCHAR pszText = (IMG_PCHAR)psz8TextB;
	RI_LIST_ENTRY *psRIEntry = NULL;
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;


	/* check Hash tables have been created (meaning at least one PMR has been defined) */
	if (!g_pRIHashTable || !g_pProcHashTable)
	{
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	if (!hPMR || !phRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	else
	{
		/* Acquire RI Lock */
		_RILock();

		*phRIHandle = NULL;

		/* look-up hPMR in Hash Table */
		hashData = HASH_Retrieve_Extended (g_pRIHashTable, (void *)&pPMRHashKey);
		psRIEntry = (RI_LIST_ENTRY *)hashData;
		if (!psRIEntry)
		{
			/* Release RI Lock */
			_RIUnlock();
			return PVRSRV_ERROR_INVALID_PARAMS;
		}

		psRISubEntry = (RI_SUBLIST_ENTRY *)OSAllocZMem(sizeof(RI_SUBLIST_ENTRY));
		if (!psRISubEntry)
		{
			/* Release RI Lock */
			_RIUnlock();
			/* Error - no memory to allocate for new RI sublist entry */
			return PVRSRV_ERROR_OUT_OF_MEMORY;
		}
		else
		{
			/*
			 * Insert new entry in sublist
			 */
			PDLLIST_NODE currentNode = dllist_get_next_node(&(psRIEntry->sSubListFirst));

			/*
			 * Insert new entry before currentNode
			 */
			if (!currentNode)
			{
				currentNode = &(psRIEntry->sSubListFirst);
			}
			dllist_add_to_tail(currentNode, (PDLLIST_NODE)&(psRISubEntry->sListNode));

			psRISubEntry->psRI = psRIEntry;

			/* Increment number of entries in sublist */
			psRIEntry->ui16SubListCount++;
			if (psRIEntry->ui16SubListCount > psRIEntry->ui16MaxSubListCount)
			{
				psRIEntry->ui16MaxSubListCount = psRIEntry->ui16SubListCount;
			}
			psRISubEntry->valid = _VALID_RI_SUBLIST_ENTRY;
		}

		psRISubEntry->pid = OSGetCurrentClientProcessIDKM();

		if (ui32TextBSize > RI_MAX_TEXT_LEN)
			ui32TextBSize = RI_MAX_TEXT_LEN;
		/* copy ai8TextB field data */
		OSSNPrintf((IMG_CHAR *)psRISubEntry->ai8TextB, ui32TextBSize+1, "%s", pszText);
		/* ensure string is NUL-terminated */
		psRISubEntry->ai8TextB[ui32TextBSize] = '\0';

		psRISubEntry->ui64Offset = ui64Offset;
		psRISubEntry->ui64Size = ui64Size;
		psRISubEntry->ui64BackedSize = ui64BackedSize;
		psRISubEntry->bIsImport = bIsImport;
		psRISubEntry->bIsExportable = bIsExportable;
		psRISubEntry->bIsPinned = IMG_TRUE;
		OSSNPrintf((IMG_CHAR *)psRISubEntry->ai8ProcName, TASK_COMM_LEN, "%s", OSGetCurrentClientProcessNameKM());
		dllist_init (&(psRISubEntry->sProcListNode));

		/*
		 *	Now insert this MEMDESC into the proc list
		 */
		/* look-up pid in Hash Table */
		pid = psRISubEntry->pid;
		hashData = HASH_Retrieve_Extended (g_pProcHashTable, (void *)&pid);
		if (!hashData)
		{
			/*
			 * No allocations for this pid yet
			 */
			HASH_Insert_Extended (g_pProcHashTable, (void *)&pid, (uintptr_t)&(psRISubEntry->sProcListNode));
			/* Increment number of entries in proc hash table */
			g_ui16ProcCount++;
		}
		else
		{
			/*
			 * Insert allocation into pid allocations linked list
			 */
			PDLLIST_NODE currentNode = (PDLLIST_NODE)hashData;

			/*
			 * Insert new entry
			 */
			dllist_add_to_tail(currentNode, (PDLLIST_NODE)&(psRISubEntry->sProcListNode));
		}
		*phRIHandle = (RI_HANDLE)psRISubEntry;
		/* Release RI Lock */
		_RIUnlock();
	}
	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIWriteProcListEntryKM

 @Description
            Write a new entry in the process list directly. We have to do this
            because there might be no, multiple or changing PMR handles.

            In the common case we have a PMR that will be added to the PMR list
            and one or several MemDescs that are associated to it in a sub-list.
            Additionally these MemDescs will be inserted in the per-process list.

            There might be special descriptors from e.g. new user APIs that
            are associated with no or multiple PMRs and not just one.
            These can be now added to the per-process list (as RI_SUBLIST_ENTRY)
            directly with this function and won't be listed in the PMR list (RIEntry)
            because there might be no PMR.

            To remove entries from the per-process list, just use
            RIDeleteMEMDESCEntryKM().

 @input     ai8TextB - String describing this secondary reference (may be null)
 @input     uiSize - Size of this allocation
 @input     ui64BackedSize - How much of uiSize is actually physically backed?
 @input     ui64DevVAddr - Virtual address of this entry
 @output    phRIHandle - Handle to the created RI entry

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIWriteProcListEntryKM(IMG_UINT32 ui32TextBSize,
                                    const IMG_CHAR *psz8TextB,
                                    IMG_UINT64 ui64Size,
                                    IMG_UINT64 ui64BackedSize,
                                    IMG_UINT64 ui64DevVAddr,
                                    RI_HANDLE *phRIHandle)
{
	uintptr_t hashData = 0;
	IMG_PID		pid;
	IMG_PCHAR pszText = (IMG_PCHAR)psz8TextB;
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;

	if (!g_pRIHashTable)
	{
		g_pRIHashTable = HASH_Create_Extended(_RI_INITIAL_HASH_TABLE_SIZE, sizeof(PMR*), HASH_Func_Default, HASH_Key_Comp_Default);
		g_pProcHashTable = HASH_Create_Extended(_RI_INITIAL_HASH_TABLE_SIZE, sizeof(IMG_PID), _ProcHashFunc, _ProcHashComp);

		if (!g_pRIHashTable || !g_pProcHashTable)
		{
			/* Error - no memory to allocate for Hash table(s) */
			return PVRSRV_ERROR_OUT_OF_MEMORY;
		}
	}

	/* Acquire RI Lock */
	_RILock();

	*phRIHandle = NULL;

	psRISubEntry = (RI_SUBLIST_ENTRY *)OSAllocZMem(sizeof(RI_SUBLIST_ENTRY));
	if (!psRISubEntry)
	{
		/* Release RI Lock */
		_RIUnlock();
		/* Error - no memory to allocate for new RI sublist entry */
		return PVRSRV_ERROR_OUT_OF_MEMORY;
	}

	psRISubEntry->valid = _VALID_RI_SUBLIST_ENTRY;


	psRISubEntry->pid = OSGetCurrentClientProcessIDKM();

	if (ui32TextBSize > RI_MAX_TEXT_LEN)
		ui32TextBSize = RI_MAX_TEXT_LEN;
	/* copy ai8TextB field data */
	OSSNPrintf((IMG_CHAR *)psRISubEntry->ai8TextB, ui32TextBSize+1, "%s", pszText);
	/* ensure string is NUL-terminated */
	psRISubEntry->ai8TextB[ui32TextBSize] = '\0';

	psRISubEntry->ui64Offset = 0;
	psRISubEntry->ui64Size = ui64Size;
	psRISubEntry->ui64BackedSize = ui64BackedSize;
	psRISubEntry->sVAddr.uiAddr = ui64DevVAddr;
	psRISubEntry->bIsImport = IMG_FALSE;
	psRISubEntry->bIsExportable = IMG_FALSE;
	psRISubEntry->bIsPinned = IMG_TRUE;
	OSSNPrintf((IMG_CHAR *)psRISubEntry->ai8ProcName, TASK_COMM_LEN, "%s", OSGetCurrentClientProcessNameKM());
	dllist_init (&(psRISubEntry->sProcListNode));

	/*
	 *	Now insert this MEMDESC into the proc list
	 */
	/* look-up pid in Hash Table */
	pid = psRISubEntry->pid;
	hashData = HASH_Retrieve_Extended (g_pProcHashTable, (void *)&pid);
	if (!hashData)
	{
		/*
		 * No allocations for this pid yet
		 */
		HASH_Insert_Extended (g_pProcHashTable, (void *)&pid, (uintptr_t)&(psRISubEntry->sProcListNode));
		/* Increment number of entries in proc hash table */
		g_ui16ProcCount++;
	}
	else
	{
		/*
		 * Insert allocation into pid allocations linked list
		 */
		PDLLIST_NODE currentNode = (PDLLIST_NODE)hashData;

		/*
		 * Insert new entry
		 */
		dllist_add_to_tail(currentNode, (PDLLIST_NODE)&(psRISubEntry->sProcListNode));
	}
	*phRIHandle = (RI_HANDLE)psRISubEntry;
	/* Release RI Lock */
	_RIUnlock();

	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIUpdateMEMDESCAddrKM

 @Description
            Update a Resource Information entry.

 @input     hRIHandle - Handle of object whose reference info is to be updated
 @input     uiAddr - New address for the RI entry

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIUpdateMEMDESCAddrKM(RI_HANDLE hRIHandle,
								   IMG_DEV_VIRTADDR sVAddr)
{
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;

	if (!hRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	psRISubEntry = (RI_SUBLIST_ENTRY *)hRIHandle;
	if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
	{
		/* Pointer does not point to valid structure */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

    /* Acquire RI lock*/
	_RILock();

	psRISubEntry->sVAddr.uiAddr = sVAddr.uiAddr;

	/* Release RI lock */
	_RIUnlock();

	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIUpdateMEMDESCPinningKM

 @Description
            Update a Resource Information entry.

 @input     hRIHandle - Handle of object whose reference info is to be updated
 @input     bIsPinned - The new pinning state

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIUpdateMEMDESCPinningKM(RI_HANDLE hRIHandle,
								   IMG_BOOL bIsPinned)
{
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;

	if (!hRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	psRISubEntry = (RI_SUBLIST_ENTRY *)hRIHandle;
	if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
	{
		/* Pointer does not point to valid structure */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

    /* Acquire RI lock*/
	_RILock();

	psRISubEntry->bIsPinned = bIsPinned;

	/* Release RI lock */
	_RIUnlock();

	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIUpdateMEMDESCBackingKM

 @Description
            Update a Resource Information entry.

 @input     hRIHandle       Handle of object whose reference info is to be updated
 @input     iSizeAdjustment The change of backed physical memory for this
                            allocation in bytes.

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIUpdateMEMDESCBackingKM(RI_HANDLE hRIHandle,
                                      IMG_INT32 iSizeAdjustment)
{
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;

	if (!hRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	psRISubEntry = (RI_SUBLIST_ENTRY *)hRIHandle;
	if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
	{
		/* Pointer does not point to valid structure */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

	/* Acquire RI lock*/
	_RILock();

	psRISubEntry->ui64BackedSize += iSizeAdjustment;

	/* Release RI lock */
	_RIUnlock();

	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIDeletePMREntryKM

 @Description
            Delete a Resource Information entry.

 @input     hRIHandle - Handle of object whose reference info is to be deleted

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDeletePMREntryKM(RI_HANDLE hRIHandle)
{
	RI_LIST_ENTRY *psRIEntry = NULL;
	PMR			*pPMRHashKey;
	PVRSRV_ERROR eResult = PVRSRV_OK;


	if (!hRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	else
	{
		psRIEntry = (RI_LIST_ENTRY *)hRIHandle;

		if (psRIEntry->valid != _VALID_RI_LIST_ENTRY)
		{
			/* Pointer does not point to valid structure */
			return PVRSRV_ERROR_INVALID_PARAMS;
		}

		if(psRIEntry->ui16SubListCount == 0)
		{
		    /* Acquire RI lock*/
			_RILock();

			/* Remove the HASH table index entry */
			pPMRHashKey = psRIEntry->hPMR;
			HASH_Remove_Extended(g_pRIHashTable, (void *)&pPMRHashKey);

			psRIEntry->valid = _INVALID;

			/* Remove PMR entry from linked-list of PMR entries */
			dllist_remove_node((PDLLIST_NODE)&(psRIEntry->sListNode));

			/* Now, free the memory used to store the RI entry */
			OSFreeMem(psRIEntry);
			psRIEntry = NULL;

		    /* Release RI lock*/
			_RIUnlock();

			/*
			 * Decrement number of RI entries - if this is now zero,
			 * we can delete the RI hash table
			 */
			if(--g_ui16RICount == 0)
			{
				HASH_Delete(g_pRIHashTable);
				g_pRIHashTable = NULL;
				/* If deInit has been deferred, we can now destroy the RI Lock */
				if (bRIDeInitDeferred)
				{
					OSLockDestroy(g_hRILock);
				}
			}
			/*
			 * Make the handle NULL once PMR RI entry is deleted
			 */
			hRIHandle = NULL;
		}
		else
		{
			eResult = PVRSRV_ERROR_DEVICEMEM_ALLOCATIONS_REMAIN_IN_HEAP;
		}
	}

	return eResult;
}

/*!
******************************************************************************

 @Function	RIDeleteMEMDESCEntryKM

 @Description
            Delete a Resource Information entry.
            Entry can be from RIEntry list or ProcList.

 @input     hRIHandle - Handle of object whose reference info is to be deleted

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDeleteMEMDESCEntryKM(RI_HANDLE hRIHandle)
{
	RI_LIST_ENTRY *psRIEntry = NULL;
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;
	uintptr_t hashData = 0;
	IMG_PID     pid;
	PVRSRV_ERROR eResult = PVRSRV_OK;


	if (!hRIHandle)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

	psRISubEntry = (RI_SUBLIST_ENTRY *)hRIHandle;
	if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
	{
		/* Pointer does not point to valid structure */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

    /* Acquire RI lock*/
	_RILock();

	/* For entries which do have a parent PMR remove the node from the sublist */
	if (psRISubEntry->psRI)
	{
		psRIEntry = (RI_LIST_ENTRY *)psRISubEntry->psRI;

		/* Now, remove entry from the sublist */
		dllist_remove_node(&(psRISubEntry->sListNode));
	}

	psRISubEntry->valid = _INVALID;

	/* Remove the entry from the proc allocations linked list */
	pid = psRISubEntry->pid;
	/* If this is the only allocation for this pid, just remove it from the hash table */
	if (dllist_get_next_node(&(psRISubEntry->sProcListNode)) == NULL)
	{
		HASH_Remove_Extended(g_pProcHashTable, (void *)&pid);
		/* Decrement number of entries in proc hash table, and delete the hash table if there are now none */
		if(--g_ui16ProcCount == 0)
		{
			HASH_Delete(g_pProcHashTable);
			g_pProcHashTable = NULL;
		}
	}
	else
	{
		hashData = HASH_Retrieve_Extended (g_pProcHashTable, (void *)&pid);
		if ((PDLLIST_NODE)hashData == &(psRISubEntry->sProcListNode))
		{
			HASH_Remove_Extended(g_pProcHashTable, (void *)&pid);
			HASH_Insert_Extended (g_pProcHashTable, (void *)&pid, (uintptr_t)dllist_get_next_node(&(psRISubEntry->sProcListNode)));
		}
	}
	dllist_remove_node(&(psRISubEntry->sProcListNode));

	/* Now, free the memory used to store the sublist entry */
	OSFreeMem(psRISubEntry);
	psRISubEntry = NULL;

	/*
	 * Decrement number of entries in sublist if this MemDesc had a parent entry.
	 */
	if (psRIEntry)
	{
		psRIEntry->ui16SubListCount--;
	}

    /* Release RI lock*/
	_RIUnlock();

	/*
	 * Make the handle NULL once MEMDESC RI entry is deleted
	 */
	hRIHandle = NULL;

	return eResult;
}

/*!
******************************************************************************

 @Function	RIDeleteListKM

 @Description
            Delete all Resource Information entries and free associated
            memory.

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDeleteListKM(void)
{
	PVRSRV_ERROR eResult = PVRSRV_OK;


	if (g_pRIHashTable)
	{
		eResult = HASH_Iterate(g_pRIHashTable, (HASH_pfnCallback)_DeleteAllEntries);
		if (eResult == PVRSRV_ERROR_RESOURCE_UNAVAILABLE)
		{
			/*
			 * PVRSRV_ERROR_RESOURCE_UNAVAILABLE is used to stop the Hash iterator when
			 * the hash table gets deleted as a result of deleting the final PMR entry,
			 * so this is not a real error condition...
			 */
			eResult = PVRSRV_OK;
		}
	}

	/* After the run through the RIHashTable that holds the PMR entries there might be
	 * still entries left in the per-process hash table because they were added with
	 * RIWriteProcListEntryKM() and have no PMR parent associated.
	 */
	if (g_pProcHashTable)
	{
		eResult = HASH_Iterate(g_pProcHashTable, (HASH_pfnCallback) _DeleteAllProcEntries);
		if (eResult == PVRSRV_ERROR_RESOURCE_UNAVAILABLE)
		{
			/*
			 * PVRSRV_ERROR_RESOURCE_UNAVAILABLE is used to stop the Hash iterator when
			 * the hash table gets deleted as a result of deleting the final PMR entry,
			 * so this is not a real error condition...
			 */
			eResult = PVRSRV_OK;
		}
	}

	return eResult;
}

/*!
******************************************************************************

 @Function	RIDumpListKM

 @Description
            Dumps out the contents of the RI List entry for the
            specified PMR, and all MEMDESC allocation entries
            in the associated sub linked list.
            At present, output is directed to Kernel log
            via PVR_DPF.

 @input     hPMR - PMR for which RI entry details are to be output

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDumpListKM(PMR *hPMR)
{
	PVRSRV_ERROR eError = PVRSRV_OK;

	/* Acquire RI lock*/
	_RILock();

	eError = _DumpList(hPMR,0);

    /* Release RI lock*/
	_RIUnlock();

	return eError;
}

/*!
******************************************************************************

 @Function	RIGetListEntryKM

 @Description
            Returns pointer to a formatted string with details of the specified
            list entry. If no entry exists (e.g. it may have been deleted
            since the previous call), NULL is returned.

 @input     pid - pid for which RI entry details are to be output
 @input     ppHandle - handle to the entry, if NULL, the first entry will be
                     returned.
 @output    pszEntryString - string to be output for the entry
 @output    hEntry - hEntry will be returned pointing to the next entry
                     (or NULL if there is no next entry)

 @Return	PVRSRV_ERROR

******************************************************************************/
IMG_BOOL RIGetListEntryKM(IMG_PID pid,
						  IMG_HANDLE **ppHandle,
						  IMG_CHAR **ppszEntryString)
{
	RI_SUBLIST_ENTRY  *psRISubEntry = NULL;
	uintptr_t     hashData      = 0;
	IMG_PID      	  hashKey  = pid;

	static IMG_CHAR	  ai8DebugfsSummaryString[RI_MAX_DEBUGFS_ENTRY_LEN+1];
	static IMG_UINT64 ui64TotalAlloc = 0;
	static IMG_UINT64 ui64TotalBacked = 0;
	static IMG_UINT64 ui64TotalImport = 0;
	static IMG_UINT64 ui64TotalUnpinned = 0;
	static IMG_BOOL bDisplaySummary = IMG_FALSE;
	static IMG_BOOL bTerminateNextCall = IMG_FALSE;

	if (bDisplaySummary)
	{
		OSSNPrintf((IMG_CHAR *)&ai8DebugfsSummaryString[0],
		            RI_MAX_TEXT_LEN,
		            "Alloc:0x%llx + Imports:0x%llx = Total:0x%llx [Physical: 0x%llx] {Unpinned:0x%llx}\n",
		            (unsigned long long) ui64TotalAlloc,
		            (unsigned long long) ui64TotalImport,
		            (unsigned long long) (ui64TotalAlloc + ui64TotalImport),
		            (unsigned long long) ui64TotalBacked,
		            (unsigned long long) ui64TotalUnpinned);

		*ppszEntryString = &ai8DebugfsSummaryString[0];
		ui64TotalAlloc = 0;
		ui64TotalImport = 0;
		ui64TotalUnpinned = 0;
		ui64TotalBacked = 0;
		bTerminateNextCall = IMG_TRUE;
		bDisplaySummary = IMG_FALSE;
		return IMG_TRUE;
	}

	if (bTerminateNextCall)
	{
		*ppszEntryString = NULL;
		*ppHandle        = NULL;
		bTerminateNextCall = IMG_FALSE;
		return IMG_FALSE;
	}

    /* Acquire RI lock*/
	_RILock();

	/* look-up pid in Hash Table, to obtain first entry for pid */
	hashData = HASH_Retrieve_Extended(g_pProcHashTable, (void *)&hashKey);
	if (hashData)
	{
		if (*ppHandle)
		{
			psRISubEntry = (RI_SUBLIST_ENTRY *)*ppHandle;
			if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
			{
				psRISubEntry = NULL;
			}
		}
		else
		{
			psRISubEntry = IMG_CONTAINER_OF((PDLLIST_NODE)hashData, RI_SUBLIST_ENTRY, sProcListNode);
			if (psRISubEntry->valid != _VALID_RI_SUBLIST_ENTRY)
			{
				psRISubEntry = NULL;
			}
		}
	}

	if (psRISubEntry)
	{
		PDLLIST_NODE  psNextProcListNode = dllist_get_next_node(&psRISubEntry->sProcListNode);

		if (psNextProcListNode == NULL  ||
		    psNextProcListNode == (PDLLIST_NODE)hashData)
		{
			bDisplaySummary = IMG_TRUE;
		}


		ui64TotalBacked += psRISubEntry->ui64BackedSize;

		if (psRISubEntry->bIsImport)
		{
			/* If it is a local import we set backed size to 0
			 * so we don't account twice for the same allocation */
			ui64TotalImport += psRISubEntry->ui64BackedSize;
		}
		else
		{
			ui64TotalAlloc += psRISubEntry->ui64Size;
		}


		if (!psRISubEntry->bIsPinned)
		{
			ui64TotalUnpinned += psRISubEntry->ui64Size;
		}

		_GenerateMEMDESCEntryString(psRISubEntry,
		                            IMG_TRUE,
		                            RI_MAX_DEBUGFS_ENTRY_LEN,
		                            (IMG_CHAR *)&ai8DebugfsSummaryString);
		ai8DebugfsSummaryString[RI_MAX_DEBUGFS_ENTRY_LEN] = '\0';

		*ppszEntryString = (IMG_CHAR *)&ai8DebugfsSummaryString;
		*ppHandle        = (IMG_HANDLE)IMG_CONTAINER_OF(psNextProcListNode, RI_SUBLIST_ENTRY, sProcListNode);

	}
	else
	{
		bDisplaySummary = IMG_TRUE;
		if (ui64TotalAlloc == 0)
		{
			ai8DebugfsSummaryString[0] = '\0';
			*ppszEntryString = (IMG_CHAR *)&ai8DebugfsSummaryString;
		}
	}

    /* Release RI lock*/
	_RIUnlock();

	return IMG_TRUE;
}

/* Function used to produce string containing info for MEMDESC RI entries (used for both debugfs and kernel log output) */
static void _GenerateMEMDESCEntryString(RI_SUBLIST_ENTRY *psRISubEntry,
                                            IMG_BOOL bDebugFs,
                                            IMG_UINT16 ui16MaxStrLen,
                                            IMG_CHAR *pszEntryString)
{
	IMG_CHAR 	szProc[RI_PROC_TAG_CHAR_LEN];
	IMG_CHAR 	szImport[RI_IMPORT_TAG_CHAR_LEN];
	IMG_PCHAR   pszAnnotationText = NULL;

	if (!bDebugFs)
	{
		/* we don't include process ID info for debugfs output */
		OSSNPrintf( (IMG_CHAR *)&szProc,
		            RI_PROC_TAG_CHAR_LEN,
		            "[%d: %s]",
		            psRISubEntry->pid,
		            (IMG_CHAR *)psRISubEntry->ai8ProcName);
	}
	if (psRISubEntry->bIsImport)
	{
		OSSNPrintf( (IMG_CHAR *)&szImport,
		            RI_IMPORT_TAG_CHAR_LEN,
		            "{Import from PID %d}",
		            psRISubEntry->psRI->pid);
		/* Set pszAnnotationText to that of the 'parent' PMR RI entry */
		pszAnnotationText = (IMG_PCHAR)psRISubEntry->psRI->ai8TextA;
	}
	else
	{
		if (psRISubEntry->bIsExportable)
		{
			/* Set pszAnnotationText to that of the 'parent' PMR RI entry */
			pszAnnotationText = (IMG_PCHAR)psRISubEntry->psRI->ai8TextA;
		}
		else
		{
			/* Set pszAnnotationText to that of the MEMDESC RI entry */
			pszAnnotationText = (IMG_PCHAR)psRISubEntry->ai8TextB;
		}
	}


	OSSNPrintf(pszEntryString,
	           ui16MaxStrLen,
	           "%s 0x%010llx\t%-80s %s\t0x%010llx [0x%010llx] %s%s%c",
	           (bDebugFs ? "" : "  "),
	           (unsigned long long) (psRISubEntry->sVAddr.uiAddr + psRISubEntry->ui64Offset),
	           pszAnnotationText,
	           (bDebugFs ? "" : (char *)szProc),
	           (unsigned long long) psRISubEntry->ui64Size,
	           (unsigned long long) psRISubEntry->ui64BackedSize,
	           (psRISubEntry->bIsImport ? (char *)&szImport : ""),
	           (psRISubEntry->bIsPinned ? "" : "{Unpinned}"),
	           (bDebugFs ? '\n' : ' '));
}

/*!
******************************************************************************

 @Function	_DumpList
 @Description
            Dumps out RI List entries according to parameters passed.

 @input     hPMR - If not NULL, function will output the RI entries for
                   the specified PMR only
 @input     pid - If non-zero, the function will only output MEMDESC RI
  	  	  	  	  entries made by the process with ID pid.
                  If zero, all MEMDESC RI entries will be output.

 @Return	PVRSRV_ERROR

******************************************************************************/
static PVRSRV_ERROR _DumpList(PMR *hPMR, IMG_PID pid)
{
	RI_LIST_ENTRY *psRIEntry = NULL;
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;
	IMG_UINT16 ui16SubEntriesParsed = 0;
	uintptr_t hashData = 0;
	IMG_PID		  hashKey;
	PMR			*pPMRHashKey = hPMR;
	IMG_BOOL 	bDisplayedThisPMR = IMG_FALSE;


	if (!hPMR)
	{
		/* NULL handle provided */
		return PVRSRV_ERROR_INVALID_PARAMS;
	}
	if (g_pRIHashTable && g_pProcHashTable)
	{
		if (pid != 0)
		{
			/* look-up pid in Hash Table */
			hashKey = pid;
			hashData = HASH_Retrieve_Extended (g_pProcHashTable, (void *)&hashKey);
			if (hashData)
			{
				psRISubEntry = IMG_CONTAINER_OF((PDLLIST_NODE)hashData, RI_SUBLIST_ENTRY, sProcListNode);
				if (psRISubEntry)
				{
					psRIEntry = psRISubEntry->psRI;
				}
			}
		}
		else
		{
			/* look-up hPMR in Hash Table */
			hashData = HASH_Retrieve_Extended (g_pRIHashTable, (void *)&pPMRHashKey);
			psRIEntry = (RI_LIST_ENTRY *)hashData;
		}
		if (!psRIEntry)
		{
			/* No entry found in hash table */
			return PVRSRV_ERROR_NOT_FOUND;
		}
		while (psRIEntry)
		{
			bDisplayedThisPMR = IMG_FALSE;
			/* Output details for RI entry */
			if (!pid)
			{
				_RIOutput (("%s (0x%p) suballocs:%d size:0x%llx",
				            psRIEntry->ai8TextA,
				            psRIEntry->hPMR,
				            (IMG_UINT)psRIEntry->ui16SubListCount,
				            (unsigned long long)psRIEntry->ui64LogicalSize));
				bDisplayedThisPMR = IMG_TRUE;
			}
			ui16SubEntriesParsed = 0;
			if(psRIEntry->ui16SubListCount)
			{
#if _DUMP_LINKEDLIST_INFO
				_RIOutput (("RI LIST: {sSubListFirst.psNextNode:0x%x}",
				            (IMG_UINT)psRIEntry->sSubListFirst.psNextNode));
#endif /* _DUMP_LINKEDLIST_INFO */
				if (!pid)
				{
					psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRIEntry->sSubListFirst)),
					                                RI_SUBLIST_ENTRY, sListNode);
				}
				/* Traverse RI sublist and output details for each entry */
				while (psRISubEntry && (ui16SubEntriesParsed < psRIEntry->ui16SubListCount))
				{
					if (!bDisplayedThisPMR)
					{
						_RIOutput (("%s (0x%p) suballocs:%d size:0x%llx",
						            psRIEntry->ai8TextA,
						            psRIEntry->hPMR,
						            (IMG_UINT)psRIEntry->ui16SubListCount,
						            (unsigned long long)psRIEntry->ui64LogicalSize));
						bDisplayedThisPMR = IMG_TRUE;
					}
#if _DUMP_LINKEDLIST_INFO
					_RIOutput (("RI LIST:    [this subentry:0x%x]",(IMG_UINT)psRISubEntry));
					_RIOutput (("RI LIST:     psRI:0x%x",(IMG_UINT32)psRISubEntry->psRI));
#endif /* _DUMP_LINKEDLIST_INFO */

					{
						IMG_CHAR szEntryString[RI_MAX_MEMDESC_RI_ENTRY_LEN];

						_GenerateMEMDESCEntryString(psRISubEntry,
						                            IMG_FALSE,
						                            RI_MAX_MEMDESC_RI_ENTRY_LEN,
						                            (IMG_CHAR *)&szEntryString);
						szEntryString[RI_MAX_MEMDESC_RI_ENTRY_LEN-1] = '\0';
						_RIOutput (("%s",(IMG_CHAR *)&szEntryString));
					}

					if (pid)
					{
						if((dllist_get_next_node(&(psRISubEntry->sProcListNode)) == 0) ||
						   (dllist_get_next_node(&(psRISubEntry->sProcListNode)) == (PDLLIST_NODE)hashData))
						{
							psRISubEntry = NULL;
						}
						else
						{
							psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRISubEntry->sProcListNode)),
							                                RI_SUBLIST_ENTRY, sProcListNode);
							if (psRISubEntry)
							{
								if (psRIEntry != psRISubEntry->psRI)
								{
									/*
									 * The next MEMDESC in the process linked list is in a different PMR
									 */
									psRIEntry = psRISubEntry->psRI;
									bDisplayedThisPMR = IMG_FALSE;
								}
							}
						}
					}
					else
					{
						ui16SubEntriesParsed++;
						psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRISubEntry->sListNode)),
						                                RI_SUBLIST_ENTRY, sListNode);
					}
				}
			}
			if (!pid)
			{
				if (ui16SubEntriesParsed != psRIEntry->ui16SubListCount)
				{
					/*
					 * Output error message as sublist does not contain the
					 * number of entries indicated by sublist count
					 */
					_RIOutput (("RI ERROR: RI sublist contains %d entries, not %d entries",
					            ui16SubEntriesParsed,psRIEntry->ui16SubListCount));
				}
				else if (psRIEntry->ui16SubListCount && !dllist_get_next_node(&(psRIEntry->sSubListFirst)))
				{
					/*
					 * Output error message as sublist is empty but sublist count
					 * is not zero
					 */
					_RIOutput (("RI ERROR: ui16SubListCount=%d for empty RI sublist",
					            psRIEntry->ui16SubListCount));
				}
			}
			psRIEntry = NULL;
		}
	}
	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIDumpAllKM

 @Description
            Dumps out the contents of all RI List entries (i.e. for all
            MEMDESC allocations for each PMR).
            At present, output is directed to Kernel log
            via PVR_DPF.

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDumpAllKM(void)
{
	if (g_pRIHashTable)
	{
		return HASH_Iterate(g_pRIHashTable, (HASH_pfnCallback)_DumpAllEntries);
	}
	return PVRSRV_OK;
}

/*!
******************************************************************************

 @Function	RIDumpProcessKM

 @Description
            Dumps out the contents of all MEMDESC RI List entries (for every
            PMR) which have been allocate by the specified process only.
            At present, output is directed to Kernel log
            via PVR_DPF.

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDumpProcessKM(IMG_PID pid)
{
	PVRSRV_ERROR eError = PVRSRV_OK;
	IMG_UINT32  dummyPMR;

	if (g_pProcHashTable)
	{
		/* Acquire RI lock*/
		_RILock();

		eError = _DumpList((PMR *)&dummyPMR,pid);

	    /* Release RI lock*/
		_RIUnlock();
	}
	return eError;
}

#if defined(DEBUG)
/*!
******************************************************************************

 @Function	_DumpList
 @Description
            Dumps out RI List entries according to parameters passed.

 @input     hPMR - If not NULL, function will output the RI entries for
                   the specified PMR only
 @input     pid - If non-zero, the function will only output MEMDESC RI
  	  	  	  	  entries made by the process with ID pid.
                  If zero, all MEMDESC RI entries will be output.

 @Return	PVRSRV_ERROR

******************************************************************************/
static PVRSRV_ERROR _DumpProcessList(PMR *hPMR,
									 IMG_PID pid,
									 IMG_UINT64 ui64Offset,
									 IMG_DEV_VIRTADDR *psDevVAddr)
{
	RI_LIST_ENTRY *psRIEntry = NULL;
	RI_SUBLIST_ENTRY *psRISubEntry = NULL;
	IMG_UINT16 ui16SubEntriesParsed = 0;
	uintptr_t hashData = 0;
	PMR *pPMRHashKey = hPMR;
	PVRSRV_ERROR eError = PVRSRV_ERROR_INVALID_PARAMS;

	psDevVAddr->uiAddr = 0;

	if (!hPMR)
	{
		/* NULL handle provided */
		return eError;
	}

	if (g_pRIHashTable && g_pProcHashTable)
	{
		PVR_ASSERT(hPMR && pid);

		/* look-up hPMR in Hash Table */
		hashData = HASH_Retrieve_Extended (g_pRIHashTable, (void *)&pPMRHashKey);
		psRIEntry = (RI_LIST_ENTRY *)hashData;

		if (!psRIEntry)
		{
			/* No entry found in hash table */
			return PVRSRV_ERROR_NOT_FOUND;
		}

		if (psRIEntry->ui16SubListCount)
		{
			psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRIEntry->sSubListFirst)),
											RI_SUBLIST_ENTRY, sListNode);

			/* Traverse RI sublist and output details for each entry */
			while (psRISubEntry && (ui16SubEntriesParsed < psRIEntry->ui16SubListCount))
			{
				if (pid == psRISubEntry->pid)
				{
					IMG_UINT64 ui64StartOffset = psRISubEntry->ui64Offset;
					IMG_UINT64 ui64EndOffset = psRISubEntry->ui64Offset + psRISubEntry->ui64Size;

					if (ui64Offset >= ui64StartOffset && ui64Offset < ui64EndOffset)
					{
						psDevVAddr->uiAddr = psRISubEntry->sVAddr.uiAddr;
						return PVRSRV_OK;
					}
				}

				ui16SubEntriesParsed++;
				psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRISubEntry->sListNode)),
												RI_SUBLIST_ENTRY, sListNode);
			}
		}
	}

	return eError;
}

/*!
******************************************************************************

 @Function	RIDumpProcessListKM

 @Description
            Dumps out selected contents of all MEMDESC RI List entries (for a
            PMR) which have been allocate by the specified process only.

 @Return	PVRSRV_ERROR

******************************************************************************/
PVRSRV_ERROR RIDumpProcessListKM(PMR *hPMR,
								 IMG_PID pid,
								 IMG_UINT64 ui64Offset,
								 IMG_DEV_VIRTADDR *psDevVAddr)
{
	PVRSRV_ERROR eError = PVRSRV_OK;

	if (g_pProcHashTable)
	{
		/* Acquire RI lock*/
		_RILock();

		eError = _DumpProcessList(hPMR,
								  pid,
								  ui64Offset,
								  psDevVAddr);

		/* Release RI lock*/
		_RIUnlock();
	}

	return eError;
}
#endif

static PVRSRV_ERROR _DumpAllEntries (uintptr_t k, uintptr_t v)
{
	RI_LIST_ENTRY *psRIEntry = (RI_LIST_ENTRY *)v;

	PVR_UNREFERENCED_PARAMETER (k);

	return RIDumpListKM(psRIEntry->hPMR);
}

static PVRSRV_ERROR _DeleteAllEntries (uintptr_t k, uintptr_t v)
{
	RI_LIST_ENTRY *psRIEntry = (RI_LIST_ENTRY *)v;
	RI_SUBLIST_ENTRY *psRISubEntry;
	PVRSRV_ERROR eResult = PVRSRV_OK;

	PVR_UNREFERENCED_PARAMETER (k);

	while ((eResult == PVRSRV_OK) && (psRIEntry->ui16SubListCount > 0))
	{
		psRISubEntry = IMG_CONTAINER_OF(dllist_get_next_node(&(psRIEntry->sSubListFirst)), RI_SUBLIST_ENTRY, sListNode);
		eResult = RIDeleteMEMDESCEntryKM((RI_HANDLE)psRISubEntry);
	}
	if (eResult == PVRSRV_OK)
	{
		eResult = RIDeletePMREntryKM((RI_HANDLE)psRIEntry);
		/*
		 * If we've deleted the Hash table, return
		 * an error to stop the iterator...
		 */
		if (!g_pRIHashTable)
		{
			eResult = PVRSRV_ERROR_RESOURCE_UNAVAILABLE;
		}
	}
	return eResult;
}

static PVRSRV_ERROR _DeleteAllProcEntries (uintptr_t k, uintptr_t v)
{
	RI_SUBLIST_ENTRY *psRISubEntry = (RI_SUBLIST_ENTRY *)v;
	PVRSRV_ERROR eResult = PVRSRV_OK;

	PVR_UNREFERENCED_PARAMETER (k);

	eResult = RIDeleteMEMDESCEntryKM((RI_HANDLE) psRISubEntry);
	if (eResult == PVRSRV_OK && !g_pProcHashTable)
	{
		/*
		 * If we've deleted the Hash table, return
		 * an error to stop the iterator...
		 */
		eResult = PVRSRV_ERROR_RESOURCE_UNAVAILABLE;
	}

	return eResult;
}

#endif /* if defined(PVR_RI_DEBUG) */