kmisc.h

三星2440原版bsp

{
public:
    SELF_DESTRUCT

    CSemaphore(LONG Count = 1, LONG Limit = MAXLONG) {;}
    ~CSemaphore() {}
    //BOOLEAN ReadState() { ; }
    void AcquireSem();
    BOOLEAN CSemaphore::ReleaseSem(KPRIORITY Increment = 0,LONG Adjustment = 1, BOOLEAN bWait = FALSE);

    void Lock()     { AcquireSem(); }
    void Unlock()   { ReleaseSem(); }
};

#endif // UNDER_CE

////////////////////////////////////////////////////////////////////////////////////////////
//
// CList : this template will take any structure that contain a LIST_ENTRY field 
// the default construtor assumes that LIST_ENTRY is the first field in a structure.
// if not, you have to call the init function with the field offset of the list entry before using the que. 
// to que an irp in this template, use init(IRP_LE_OFFSET) function before starting
// to use the que. If the objects to be inserted in the que are derived from CBaseObj, then
// set the UseBaseObj to TRUE when you declare these objects. If you do, the template class 
// will call the AddRef() on the object when it gets inserted in the que, and Release() when it is removed.
//  
template <class T, ULONG OffsetLE = 0, class L = NoRealLock, class R = NoRefObject<T> > 
class CList 
{
private:
    SELF_DESTRUCT
	
    LIST_ENTRY m_ListHead;
    CList (CList<T, OffsetLE, class L, class R> &);               // no copy constuctor allowed.
    void operator= (CList<T, OffsetLE, class L, class R>&);
	T* ObjectPtrFromListEntryPtr(PLIST_ENTRY pListEntry);
	PLIST_ENTRY ListEntryPtrFromObjectPtr(PVOID pObject);

    L m_Lock;

public:

    CList(void);
    ~CList(void);
	T*		GetHead(void);
	T* 		GetTail(void);
	T* 		GetNext(T* pTCurr);
	T*		GetPrev(T* pTCurr);
	void	AddHead(T* pT);
	void	AddTail(T* pT);
	T* 		RemoveHead(void);
	T* 		RemoveTail(void);
	T* 		RemoveAt(T* pT);
	BOOLEAN	IsEmpty(void);
	ULONG 	GetCount(void);

	void Lock(void)     { m_Lock.Lock();      }
	void Unlock(void)   { m_Lock.Unlock();    }
};

template <class T, ULONG OffsetLE, class L, class R> 
CList<T, OffsetLE, L, R>::CList(void) 
{ 
   InitializeListHead (&m_ListHead);
}

template <class T, ULONG OffsetLE, class L, class R>
CList<T, OffsetLE, L, R>::~CList(void) 
{ 
}

