1694 lines
41 KiB
C++
1694 lines
41 KiB
C++
/*
|
|
- QOS.CPP
|
|
-
|
|
* Microsoft NetMeeting
|
|
* Quality of Service DLL
|
|
* IQoS interfaces
|
|
*
|
|
* Revision History:
|
|
*
|
|
* When Who What
|
|
* -------- ------------------ ---------------------------------------
|
|
* 10.23.96 Yoram Yaacovi Created
|
|
*
|
|
* Functions:
|
|
* IQoS
|
|
* CQoS::QueryInterface
|
|
* CQoS::AddRef
|
|
* CQoS::Release
|
|
* CQoS::RequestResources
|
|
* CQoS::ReleaseResources
|
|
* CQoS::SetClients
|
|
* CQoS::SetResources
|
|
* CQoS::GetResources
|
|
* CQoS::FreeBuffer
|
|
* Public:
|
|
* CQoS::CQoS
|
|
* CQoS::~CQoS
|
|
* CQoS::Initialize
|
|
* Private
|
|
* CQoS::AnyRequests
|
|
* CQoS::FindClientsForResource
|
|
* CQoS::StoreResourceRequest
|
|
* CQoS::FreeResourceRequest
|
|
* CQoS::UpdateClientInfo
|
|
* CQoS::QoSCleanup
|
|
* CQoS::FindClient
|
|
* CQoS::UpdateRequestsForClient
|
|
* External
|
|
* CreateQoS
|
|
* QoSEntryPoint
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
EXTERN_C int g_cQoSObjects=0;
|
|
EXTERN_C HANDLE g_hQoSMutex=NULL;
|
|
class CQoS *g_pQoS;
|
|
|
|
#ifdef DEBUG
|
|
HDBGZONE ghDbgZoneQoS = NULL;
|
|
|
|
static PTCHAR _rgZonesQos[] = {
|
|
TEXT("qos"),
|
|
TEXT("Init"),
|
|
TEXT("IQoS"),
|
|
TEXT("Thread"),
|
|
TEXT("Structures"),
|
|
TEXT("Parameters"),
|
|
};
|
|
#endif /* DEBUG */
|
|
|
|
/***************************************************************************
|
|
|
|
Name : QoSCleanup
|
|
|
|
Purpose : Cleans up a QoS object before releasing (free memory, etc)
|
|
|
|
Parameters: pqos - pointer to a QoS pbject
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::QoSCleanup ()
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
LPRESOURCEINT pr=NULL;
|
|
LPCLIENTINT pc=NULL;
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
/*
|
|
* Free memory
|
|
*/
|
|
// traverse and free all the memory allocated by the QoS object
|
|
// resources and requests first
|
|
pr = m_pResourceList;
|
|
while (pr)
|
|
{
|
|
LPRESOURCEINT prNext=pr->fLink;
|
|
|
|
// first, delete the request list for this resource
|
|
FreeListOfRequests(&(pr->pRequestList));
|
|
|
|
MEMFREE(pr);
|
|
pr = prNext;
|
|
}
|
|
m_pResourceList = 0;
|
|
|
|
// next is clients
|
|
pc = m_pClientList;
|
|
while (pc)
|
|
{
|
|
LPCLIENTINT pcNext=pc->fLink;
|
|
|
|
// delete the request list for this client
|
|
FreeListOfRequests(&(pc->pRequestList));
|
|
|
|
// now delete the client itself
|
|
MEMFREE(pc);
|
|
pc = pcNext;
|
|
}
|
|
m_pClientList = 0;
|
|
|
|
// terminate the QoS thread and let it exit
|
|
// the thread should really be terminated when the last request
|
|
// is released, so this is just a safety measure
|
|
StopQoSThread();
|
|
|
|
// delete the events
|
|
if (m_evImmediateNotify)
|
|
CloseHandle(m_evImmediateNotify);
|
|
m_evImmediateNotify = NULL;
|
|
|
|
if (m_evThreadExitSignal)
|
|
CloseHandle(m_evThreadExitSignal);
|
|
m_evThreadExitSignal = NULL;
|
|
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : AnyRequests
|
|
|
|
Purpose : Finds out if there are any resource requests
|
|
|
|
Parameters: none
|
|
|
|
Returns : TRUE - there is at least one request
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
BOOL CQoS::AnyRequests(void)
|
|
{
|
|
LPRESOURCEINT pr=NULL;
|
|
BOOL bAnyRequests=FALSE;
|
|
|
|
pr = m_pResourceList;
|
|
while (pr)
|
|
{
|
|
if (pr->pRequestList)
|
|
{
|
|
bAnyRequests=TRUE;
|
|
break;
|
|
}
|
|
|
|
// next resource
|
|
pr = pr->fLink;
|
|
}
|
|
|
|
return bAnyRequests;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : FindClientsForResource
|
|
|
|
Purpose : Finds if there are clients for a specific resource
|
|
|
|
Parameters: [in] dwResourceID = the ID of the resource
|
|
[in] pc = client pointer to start searching from
|
|
[out] puSamePriClients = number of clients with the same
|
|
priority for this resource is returned here
|
|
[out] puLowerPriClients = number of clients with lower
|
|
priority for this resource is returned here
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : This function is NOT general purpose. It only counts clients
|
|
with the same priority DOWN the list.
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::FindClientsForResource( DWORD dwResourceID,
|
|
LPCLIENTINT pc,
|
|
ULONG *puSamePriClients,
|
|
ULONG *puLowerPriClients)
|
|
{
|
|
LPCLIENTINT pctemp=pc->fLink;
|
|
LPRESOURCEREQUESTINT pcrr=NULL;
|
|
|
|
*puLowerPriClients = 0;
|
|
*puSamePriClients = 1; // the first client (at 'pc')
|
|
while (pctemp)
|
|
{
|
|
LPRESOURCEINT pr=NULL;
|
|
|
|
// does this client need this specific resource ?
|
|
pcrr = pctemp->pRequestList;
|
|
while (pcrr)
|
|
{
|
|
if (pcrr->sResourceRequest.resourceID == dwResourceID)
|
|
{
|
|
// it is either a same priority client or a lower priority
|
|
// client (the list is sorted)
|
|
(pctemp->client.priority == pc->client.priority ?
|
|
(*puSamePriClients)++ :
|
|
(*puLowerPriClients)++);
|
|
break;
|
|
}
|
|
|
|
// next request for this client
|
|
pcrr = pcrr->fLink;
|
|
}
|
|
|
|
pctemp = pctemp->fLink;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : FreeListOfRequests
|
|
|
|
Purpose : Free all records of a linked list of requests, given the
|
|
address of the list pointer. Zero's the list pointer
|
|
|
|
Parameters: lppRequestList - address of the pointer to the beginning
|
|
of the list
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::FreeListOfRequests(LPRESOURCEREQUESTINT *lppRequestList)
|
|
{
|
|
LPRESOURCEREQUESTINT prr=*lppRequestList;
|
|
HRESULT hr=NOERROR;
|
|
|
|
while (prr)
|
|
{
|
|
LPRESOURCEREQUESTINT prrNext=prr->fLink;
|
|
|
|
MEMFREE(prr);
|
|
prr = prrNext;
|
|
}
|
|
|
|
*lppRequestList = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : FreeResourceRequest
|
|
|
|
Purpose : Frees resource units and respective resource requests
|
|
|
|
Parameters: pClientGUID - the GUID of the calling client (stream)
|
|
pnUnits - a pointer of where to return the number of units freed
|
|
pResourceInt - pointer to the resource being freed
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::FreeResourceRequest ( LPGUID pClientGUID,
|
|
LPRESOURCEINT pResourceInt,
|
|
int *pnUnits)
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
LPRESOURCEREQUESTINT prr=NULL, *prrPrev=NULL;
|
|
|
|
// find the request from this client
|
|
prr = pResourceInt->pRequestList;
|
|
prrPrev = &(pResourceInt->pRequestList);
|
|
while (prr)
|
|
{
|
|
if (COMPARE_GUIDS(&(prr->guidClientGUID), pClientGUID))
|
|
{
|
|
// we do have a request from this client.
|
|
// reclaim the units...
|
|
*pnUnits = prr->sResourceRequest.nUnitsMin;
|
|
|
|
// ...and remove it
|
|
*prrPrev = prr->fLink;
|
|
MEMFREE(prr);
|
|
|
|
// we're done.
|
|
hr = NOERROR;
|
|
goto out;
|
|
}
|
|
|
|
prrPrev = &(prr->fLink);
|
|
prr = prr->fLink;
|
|
}
|
|
|
|
hr = QOS_E_NO_SUCH_REQUEST;
|
|
|
|
out:
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : StoreResourceRequest
|
|
|
|
Purpose : Stores a resource request with the resource
|
|
|
|
Parameters: pClientGUID - the GUID of the calling client (stream)
|
|
pResourceRequest - the request to store
|
|
pfnQoSNotify - a pointer to a notification function for the
|
|
requesting client
|
|
pResourceInt - pointer to the resource on which to store the
|
|
request
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::StoreResourceRequest (LPGUID pClientGUID,
|
|
LPRESOURCEREQUEST pResourceRequest,
|
|
LPFNQOSNOTIFY pfnQoSNotify,
|
|
DWORD_PTR dwParam,
|
|
LPRESOURCEINT pResourceInt)
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
LPRESOURCEREQUESTINT prr=NULL, *prrPrev=NULL;
|
|
BOOL fRequestFound=FALSE;
|
|
|
|
/*
|
|
* Store the request
|
|
*/
|
|
|
|
// do we already have a request from this client ?
|
|
prr = pResourceInt->pRequestList;
|
|
prrPrev = &(pResourceInt->pRequestList);
|
|
while (prr)
|
|
{
|
|
if (COMPARE_GUIDS(&(prr->guidClientGUID), pClientGUID))
|
|
{
|
|
// we do have a request from this client. override it.
|
|
RtlCopyMemory( &(prr->sResourceRequest),
|
|
pResourceRequest,
|
|
sizeof(RESOURCEREQUEST));
|
|
RtlCopyMemory(&(prr->guidClientGUID), pClientGUID, sizeof(GUID));
|
|
prr->pfnQoSNotify = pfnQoSNotify;
|
|
prr->dwParam = dwParam;
|
|
|
|
// we're done.
|
|
hr = NOERROR;
|
|
fRequestFound = TRUE;
|
|
break;
|
|
}
|
|
|
|
prrPrev = &(prr->fLink);
|
|
prr = prr->fLink;
|
|
}
|
|
|
|
if (!fRequestFound)
|
|
{
|
|
// not found. make one
|
|
prr = (LPRESOURCEREQUESTINT) MEMALLOC(sizeof(RESOURCEREQUESTINT));
|
|
ASSERT(prr);
|
|
if (!prr)
|
|
{
|
|
ERRORMSG(("StoreResourceRequest: MEMALLOC failed on RESOURCEREQUESTINT\n"));
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
*prrPrev = prr;
|
|
prr->fLink = NULL;
|
|
|
|
}
|
|
|
|
// whether found or made, copy the contents in
|
|
RtlCopyMemory( &(prr->sResourceRequest),
|
|
pResourceRequest,
|
|
sizeof(RESOURCEREQUEST));
|
|
RtlCopyMemory(&(prr->guidClientGUID), pClientGUID, sizeof(GUID));
|
|
prr->pfnQoSNotify = pfnQoSNotify;
|
|
prr->dwParam = dwParam;
|
|
|
|
out:
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : UpdateClientInfo
|
|
|
|
Purpose : Updates the client info when a resource request is granted
|
|
|
|
Parameters: pClientGUID - the GUID of the calling client (stream)
|
|
pfnQoSNotify - a pointer to a notification function for the
|
|
requesting client
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::UpdateClientInfo (LPGUID pClientGUID,
|
|
LPFNQOSNOTIFY pfnQoSNotify)
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
LPCLIENTLIST pcl=NULL;
|
|
|
|
/*
|
|
* Update client info
|
|
*/
|
|
|
|
// we'll do this through calling the SetClients method
|
|
// allocate and fill a CLIENTLIST structure
|
|
pcl = (LPCLIENTLIST) MEMALLOC(sizeof(CLIENTLIST));
|
|
if (!pcl)
|
|
{
|
|
ERRORMSG(("UpdateClientInfo: MEMALLOC failed\n"));
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
RtlZeroMemory((PVOID) pcl, sizeof(CLIENTLIST));
|
|
|
|
// fill in the resource list
|
|
pcl->cClients = 1;
|
|
RtlCopyMemory(&(pcl->aClients[0].guidClientGUID), pClientGUID, sizeof(GUID));
|
|
pcl->aClients[0].priority = QOS_LOWEST_PRIORITY;
|
|
|
|
// set the clients info on the QoS module
|
|
hr = SetClients(pcl);
|
|
|
|
out:
|
|
if (pcl)
|
|
MEMFREE(pcl);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : UpdateRequestsForClient
|
|
|
|
Purpose : Update a client's request list by finding all existing resource
|
|
requests for this client
|
|
|
|
Parameters: pClientGUID - the GUID of the calling client (stream)
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::UpdateRequestsForClient (LPGUID pClientGUID)
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
LPRESOURCEINT pr=NULL;
|
|
LPCLIENTINT pc=NULL;
|
|
LPRESOURCEREQUESTINT prr=NULL, *pcrrfLink=NULL, pcrr=NULL;
|
|
|
|
/*
|
|
* get rid of the current request list for this client
|
|
*/
|
|
// find the client first
|
|
hr = FindClient(pClientGUID, &pc);
|
|
if (FAILED(hr) || !pc)
|
|
{
|
|
hr = QOS_E_NO_SUCH_CLIENT;
|
|
goto out;
|
|
}
|
|
|
|
// now delete old request list
|
|
FreeListOfRequests(&(pc->pRequestList));
|
|
|
|
/*
|
|
* create and add the new request list
|
|
*/
|
|
pr = m_pResourceList;
|
|
pcrrfLink = &(pc->pRequestList);
|
|
while (pr)
|
|
{
|
|
prr = pr->pRequestList;
|
|
while (prr)
|
|
{
|
|
if (COMPARE_GUIDS(&(prr->guidClientGUID), pClientGUID))
|
|
{
|
|
// we found a request from this client.
|
|
// allocate memory for it, and copy it in
|
|
pcrr = (LPRESOURCEREQUESTINT) MEMALLOC(sizeof(RESOURCEREQUESTINT));
|
|
ASSERT(pcrr);
|
|
if (!pcrr)
|
|
{
|
|
ERRORMSG(("UpdateRequestsForClient: MEMALLOC failed on RESOURCEREQUESTINT\n"));
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
// copy the contents in
|
|
RtlCopyMemory(pcrr, prr, sizeof(RESOURCEREQUESTINT));
|
|
|
|
// need a different fLink for the client request list
|
|
*pcrrfLink = pcrr;
|
|
pcrr->fLink = NULL;
|
|
pcrrfLink = &(pcrr->fLink);
|
|
}
|
|
|
|
// next request
|
|
prr = prr->fLink;
|
|
}
|
|
|
|
// next resource
|
|
pr = pr->fLink;
|
|
}
|
|
|
|
out:
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : FindClient
|
|
|
|
Purpose : Finds and returns a client record
|
|
|
|
Parameters: pClientGUID - the GUID whose record to find
|
|
ppClient - address of where to put a pointer to the client found
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::FindClient(LPGUID pClientGUID, LPCLIENTINT *ppClient)
|
|
{
|
|
LPCLIENTINT pc=NULL;
|
|
HRESULT hr=NOERROR;
|
|
|
|
*ppClient = NULL;
|
|
pc = m_pClientList;
|
|
while (pc)
|
|
{
|
|
if (COMPARE_GUIDS(&(pc->client.guidClientGUID), pClientGUID))
|
|
{
|
|
*ppClient = pc;
|
|
goto out;
|
|
}
|
|
|
|
// next client
|
|
pc = pc->fLink;
|
|
}
|
|
|
|
hr = QOS_E_NO_SUCH_CLIENT;
|
|
|
|
out:
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
IUnknown Methods
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::QueryInterface (REFIID riid, LPVOID *lppNewObj)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::QueryInterface\n"));
|
|
|
|
if (IsBadReadPtr(&riid, (UINT) sizeof(IID)))
|
|
{
|
|
hr = ResultFromScode(E_INVALIDARG);
|
|
goto out;
|
|
}
|
|
|
|
if (IsBadWritePtr(lppNewObj, sizeof(LPVOID)))
|
|
{
|
|
hr = ResultFromScode(E_INVALIDARG);
|
|
goto out;
|
|
}
|
|
|
|
*lppNewObj = 0;
|
|
if (riid == IID_IUnknown || riid == IID_IQoS)
|
|
*lppNewObj = (IQoS *) this;
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
goto out;
|
|
}
|
|
|
|
((IUnknown *)*lppNewObj)->AddRef ();
|
|
|
|
out:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::QueryInterface - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
ULONG CQoS::AddRef (void)
|
|
{
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::AddRef\n"));
|
|
|
|
InterlockedIncrement((long *) &m_cRef);
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::AddRef - leave, m_cRef=%d\n", m_cRef));
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
ULONG CQoS::Release (void)
|
|
{
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::Release\n"));
|
|
|
|
// if the cRef is already 0 (shouldn't happen), assert, but let it through
|
|
ASSERT(m_cRef);
|
|
|
|
if (InterlockedDecrement((long *) &m_cRef) == 0)
|
|
{
|
|
if (m_bQoSEnabled)
|
|
QoSCleanup();
|
|
delete this;
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::Final Release\n"));
|
|
return 0;
|
|
}
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::Release - leave, m_cRef=%d\n", m_cRef));
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::RequestResources
|
|
|
|
Purpose : Requests resources
|
|
|
|
Parameters: lpStreamGUID - the GUID of the calling client (stream)
|
|
lpResourceRequestList - a list of resource requests that
|
|
the caller wants to reserve
|
|
lpfnQoSNotify - a pointer to a notification function for the
|
|
requesting client
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::RequestResources (LPGUID lpClientGUID,
|
|
LPRESOURCEREQUESTLIST lpResourceRequestList,
|
|
LPFNQOSNOTIFY lpfnQoSNotify,
|
|
DWORD_PTR dwParam)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
ULONG i;
|
|
BOOL fResourceFound=FALSE, fRequestGranted=FALSE;
|
|
LPRESOURCEINT pResourceInt=NULL, *pPrevResourcefLink=NULL;
|
|
RESOURCEREQUEST *pResourceRequest=NULL;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::RequestResources\n"));
|
|
|
|
/*
|
|
* Parameter validation
|
|
*/
|
|
|
|
// lpResourceRequestList should at least have a count DWORD
|
|
// must have a GUID and a notify callback
|
|
if (!lpResourceRequestList ||
|
|
IsBadReadPtr(lpResourceRequestList, (UINT) sizeof(DWORD)) ||
|
|
!lpClientGUID ||
|
|
!lpfnQoSNotify)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto out_nomutex;
|
|
}
|
|
|
|
DISPLAYPARAMETERS( REQUEST_RESOURCES_ID,
|
|
lpClientGUID,
|
|
lpResourceRequestList,
|
|
lpfnQoSNotify,
|
|
dwParam,
|
|
0);
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
if (!m_bQoSEnabled)
|
|
// just return
|
|
goto out;
|
|
|
|
/*
|
|
* Find and allocate the resources
|
|
*/
|
|
|
|
// for each requested resource
|
|
pResourceRequest=lpResourceRequestList->aRequests;
|
|
for (i=0; i < lpResourceRequestList->cRequests; i++)
|
|
{
|
|
pResourceInt = m_pResourceList;
|
|
fResourceFound = FALSE;
|
|
// find the resource
|
|
while (pResourceInt)
|
|
{
|
|
if (pResourceInt->resource.resourceID == pResourceRequest[i].resourceID)
|
|
{ // resource found
|
|
// see if the resource is available
|
|
// priority will be handled at the first notify callback
|
|
// CHECK: add nUnitsMax handling
|
|
if (pResourceRequest[i].nUnitsMin <= pResourceInt->nNowAvailUnits)
|
|
{
|
|
// resource is available. take the requested share.
|
|
pResourceInt->nNowAvailUnits -= pResourceRequest[i].nUnitsMin;
|
|
|
|
// store a local copy of the request
|
|
pResourceRequest[i].hResult = StoreResourceRequest(lpClientGUID,
|
|
&(pResourceRequest[i]),
|
|
lpfnQoSNotify,
|
|
dwParam,
|
|
pResourceInt);
|
|
// if we failed storing, propagate the result to the bottom line
|
|
// returned result
|
|
if (FAILED(pResourceRequest[i].hResult))
|
|
{
|
|
hr = pResourceRequest[i].hResult;
|
|
}
|
|
else
|
|
{ // at least one request was granted to this client
|
|
fRequestGranted = TRUE;
|
|
}
|
|
}
|
|
else // resource not available
|
|
{
|
|
// let the client know how much is available
|
|
pResourceRequest[i].nUnitsMin = pResourceInt->nNowAvailUnits;
|
|
pResourceRequest[i].hResult = QOS_E_RES_NOT_ENOUGH_UNITS;
|
|
hr = QOS_E_REQ_ERRORS;
|
|
}
|
|
|
|
fResourceFound = TRUE;
|
|
|
|
break;
|
|
}
|
|
|
|
// not this one. try next one.
|
|
pResourceInt = pResourceInt->fLink;
|
|
|
|
} // while
|
|
|
|
if (!fResourceFound)
|
|
{
|
|
pResourceRequest[i].hResult = QOS_E_RES_NOT_AVAILABLE;
|
|
hr = QOS_E_REQ_ERRORS;
|
|
}
|
|
|
|
// next request
|
|
} // for
|
|
|
|
// if we allocated resources to this client, add it to the client list,
|
|
// provided that it is not already in the list
|
|
// special case: if the call to RequestResources was made from the QoS
|
|
// notification proc, no need to update the client info. Actually, it will
|
|
// be bad to do this, since we are traversing the client list in the
|
|
// notify proc right at this moment...
|
|
if (fRequestGranted && !m_bInNotify)
|
|
{ // add (or update) the client list with this client
|
|
HRESULT hrTemp=NOERROR;
|
|
LPCLIENTINT pc=NULL;
|
|
|
|
// if the client is not already in the client list - add it
|
|
FindClient(lpClientGUID, &pc);
|
|
if (!pc)
|
|
{
|
|
hrTemp = UpdateClientInfo (lpClientGUID, lpfnQoSNotify);
|
|
if (FAILED(hrTemp))
|
|
hr = hrTemp;
|
|
}
|
|
|
|
// also, make a note that RequestResources has been called. This will
|
|
// make the QoS thread skip one heartbeat in order not call a client
|
|
// too early
|
|
m_nSkipHeartBeats = 1;
|
|
|
|
// we have at least one request, so spawn the QoS thread, if not
|
|
// already running
|
|
if (!m_hThread)
|
|
hrTemp = StartQoSThread();
|
|
|
|
}
|
|
|
|
out:
|
|
DISPLAYQOSOBJECT();
|
|
RELMUTEX(g_hQoSMutex);
|
|
out_nomutex:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::RequestResources - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::ReleaseResources
|
|
|
|
Purpose : Releases resources
|
|
|
|
Parameters: lpClientGUID - the GUID of the calling client (stream)
|
|
lpResourceRequestList - a list of resource requests that
|
|
the caller wants to reserve
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : The values in the resource list are ignored. The resources
|
|
specified are freed.
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::ReleaseResources (LPGUID lpClientGUID,
|
|
LPRESOURCEREQUESTLIST lpResourceRequestList)
|
|
{
|
|
ULONG i;
|
|
int nUnits=0;
|
|
BOOL fResourceFound=FALSE;
|
|
LPRESOURCEINT pResourceInt=NULL, *pPrevResourcefLink=NULL;
|
|
RESOURCEREQUEST *pResourceRequest=NULL;
|
|
HRESULT hr = NOERROR;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::ReleaseResources\n"));
|
|
|
|
/*
|
|
* parameter validation
|
|
*/
|
|
|
|
// lpResourceRequestList should at least have a count DWORD
|
|
if (!lpResourceRequestList ||
|
|
IsBadReadPtr(lpResourceRequestList, (UINT) sizeof(DWORD)))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto out_nomutex;
|
|
}
|
|
|
|
DISPLAYPARAMETERS( RELEASE_RESOURCES_ID,
|
|
lpClientGUID,
|
|
lpResourceRequestList,
|
|
0,
|
|
0,
|
|
0);
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
if (!m_bQoSEnabled)
|
|
// just return
|
|
goto out;
|
|
|
|
// for each requested resource
|
|
pResourceRequest=lpResourceRequestList->aRequests;
|
|
for (i=0; i < lpResourceRequestList->cRequests; i++)
|
|
{
|
|
// make sure we start with no error (caller might not cleared last hresult)
|
|
pResourceRequest[i].hResult = NOERROR;
|
|
pResourceInt = m_pResourceList;
|
|
fResourceFound = FALSE;
|
|
// find the resource
|
|
while (pResourceInt)
|
|
{
|
|
if (pResourceInt->resource.resourceID == pResourceRequest[i].resourceID)
|
|
{ // resource found
|
|
// free the local copy of the request
|
|
pResourceRequest[i].hResult = FreeResourceRequest(lpClientGUID,
|
|
pResourceInt,
|
|
&nUnits);
|
|
|
|
// if succeeded, claim the units back
|
|
if (SUCCEEDED(pResourceRequest[i].hResult) && (nUnits >= 0))
|
|
{
|
|
// add the freed units
|
|
pResourceInt->nNowAvailUnits += nUnits;
|
|
// in case something went wrong and we now have more available units
|
|
// than total ones
|
|
// NOTE: the ASSERT below is no longer proper. If SetResources was called,
|
|
// and decreased the total units for a resource while there were
|
|
// requests on this resource, the available units for this resource
|
|
// might exceed the total one if released. Since QoS will auto-repair
|
|
// this in the next notify cycle, the window for this is very small
|
|
// ASSERT(!(pResourceInt->nNowAvailUnits > pResourceInt->resource.nUnits));
|
|
if (pResourceInt->nNowAvailUnits > pResourceInt->resource.nUnits)
|
|
{ // we don't want to have more available units than total
|
|
pResourceInt->nNowAvailUnits = pResourceInt->resource.nUnits;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no such request
|
|
pResourceRequest[i].hResult = QOS_E_NO_SUCH_REQUEST;
|
|
hr = QOS_E_REQ_ERRORS;
|
|
}
|
|
|
|
fResourceFound = TRUE;
|
|
|
|
break;
|
|
}
|
|
|
|
// not this one. try next one.
|
|
pResourceInt = pResourceInt->fLink;
|
|
|
|
} // while
|
|
|
|
if (!fResourceFound)
|
|
{
|
|
pResourceRequest[i].hResult = QOS_E_NO_SUCH_RESOURCE;
|
|
hr = QOS_E_REQ_ERRORS;
|
|
}
|
|
|
|
// next request
|
|
}
|
|
|
|
// if no requests left, can let the notification thread go...
|
|
if (m_hThread &&
|
|
!AnyRequests())
|
|
{
|
|
// stop the thread
|
|
StopQoSThread();
|
|
}
|
|
|
|
out:
|
|
DISPLAYQOSOBJECT();
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
out_nomutex:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::ReleaseResources - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::SetResources
|
|
|
|
Purpose : Sets the available resources on the QoS module
|
|
|
|
Parameters: lpResourceList - list of resources and their availability
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::SetResources (LPRESOURCELIST lpResourceList)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
ULONG i;
|
|
BOOL fResourceFound=FALSE;
|
|
LPRESOURCEINT pResourceInt=NULL, *pPrevResourcefLink=NULL;
|
|
RESOURCE *pResource=NULL;
|
|
|
|
RegEntry reQoSResourceRoot(REGKEY_QOS_RESOURCES,
|
|
HKEY_LOCAL_MACHINE,
|
|
FALSE,
|
|
KEY_READ);
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::SetResources\n"));
|
|
|
|
/*
|
|
* parameter validation
|
|
*/
|
|
|
|
// lpResourceList should at least have a count DWORD
|
|
if (!lpResourceList || IsBadReadPtr(lpResourceList, (UINT) sizeof(DWORD)))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto out_nomutex;
|
|
}
|
|
|
|
DISPLAYPARAMETERS( SET_RESOURCES_ID,
|
|
lpResourceList,
|
|
0,
|
|
0,
|
|
0,
|
|
0);
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
if (!m_bQoSEnabled)
|
|
// just return
|
|
goto out;
|
|
|
|
/*
|
|
* Get configurable resource info
|
|
*/
|
|
|
|
pResource=lpResourceList->aResources;
|
|
for (i=0; i < lpResourceList->cResources; i++)
|
|
{
|
|
TCHAR szKey[10]; // should be way enough for a resource ID
|
|
int nUnits=INT_MAX;
|
|
int nLeaveUnused=0;
|
|
|
|
// build and open the key
|
|
wsprintf(szKey, "%d", pResource[i].resourceID);
|
|
|
|
RegEntry reQosResource(szKey, reQoSResourceRoot.GetKey(), FALSE, KEY_READ);
|
|
|
|
|
|
// MaxUnits:
|
|
// run through the list of resources and make sure none of the
|
|
// resources was set to a number of units above the allowed maximum
|
|
// if it was, trim and warn
|
|
|
|
// get maximum numbers for the resource, if any, from the registry
|
|
nUnits = reQosResource.GetNumberIniStyle(TEXT("MaxUnits"), INT_MAX);
|
|
|
|
// is the client trying to set the resource to a higher value ?
|
|
if (pResource[i].nUnits > nUnits)
|
|
{
|
|
pResource[i].nUnits = nUnits;
|
|
hr = QOS_W_MAX_UNITS_EXCEEDED;
|
|
}
|
|
|
|
// LeaveUnused:
|
|
// leave some of the resource unused, as configured
|
|
|
|
// use different default value depending on the resource
|
|
switch (pResource[i].resourceID)
|
|
{
|
|
case RESOURCE_OUTGOING_BANDWIDTH:
|
|
nLeaveUnused = 30;
|
|
break;
|
|
default:
|
|
nLeaveUnused = 10;
|
|
break;
|
|
}
|
|
|
|
nLeaveUnused = reQosResource.GetNumberIniStyle( TEXT("LeaveUnused"),
|
|
nLeaveUnused);
|
|
|
|
pResource[i].nUnits = (pResource[i].nUnits * (100 - nLeaveUnused)) / 100;
|
|
}
|
|
|
|
/*
|
|
* Add the resource to the list
|
|
*/
|
|
|
|
// run through the input resource list and store the resources
|
|
// resource availability is NOT accumulative
|
|
pResource=lpResourceList->aResources;
|
|
for (i=0; i < lpResourceList->cResources; i++)
|
|
{
|
|
pResourceInt = m_pResourceList;
|
|
pPrevResourcefLink = &m_pResourceList;
|
|
fResourceFound = FALSE;
|
|
while (pResourceInt != 0)
|
|
{
|
|
if (pResourceInt->resource.resourceID == pResource[i].resourceID)
|
|
{ // found a match
|
|
// did the total number of units change for this resource ?
|
|
if (pResourceInt->resource.nUnits != pResource[i].nUnits)
|
|
{
|
|
// update the now available units
|
|
// since we could end up with less units than what was allocated
|
|
// we are issuing a NotifyNow at the end of this call
|
|
pResourceInt->nNowAvailUnits = pResource[i].nUnits -
|
|
(pResourceInt->resource.nUnits -
|
|
pResourceInt->nNowAvailUnits);
|
|
if (pResourceInt->nNowAvailUnits < 0)
|
|
pResourceInt->nNowAvailUnits = 0;
|
|
}
|
|
|
|
// override the previous setting
|
|
RtlCopyMemory( &(pResourceInt->resource),
|
|
&(pResource[i]),
|
|
sizeof(RESOURCE));
|
|
fResourceFound = TRUE;
|
|
break;
|
|
}
|
|
|
|
// not this one. try next one.
|
|
pPrevResourcefLink = &(pResourceInt->fLink);
|
|
pResourceInt = pResourceInt->fLink;
|
|
|
|
} // while
|
|
|
|
if (fResourceFound)
|
|
continue;
|
|
|
|
// not found. add the resource
|
|
pResourceInt = (LPRESOURCEINT) MEMALLOC(sizeof(RESOURCEINT));
|
|
ASSERT(pResourceInt);
|
|
if (!pResourceInt)
|
|
{
|
|
ERRORMSG(("IQoS::SetResources: MEMALLOC failed on RESOURCEINT\n"));
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
// copy the resource in
|
|
RtlCopyMemory( &(pResourceInt->resource),
|
|
&(pResource[i]),
|
|
sizeof(RESOURCE));
|
|
pResourceInt->fLink = NULL;
|
|
pResourceInt->nNowAvailUnits = pResourceInt->resource.nUnits;
|
|
*pPrevResourcefLink = pResourceInt;
|
|
|
|
// increment the number of resources we're tracking
|
|
// this number will never go down
|
|
m_cResources++;
|
|
|
|
// next resource
|
|
|
|
} // for
|
|
|
|
// since there was a possible change in the resource availability,
|
|
// run an immediate notification cycle
|
|
if (SUCCEEDED(hr))
|
|
NotifyNow();
|
|
|
|
out:
|
|
DISPLAYQOSOBJECT();
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
out_nomutex:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::SetResources - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::GetResources
|
|
|
|
Purpose : Gets the list of resources available to the QoS module
|
|
|
|
Parameters: lppResourceList - an address where QoS will place a pointer
|
|
to a buffer with the list of resources available to QoS.
|
|
The caller must use CQoS::FreeBuffer to free this buffer.
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::GetResources (LPRESOURCELIST *lppResourceList)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
ULONG i;
|
|
LPRESOURCELIST prl=NULL;
|
|
LPRESOURCEINT pResourceInt=NULL;
|
|
RESOURCE *pResource=NULL;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::GetResources\n"));
|
|
|
|
/*
|
|
* parameter validation
|
|
*/
|
|
|
|
// lpResourceList should at least have a count DWORD
|
|
if (!lppResourceList || IsBadWritePtr(lppResourceList, (UINT) sizeof(DWORD)))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto out_nomutex;
|
|
}
|
|
|
|
// no list yet
|
|
*lppResourceList = NULL;
|
|
|
|
if (!m_bQoSEnabled)
|
|
// just return
|
|
goto out_nomutex;
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
/*
|
|
* Get resource info
|
|
*/
|
|
|
|
// allocate a buffer for the resources info
|
|
prl = (LPRESOURCELIST) MEMALLOC(sizeof(RESOURCELIST) +
|
|
((LONG_PTR)m_cResources-1)*sizeof(RESOURCE));
|
|
if (!prl)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
ERRORMSG(("GetResources: MEMALLOC failed\n"));
|
|
goto out;
|
|
}
|
|
|
|
RtlZeroMemory((PVOID) prl, sizeof(RESOURCELIST) +
|
|
((LONG_PTR)m_cResources-1)*sizeof(RESOURCE));
|
|
|
|
// now fill in the information
|
|
prl->cResources = m_cResources;
|
|
pResourceInt=m_pResourceList;
|
|
for (i=0; i < m_cResources; i++)
|
|
{
|
|
ASSERT(pResourceInt);
|
|
|
|
// see if we have a NULL resource pointer
|
|
// shouldn't happen, but we shouldn't crash if it does
|
|
if (!pResourceInt)
|
|
{
|
|
hr = QOS_E_INTERNAL_ERROR;
|
|
ERRORMSG(("GetResources: bad QoS internal resource list\n"));
|
|
goto out;
|
|
}
|
|
|
|
// copy the resource info into the buffer
|
|
RtlCopyMemory( &(prl->aResources[i]),
|
|
&(pResourceInt->resource),
|
|
sizeof(RESOURCE));
|
|
|
|
// next resource
|
|
pResourceInt = pResourceInt->fLink;
|
|
} // for
|
|
|
|
*lppResourceList = prl;
|
|
|
|
out:
|
|
DISPLAYQOSOBJECT();
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
out_nomutex:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::GetResources - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::SetClients
|
|
|
|
Purpose : Tells the QoS module what are the priorities of the requesting
|
|
streams. This allows the QoS module to allocate resources
|
|
appropriately.
|
|
|
|
Parameters: lpClientList - list of clients and their respective
|
|
priorities
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : client info will override an already existing info for this
|
|
client
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::SetClients(LPCLIENTLIST lpClientList)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
ULONG i;
|
|
BOOL fClientFound=FALSE;
|
|
LPCLIENTINT pClientInt=NULL, *pPrevClientfLink=NULL, pClientNew=NULL;;
|
|
LPCLIENT pClient=NULL;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::SetClients\n"));
|
|
|
|
/*
|
|
* parameter validation
|
|
*/
|
|
|
|
// lpClientList should at least have a count DWORD
|
|
if (!lpClientList || IsBadReadPtr(lpClientList, (UINT) sizeof(DWORD)))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
goto out_nomutex;
|
|
}
|
|
|
|
DISPLAYPARAMETERS( SET_CLIENTS_ID,
|
|
lpClientList,
|
|
0,
|
|
0,
|
|
0,
|
|
0);
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
if (!m_bQoSEnabled)
|
|
// just return
|
|
goto out;
|
|
|
|
// first remove existing clients that are being set again
|
|
// this will make it easier to store clients in a priority order
|
|
pClient=lpClientList->aClients;
|
|
for (i=0; i < lpClientList->cClients; i++)
|
|
{
|
|
pClientInt = m_pClientList;
|
|
pPrevClientfLink = &m_pClientList;
|
|
fClientFound = FALSE;
|
|
while (pClientInt != 0)
|
|
{
|
|
if (COMPARE_GUIDS( &(pClientInt->client.guidClientGUID),
|
|
&(pClient[i].guidClientGUID)))
|
|
{ // found a match
|
|
LPCLIENTINT pClientIntNext=pClientInt->fLink;
|
|
|
|
// special case for internal calls from RequestResources
|
|
// we want to preserve the original priority before freeing
|
|
if (pClient[i].priority == QOS_LOWEST_PRIORITY)
|
|
pClient[i].priority = pClientInt->client.priority;
|
|
|
|
// free the requests for this client
|
|
// NOTE: we're not going to recreate the request list from
|
|
// the one in the resource list. it will be created on the
|
|
// fly when needed.
|
|
FreeListOfRequests(&(pClientInt->pRequestList));
|
|
|
|
// free the client record
|
|
MEMFREE(pClientInt);
|
|
*pPrevClientfLink = pClientIntNext;
|
|
fClientFound = TRUE;
|
|
break;
|
|
}
|
|
|
|
// not this one. try next one.
|
|
pPrevClientfLink = &(pClientInt->fLink);
|
|
pClientInt = pClientInt->fLink;
|
|
|
|
} // while
|
|
|
|
// next resource
|
|
|
|
} // for
|
|
|
|
// now store the clients in the input list in priority order
|
|
pClient=lpClientList->aClients;
|
|
for (i=0; i < lpClientList->cClients; i++)
|
|
{
|
|
pClientInt = m_pClientList;
|
|
pPrevClientfLink = &m_pClientList;
|
|
while (pClientInt != 0)
|
|
{
|
|
// as long as the priority of the new client is higher than or equal to the one
|
|
// in the list, we continue to traverse the list
|
|
if (pClient[i].priority < pClientInt->client.priority)
|
|
{ // this is the place to insert this client
|
|
break;
|
|
}
|
|
|
|
// not time to insert yet. next client
|
|
pPrevClientfLink = &(pClientInt->fLink);
|
|
pClientInt = pClientInt->fLink;
|
|
|
|
} // while
|
|
|
|
// not found. add the client
|
|
pClientNew = (LPCLIENTINT) MEMALLOC(sizeof(CLIENTINT));
|
|
ASSERT(pClientNew);
|
|
if (!pClientNew)
|
|
{
|
|
ERRORMSG(("IQoS::SetClients: MEMALLOC failed on CLIENTINT\n"));
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
// copy the resource in
|
|
RtlCopyMemory( &(pClientNew->client),
|
|
&(pClient[i]),
|
|
sizeof(CLIENT));
|
|
pClientNew->fLink = pClientInt;
|
|
*pPrevClientfLink = pClientNew;
|
|
|
|
// next resource
|
|
|
|
} // for
|
|
|
|
out:
|
|
DISPLAYQOSOBJECT();
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
out_nomutex:
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::SetClients -leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::NotifyNow
|
|
|
|
Purpose : Tells the QoS module to initiate a notification cycle as
|
|
soon as possible.
|
|
|
|
Parameters: None
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : Don't call from within a notify proc.
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::NotifyNow(void)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::NotifyNow\n"));
|
|
|
|
SetEvent(m_evImmediateNotify);
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::NotifyNow - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::FreeBuffer
|
|
|
|
Purpose : Frees a buffer allocated by the QoS module.
|
|
|
|
Parameters: lpBuffer - a pointer to the buffer to free. This buffer must
|
|
have been allocated by QoS
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::FreeBuffer(LPVOID lpBuffer)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::FreeBuffer\n"));
|
|
|
|
if (lpBuffer)
|
|
MEMFREE(lpBuffer);
|
|
|
|
DEBUGMSG(ZONE_IQOS,("IQoS::FreeBuffer - leave, hr=0x%x\n", hr));
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::CQoS
|
|
|
|
Purpose : The CQoS object constructor
|
|
|
|
Parameters: none
|
|
|
|
Returns : None
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
inline CQoS::CQoS (void)
|
|
{
|
|
m_cRef = 0; // will be bumped to 1 by the explicit QI in CreateQoS
|
|
m_pResourceList = NULL;
|
|
m_cResources = 0;
|
|
m_pClientList = NULL;
|
|
m_evThreadExitSignal = NULL;
|
|
m_evImmediateNotify = NULL;
|
|
m_hThread = NULL;
|
|
m_bQoSEnabled = TRUE;
|
|
m_bInNotify = FALSE;
|
|
m_nSkipHeartBeats = 0;
|
|
m_hWnd = NULL;
|
|
m_nLeaveForNextPri = 5;
|
|
// can't use ++ because RISC processors may translate to several instructions
|
|
InterlockedIncrement((long *) &g_cQoSObjects);
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::~CQoS
|
|
|
|
Purpose : The CQoS object destructor
|
|
|
|
Parameters: none
|
|
|
|
Returns : None
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
inline CQoS::~CQoS (void)
|
|
{
|
|
// can't use ++ because RISC processors may translate to several instructions
|
|
InterlockedDecrement((long *) &g_cQoSObjects);
|
|
g_pQoS = (CQoS *)NULL;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CQoS::Initialize
|
|
|
|
Purpose : Initializes the QoS object
|
|
|
|
Parameters: None
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT CQoS::Initialize(void)
|
|
{
|
|
HRESULT hr=NOERROR;
|
|
OSVERSIONINFO tVersionInfo;
|
|
|
|
/*
|
|
* Initialize the object
|
|
*/
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
|
|
// first see if QoS is enabled
|
|
RegEntry reQoS(QOS_KEY,
|
|
HKEY_LOCAL_MACHINE,
|
|
FALSE,
|
|
KEY_READ);
|
|
|
|
m_bQoSEnabled = reQoS.GetNumberIniStyle(TEXT("Enable"), TRUE);
|
|
|
|
if (!m_bQoSEnabled)
|
|
{
|
|
// don't create a thread, but return success
|
|
DEBUGMSG(ZONE_IQOS,("Initialize: QoS not enabled\n"));
|
|
hr = NOERROR;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* QoS notification thread
|
|
*/
|
|
|
|
// create an event that will be used to signal the thread to terminate
|
|
// CreateEvent(No security attr's, no manual reset, not signalled, no name)
|
|
m_evThreadExitSignal = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
ASSERT(m_evThreadExitSignal);
|
|
if (!(m_evThreadExitSignal))
|
|
{
|
|
ERRORMSG(("Initialize: Exit event creation failed: %x\n", GetLastError()));
|
|
hr = E_FAIL;
|
|
goto out;
|
|
}
|
|
|
|
// create an event that will be used to signal the thread to initiate
|
|
// an immediate notify cycle
|
|
// CreateEvent(No security attr's, no manual reset, not signalled, no name)
|
|
m_evImmediateNotify = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
ASSERT(m_evImmediateNotify);
|
|
if (!(m_evImmediateNotify))
|
|
{
|
|
ERRORMSG(("Initialize: Immediate notify event creation failed: %x\n", GetLastError()));
|
|
hr = E_FAIL;
|
|
goto out;
|
|
}
|
|
|
|
|
|
//Set the OS flag
|
|
tVersionInfo.dwOSVersionInfoSize=sizeof (OSVERSIONINFO);
|
|
if (!(GetVersionEx (&tVersionInfo))) {
|
|
ERRORMSG(("Initialize: Couldn't get version info: %x\n", GetLastError()));
|
|
hr = E_FAIL;
|
|
goto out;
|
|
}
|
|
|
|
if (tVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
|
|
bWin9x=TRUE;
|
|
}else {
|
|
if (tVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
|
bWin9x=FALSE;
|
|
}else {
|
|
//How on earth did we get here?
|
|
ASSERT (0);
|
|
hr=E_FAIL;
|
|
goto out;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
out:
|
|
RELMUTEX(g_hQoSMutex);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CreateQoS
|
|
|
|
Purpose : Creates the QoS object and return an IQoS interface pointer
|
|
|
|
Parameters:
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : CreateQoS will only create one instance of the QoS object.
|
|
Additional calls will return the same interface pointer
|
|
|
|
***************************************************************************/
|
|
extern "C" HRESULT WINAPI CreateQoS ( IUnknown *punkOuter,
|
|
REFIID riid,
|
|
void **ppv)
|
|
{
|
|
CQoS *pQoS;
|
|
HRESULT hr = NOERROR;
|
|
|
|
*ppv = 0;
|
|
if (punkOuter)
|
|
return CLASS_E_NOAGGREGATION;
|
|
|
|
/*
|
|
* instantiate the QoS object
|
|
*/
|
|
|
|
ACQMUTEX(g_hQoSMutex);
|
|
|
|
// only instantiate a new object if it doesn't already exist
|
|
if (g_cQoSObjects == 0)
|
|
{
|
|
if (!(pQoS = new CQoS))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto out;
|
|
}
|
|
|
|
// Save pointer
|
|
g_pQoS = pQoS;
|
|
|
|
// initialize the QoS object
|
|
hr = pQoS->Initialize();
|
|
|
|
}
|
|
else
|
|
{
|
|
// this is the case when the object was already instantiaed in this
|
|
// process, so we only want to return the object pointer.
|
|
pQoS = g_pQoS;
|
|
}
|
|
|
|
// must have only one QoS object at this point
|
|
ASSERT(g_cQoSObjects == 1);
|
|
|
|
RELMUTEX(g_hQoSMutex);
|
|
|
|
// get the IQoS interface for the caller
|
|
if (pQoS)
|
|
{
|
|
// QueryInterface will get us the interface pointer and will AddRef
|
|
// the object
|
|
hr = pQoS->QueryInterface (riid, ppv);
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
|
|
out:
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : QoSEntryPoint
|
|
|
|
Purpose : Called by nac.dll (where the QoS lives these days) to make
|
|
the necessary process attach and detach initializations
|
|
|
|
Parameters: same as a standard DllEntryPoint
|
|
|
|
Returns :
|
|
|
|
|
|
***************************************************************************/
|
|
extern "C" BOOL APIENTRY QoSEntryPoint( HINSTANCE hInstDLL,
|
|
DWORD dwReason,
|
|
LPVOID lpReserved)
|
|
{
|
|
BOOL fRet=TRUE;
|
|
|
|
switch (dwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
QOSDEBUGINIT();
|
|
|
|
// create a no-name mutex to control access to QoS object data
|
|
if (!g_hQoSMutex)
|
|
{
|
|
g_hQoSMutex = CreateMutex(NULL, FALSE, NULL);
|
|
ASSERT(g_hQoSMutex);
|
|
if (!g_hQoSMutex)
|
|
{
|
|
ERRORMSG(("QoSEntryPoint: CreateMutex failed, 0x%x\n", GetLastError()));
|
|
fRet = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
if (g_hQoSMutex)
|
|
CloseHandle(g_hQoSMutex);
|
|
g_hQoSMutex = NULL;
|
|
DBGDEINIT(&ghDbgZoneQoS);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return fRet;
|
|
}
|