template <class T, ULONG OffsetLE, class L, class R>
PLIST_ENTRY CList<T, OffsetLE, L, R>::ListEntryPtrFromObjectPtr(PVOID pObject)
{
    if (pObject) {
	    return  (PLIST_ENTRY)( OffsetLE + (ULONG)pObject);
    }
    return NULL;
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::ObjectPtrFromListEntryPtr(PLIST_ENTRY pListEntry)
{
	if (pListEntry == &m_ListHead) {
		return NULL;
    }
    else {
        if ( pListEntry) {
		    return (T*)( (PUCHAR)pListEntry - OffsetLE );
        }
    }
    return NULL;
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::GetHead(void) 
{ 
    T * pT;
    if ( IsListEmpty(&m_ListHead) ) {
        pT = NULL;
    }
    else {
        pT =  ObjectPtrFromListEntryPtr( m_ListHead.Flink);
    }
    return  pT;
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::GetTail(void) 
{ 
    T * pT;
    if ( IsListEmpty(&m_ListHead)) {
        pT = NULL;
    }
    else {
        pT =  ObjectPtrFromListEntryPtr(m_ListHead.Blink);
    }
    return  pT;
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::GetNext(T* pTCurr)
{
	T *  pT;
    if (pTCurr == NULL) {
		return GetHead();  
    }
    else {
        if ( ( ListEntryPtrFromObjectPtr(pTCurr))->Flink != &m_ListHead) {
		    pT =  ObjectPtrFromListEntryPtr( (ListEntryPtrFromObjectPtr(pTCurr) )->Flink ) ;
        }
        else  {
            pT = NULL;
        }
    }
	return pT;
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::GetPrev(T* pTCurr)
{
	T *  pT;
    if (pTCurr == NULL) {
		return GetTail();
    }
    else {
        if ( (ListEntryPtrFromObjectPtr(pTCurr))->Blink != &m_ListHead) {
    		pT = ObjectPtrFromListEntryPtr( (ListEntryPtrFromObjectPtr(pTCurr) )->Blink) );
        }
        else {
            pT = NULL;
        }
    }
	return pT;
}

template <class T, ULONG OffsetLE, class L, class R>
void CList<T, OffsetLE, L, R>::AddHead(T* pT)
{
    R r;
    r.AddRef(pT);

	InsertHeadList(&m_ListHead, ListEntryPtrFromObjectPtr(pT) );
}

template <class T, ULONG OffsetLE, class L, class R>
void CList<T, OffsetLE, L, R>::AddTail(T* pT)
{
    R r;
    r.AddRef(pT);

	InsertTailList(&m_ListHead, ListEntryPtrFromObjectPtr(pT) );
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::RemoveHead(void) 
{ 
    T* pT = NULL;
    if ( IsListEmpty(&m_ListHead) == FALSE) {
        PLIST_ENTRY pListEntry = RemoveHeadList(&m_ListHead);
        ASSERT( pListEntry != NULL);
        pT = ObjectPtrFromListEntryPtr(pListEntry);
        R r;
        r.Release(pT);
    }
    return pT;    
}


template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::RemoveTail(void) 
{ 
    T* pT = NULL;
    if ( IsListEmpty(&m_ListHead) == FALSE) {
        PLIST_ENTRY pListEntry = RemoveTailList(&m_ListHead);
        ASSERT( pListEntry != NULL);
        pT = ObjectPtrFromListEntryPtr(pListEntry);
        R r;
        r.Release(pT);
    }
    return pT;    
}

template <class T, ULONG OffsetLE, class L, class R>
T* CList<T, OffsetLE, L, R>::RemoveAt(T* pTCurr)
{
    if (pTCurr){
        R r;
		RemoveEntryList( ListEntryPtrFromObjectPtr(pTCurr) );

        r.Release(pTCurr);
	}
	return pTCurr;
}

template <class T, ULONG OffsetLE, class L, class R>
BOOLEAN CList<T, OffsetLE, L, R>::IsEmpty(void) 
{ 
	BOOLEAN bTest = IsListEmpty(&m_ListHead);
	return bTest;
}

template <class T, ULONG OffsetLE, class L, class R>
ULONG CList<T, OffsetLE, L, R>::GetCount(void)
{
    ULONG ulCount=0;
    if (IsListEmpty(&m_ListHead)) {
        ulCount = 0;
    }
    else{
		PLIST_ENTRY pListEntry  = m_ListHead.Flink;
        ulCount = 0;
        do {
			ulCount++;
			pListEntry = pListEntry->Flink;
		} while  (pListEntry != &m_ListHead);
	}
	return ulCount;
}

////////////////////////////////////////////////////////////////////////////////
typedef 
void
(*PFNCMNDCOMPLETE)( PVOID CommandContext   );

#if ! (defined (UNDER_CE) || defined (WINCE_EMULATION))
class KCounter 
{
private:
	LONG m_Counter;
public:
    SELF_DESTRUCT

	KCounter(void) { m_Counter = 0; }
    void init (LONG value) { m_Counter = value;}
    BOOLEAN Off() { return ((m_Counter == 0) ? TRUE : FALSE); }
    BOOLEAN On() { return ((m_Counter == 0) ? FALSE : TRUE); }
    LONG operator ++(void);
	LONG operator --(void) { return InterlockedDecrement(&m_Counter); }
	operator LONG () { return m_Counter; }
	LONG Peek(void) { return InterlockedExchangeAdd(&m_Counter, 0); }
	LONG TestAndSet(LONG Value) { return InterlockedExchange(&m_Counter, Value);}
    LONG Add( LONG Value) { return InterlockedExchangeAdd(&m_Counter, Value);}
};

inline LONG KCounter::operator ++(void)
{
    LONG counter = InterlockedIncrement(&m_Counter);
    if (counter == 0 )
        ++counter;
    return counter;
}

/////////////////////////////////////////////////////////////////////////
extern ULONG PoolTag;
//
// this function sets the pool tag. 
//
inline void AssignPoolTag(ULONG Tag)
{
    PoolTag = Tag;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
inline PVOID operator new ( size_t iSize,POOL_TYPE poolType  )
{
    PVOID result = NULL;
    if ( iSize) {
        result = ExAllocatePoolWithTag(poolType,iSize,PoolTag);
    }
    if (result) {
        RtlZeroMemory(result,iSize);
    }

    return result;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
inline PVOID operator new ( size_t iSize,POOL_TYPE poolType ,  ULONG tag)
{
    PVOID result = NULL;
    if ( iSize) {
        result = ExAllocatePoolWithTag(poolType,iSize,tag);
    }
    if (result) {
        RtlZeroMemory(result,iSize);
    }

    return result;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// operator new for a previously allocated chunk of memory, usefull for open
// ended C++ structures 
inline PVOID operator new (size_t iSize, PVOID pVoid)
{
    if (pVoid) {
        RtlZeroMemory(pVoid, iSize);
    }

    return pVoid;
}

///////////////////////////////////////////////////////////////////////////
inline void __cdecl operator delete(PVOID pVoid)
{
    if ( pVoid)
        ExFreePool(pVoid);
}
///////////////////////////////////////////////////////////////////////////
inline void __cdecl operator delete [] (PVOID pVoid)
{
    if (pVoid)
        ExFreePool(pVoid);
}
#endif // UNDER_CE

#endif