windows-nt/Source/XPSP1/NT/net/tapi/skywalker/mspbase/mspthrd.cpp

/*++

Copyright (c) 1998-1999 Microsoft Corporation

Module Name:

    mspthrd.cpp

Abstract:

    Implementation for MSP thread management classes.

--*/

#include "precomp.h"
#pragma hdrstop

#include <dbt.h>


CMSPThread g_Thread;

extern "C" DWORD WINAPI gfThreadProc(LPVOID p)
{
    return ((CMSPThread *)p)->ThreadProc();
}

HRESULT CMSPThread::Start()
/*++

Routine Description:

    Create the thread if it has not already been created. Otherwise, just
    keep track of how many times the thread start was performed so that
    we only stop the thread when all of these have been paired with a stop.

Arguments:
    
Return Value:

    HRESULT.

--*/
{
    LOG((MSP_TRACE, "CMSPThread::Start - enter"));

    CLock Lock(m_CountLock);

    if ( m_iStartCount == 0 )
    {

        _ASSERTE(m_hCommandEvent == NULL);
        _ASSERTE(m_hThread == NULL);


        TCHAR *ptczEventName = NULL;

#if DBG

        //
        // in debug build, use named events
        //

        TCHAR tszEventName[MAX_PATH];

        _stprintf(tszEventName,
            _T("CMSPThread_CommandEvent_pid[0x%lx]CMSPThread[%p]"),
            GetCurrentProcessId(), this);

        LOG((MSP_TRACE, "CMSPThread::Start - creating event[%S]", tszEventName));

        ptczEventName = &tszEventName[0];

#endif


        if ((m_hCommandEvent = ::CreateEvent(
            NULL, 
            FALSE,          // flag for manual-reset event
            FALSE,          // initial state is not set.
            ptczEventName   // No name in release builds, named in debug builds
            )) == NULL)
        {
            LOG((MSP_ERROR, "Can't create the command event"));
            return E_FAIL;
        }

        DWORD dwThreadID;
        m_hThread = ::CreateThread(NULL, 0, gfThreadProc, this, 0, &dwThreadID);

        if (m_hThread == NULL)
        {
            LOG((MSP_ERROR, "Can't create thread.  %ld", GetLastError()));
            return E_FAIL;
        }
    }

    m_iStartCount++;

    LOG((MSP_TRACE, "CMSPThread::Start - exit S_OK"));
    return S_OK;
}

HRESULT CMSPThread::Stop()
/*++

Routine Description:

    Stop the thread.

Arguments:
    
Return Value:

    HRESULT.

--*/
{
    LOG((MSP_TRACE, "CMSPThread::Stop - enter"));

    CLock Lock(m_CountLock);

    //
    // Complain if we get more Stops than Starts.
    //

    if ( m_iStartCount == 0 )
    {
        LOG((MSP_ERROR, "CMSPThread::Stop - thread already stopped - "
            "exit E_FAIL"));
        return E_FAIL;
    }

    //
    // Decrement the start count. Due to the above check we should
    // never go below zero.
    //

    m_iStartCount--;

    _ASSERTE( m_iStartCount >= 0 );

    //
    // If there have now been just as many stops as starts, it's time to stop
    // the thread.
    //

    if ( m_iStartCount == 0 )
    {
        //
        // Our state should be cleaned up from before.
        //

        _ASSERTE(m_hCommandEvent != NULL);
        _ASSERTE(m_hThread != NULL);

        //
        // Allocate a command queue item which we will pass to the thread.
        //

        COMMAND_QUEUE_ITEM * pItem = new COMMAND_QUEUE_ITEM;

        if ( ! pItem )
        {
            LOG((MSP_ERROR, "CMSPThread::Stop - allocate new queue item"));

            return E_OUTOFMEMORY;
        }

        pItem->node.cmd = STOP;

        //
        // Put the command queue item in the command queue.
        //

        m_QueueLock.Lock();
        InsertTailList(&m_CommandQueue, &(pItem->link));
        m_QueueLock.Unlock();

        //
        // Signal thread to process this stop command.
        //

        if (SignalThreadProc() == 0)
        {
            LOG((MSP_ERROR, "CMSPThread::Stop - can't signal the thread - "
                "exit E_FAIL"));

            return E_FAIL;
        }

        //
        // Wait until the thread stops
        //

        if (::WaitForSingleObject(m_hThread, INFINITE) != WAIT_OBJECT_0)
        {
            LOG((MSP_ERROR, "CMSPThread::Stop - timeout while waiting for the "
                "thread to stop"));
        }

        //
        // Clean up our state.
        //

        ::CloseHandle(m_hCommandEvent);
        ::CloseHandle(m_hThread);

        m_hCommandEvent     = NULL;
        m_hThread           = NULL;

    }

    LOG((MSP_TRACE, "CMSPThread::Stop - exit S_OK"));
    return S_OK;
}

HRESULT CMSPThread::Shutdown()
/*++

Routine Description:

    Unconditionally shutdown the thread. MSPs should by default use Stop()
    instead of Shutdwon(), unless they cannot do matched Start() / Stop()
    calls because of some other issue.

Arguments:
    
Return Value:

    HRESULT.

--*/
{
    LOG((MSP_TRACE, "CMSPThread::Shutdown - enter"));

    CLock Lock(m_CountLock);

    //
    // Ignore if we are not started.
    //

    if ( m_iStartCount == 0 )
    {
        LOG((MSP_ERROR, "CMSPThread::Shutdown - thread already stopped - "
            "exit S_OK"));
 
        return S_OK;
    }

    //
    // We are started, so stop now, irrespective of the outstanding start
    // count.
    //

    m_iStartCount = 1;

    HRESULT hr = Stop();
    
    LOG((MSP_(hr), "CMSPThread::Shutodwn - exit 0x%08x", hr));

    return hr;
}

HRESULT CMSPThread::ThreadProc()
/*++

Routine Description:

    the main loop of this thread.

Arguments:
    
Return Value:

    HRESULT.

--*/
{

    LOG((MSP_TRACE, "CMSPThread::ThreadProc - started"));


    BOOL bExitFlag = FALSE;

    m_hDevNotifyVideo = NULL;
    m_hDevNotifyAudio = NULL;
    m_hWndNotif = NULL;


    HRESULT hr = E_FAIL;

    if (FAILED(hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED)))
    {
        LOG((MSP_ERROR, "CMSPThread::ThreadProc - ConinitialzeEx failed:%x",
            hr));

        return hr;
    }


    //
    // Create a window to receive PNP device notifications. 
    //
    // since this is a base class that is used by more than one msp, we want 
    // to make sure that each msp registers a window class with a unique name
    // 
    // for this reason window class name is derived from threadid.
    //

    DWORD dwThreadID = GetCurrentThreadId();


    //
    // the string needs to be big enough to hold max dword number in hex + 
    // terminating zero. 20 is more than enough.
    //

    TCHAR szWindowClassName[20];

    _stprintf(szWindowClassName, _T("%lx"), dwThreadID);


    //
    // configure window class structure for RegisterClass
    //

    WNDCLASS wc;

    ZeroMemory(&wc, sizeof(wc));

    wc.lpfnWndProc = NotifWndProc;
    wc.lpszClassName = szWindowClassName;

    
    //
    // perform the actual registration
    //

    ATOM atomClassRegistration = 0;

    atomClassRegistration = RegisterClass(&wc);

    if (0 == atomClassRegistration)
    {
        LOG((MSP_ERROR, 
            "CMSPThread::ThreadProc - RegisterClass failed, last error %ld", 
            GetLastError()));
        
        hr = E_FAIL;
        goto exit;
    }
    

    //
    // create window that will receive pnp notifications
    //

    m_hWndNotif = CreateWindow(szWindowClassName, _T("MSP PNP Notification Window"), 0,
            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, this);

    if (m_hWndNotif == NULL)
    {
        LOG((MSP_ERROR, "CMSPThread::ThreadProc - can't create notification window"));
        hr = E_FAIL;
        goto exit;
    }


    //
    // success
    //

    LOG((MSP_TRACE, "CMSPThread::ThreadProc - created notification window"));


    //
    // Register to receive PNP device notifications
    //
    DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;

    ZeroMemory( &NotificationFilter, sizeof(NotificationFilter) );
    NotificationFilter.dbcc_size = 
        sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    NotificationFilter.dbcc_classguid = AM_KSCATEGORY_VIDEO;

    if ((m_hDevNotifyVideo = RegisterDeviceNotification( m_hWndNotif, 
        &NotificationFilter,
        DEVICE_NOTIFY_WINDOW_HANDLE
        )) == NULL)
    {
        LOG((MSP_ERROR, "CMSPThread::ThreadProc - can't register for video device notification"));
        hr = E_FAIL;
        goto exit;
    }

    NotificationFilter.dbcc_classguid = AM_KSCATEGORY_AUDIO;

    if ((m_hDevNotifyAudio = RegisterDeviceNotification( m_hWndNotif, 
        &NotificationFilter,
        DEVICE_NOTIFY_WINDOW_HANDLE
        )) == NULL)
    {
        LOG((MSP_ERROR, "CMSPThread::ThreadProc - can't register for audio device notification"));
        hr = E_FAIL;
        goto exit;
    }
    
    LOG((MSP_TRACE, "CMSPThread::ThreadProc - registered for PNP device notifications"));

    while (!bExitFlag)
    {
        //
        // Msg:      Grab window messages.
        // Multiple: We only use 1, but Msg and Ex only exist with Multiple.
        // Ex:       Allow flags, so we can pass in MWMO_ALERTABLE.
        //
        
        DWORD dwResult = ::MsgWaitForMultipleObjectsEx(
            1,                // wait for one event
            &m_hCommandEvent, // array of events to wait for
            INFINITE,         // wait forever
            QS_ALLINPUT,      // get all window messages
            MWMO_ALERTABLE    // get APC requests (in case this MSP uses them)
            );

        if ( ( dwResult == WAIT_OBJECT_0 ) || ( dwResult == WAIT_OBJECT_0 + 1 ) )
        {
            LOG((MSP_TRACE, "thread is signaled"));

            m_QueueLock.Lock();
            
            while ( ! IsListEmpty(&m_CommandQueue) )
            {

                LIST_ENTRY * links = RemoveHeadList( &m_CommandQueue );
                
                m_QueueLock.Unlock();
            
                COMMAND_QUEUE_ITEM * pItem =
                    CONTAINING_RECORD(links,
                                      COMMAND_QUEUE_ITEM,
                                      link);

                COMMAND_NODE * pNode = &(pItem->node);

                switch (pNode->cmd)
                {

                case WORK_ITEM:
                
                    LOG((MSP_TRACE, "CMSPThread::ThreadProc - "
                        "got command WORK_ITEM"));

                    pNode->pfn( pNode->pContext );

                    if ( pNode->hEvent != NULL )
                    {
                        if ( SetEvent( pNode->hEvent ) == 0 )
                        {
                            LOG((MSP_ERROR, "CMSPThread::ThreadProc - "
                                "can't signal event for synchronous work "
                                "item"));
                        }
                    }
                    break;

                case STOP:
                    
                    LOG((MSP_TRACE, "CMSPThread::ThreadProc - "
                        "thread is exiting"));

                    bExitFlag = TRUE;
                    break;
                }

                delete pItem;
            
                m_QueueLock.Lock();

            }
            m_QueueLock.Unlock();
            

            //
            // We have processed all commands and unblocked everyone
            // who is waiting for us. Now check for window messages.
            //

            MSG msg;

            // Retrieve the next item in the message queue.

            while ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else if ( dwResult == WAIT_IO_COMPLETION )
        {
            // FEATUREFEATURE: The base MSP does not do anything with APC /
            // async I/O. If the derived MSP does something with it, they must
            // implement this to take appropriate action. Question is, how
            // best to expose this to the derived MSP? We could have a method
            // to override, but then how would the derived thread class get
            // instantiated? Instead, we'll have to have a method to set
            // an async I/O completion callback function pointer.
        }
        else
        {
            LOG((MSP_ERROR, "CMSPThread::ThreadProc - "
                "WaitForMultipleObjects failed  %ld", GetLastError()));

            break;
        }
    }

    hr = S_OK;

exit:

    

    //
    //  cleanup: 
    //
    //  Unregister from PNP device notifications
    //  destroy window
    //  unregister window class
    //  couninitialize
    //


    //
    // unregister from video pnp events if needed
    //

    if ( NULL != m_hDevNotifyVideo )
    {
        HRESULT hr2 = UnregisterDeviceNotification(m_hDevNotifyVideo);

        if (FAILED(hr2))
        {

            LOG((MSP_ERROR,
                "CMSPThread::ThreadProc - UnregisterDeviceNotification failed for video events. "
                "hr = %lx", hr2));
        }
    }

    
    //
    // unregister from audio pnp events if needed
    //

    if ( NULL != m_hDevNotifyAudio )
    {

        HRESULT hr2 = UnregisterDeviceNotification(m_hDevNotifyAudio);

        if (FAILED(hr2))
        {

            LOG((MSP_ERROR, 
                "CMSPThread::ThreadProc - UnregisterDeviceNotification failed for audio events. "
                "hr = %lx", hr2));
        }
    }

    
    //
    // destroy window if needed
    //

    if ( NULL != m_hWndNotif )
    {
        
        BOOL bDestroyWindowSuccess = DestroyWindow(m_hWndNotif);

        if ( ! bDestroyWindowSuccess )
        {
            LOG((MSP_ERROR, 
                "CMSPThread::ThreadProc - DestroyWindow failed. LastError = %ld",
                GetLastError()));
        }
    }


    //
    // unregister window class
    //

    if (0 != atomClassRegistration)
    {

        BOOL bUnregisterSuccess = UnregisterClass( (LPCTSTR)atomClassRegistration, ::GetModuleHandle(NULL) );

        if ( ! bUnregisterSuccess )
        {
            LOG((MSP_ERROR, 
                "CMSPThread::ThreadProc - UnregisterClass failed. LastError = %ld", 
                GetLastError()));
        }
    }


    ::CoUninitialize();

    LOG((MSP_(hr), "CMSPThread::ThreadProc - exit. hr = 0x%lx", hr));

    return hr;
}

HRESULT CMSPThread::QueueWorkItem(
    LPTHREAD_START_ROUTINE Function,
    PVOID Context,
    BOOL  fSynchronous
    )
{
    LOG((MSP_TRACE, "CMSPThread::QueueWorkItem - enter"));


    //
    // Create a command block for this.
    //

    COMMAND_QUEUE_ITEM * pItem = new COMMAND_QUEUE_ITEM;

    if ( ! pItem )
    {
        LOG((MSP_ERROR, "CMSPThread::QueueWorkItem - "
            "can't allocate new queue item - exit E_OUTOFMEMORY"));

        return E_OUTOFMEMORY;
    }


    //
    // Create an event to wait on if this is a synchronous work item.
    // Otherwise the thread proc gets a NULL event handle and it knows not to
    // signal it since it's an asynchronous work item.
    //

    TCHAR *ptczEventName = NULL;

#if DBG

    static LONG lSequenceNumber = 0;


    //
    // in debug build, use named events
    //

    TCHAR tszEventName[MAX_PATH];

    InterlockedIncrement(&lSequenceNumber);


    //
    // identify events by the address of the correspoding queue item, and by 
    // the sequence number
    //

    _stprintf(tszEventName,
        _T("CMSPThread_QueueWorkitemEvent_pid[0x%lx]_CMSPThread[%p]_Event[%p]_eventNumber[%lu]"),
        GetCurrentProcessId(), this, pItem, lSequenceNumber);

    LOG((MSP_TRACE, "CMSPThread::QueueWorkItem - creating event[%S]", tszEventName));

    ptczEventName = &tszEventName[0];

#endif


    HANDLE hEvent = NULL;

    if (fSynchronous)
    {
        hEvent = ::CreateEvent(NULL, 
                               FALSE,           // flag for manual-reset event 
                               FALSE,           // initial state is not set.
                               ptczEventName);  // No name in release, named in debug

        if ( hEvent == NULL )
        {
            LOG((MSP_ERROR, "CMSPThread::QueueWorkItem - "
                "Can't create the Job Done event"));

            delete pItem;
            pItem = NULL;

            return E_FAIL;
        }
    }


    //
    // we already have the q item, now initialize it.
    //

    pItem->node.cmd        = WORK_ITEM;
    pItem->node.pfn        = Function;
    pItem->node.pContext   = Context;
    pItem->node.hEvent     = hEvent;


    //
    // Put the command block on the queue. The queue is protected by a
    // critical section.
    //

    m_QueueLock.Lock();
    InsertTailList(&m_CommandQueue, &(pItem->link));


    //
    // Signal the thread to process the command.
    //

    if (SignalThreadProc() == 0)
    {

        //
        // failed to signal processing thread
        // cleanup and return error
        //

        
        //
        // remove the queue entry we have submitted
        //

        RemoveTailList(&m_CommandQueue);


        //
        // unlock the queue so other threads can use it
        //

        m_QueueLock.Unlock();


        //
        // close handle and delete pItem that we have created -- 
        // no one else is going to do this for us
        //

        if (NULL != hEvent)
        {
            ::CloseHandle(hEvent);
            hEvent = NULL;
        }

        delete pItem;
        pItem = NULL;


        LOG((MSP_ERROR, "CMSPThread::QueueWorkItem - "
            "can't signal the thread"));

        return E_FAIL;
    }


    //
    // unlock the event queue, so it can be used by processing and other 
    // threads
    //

    m_QueueLock.Unlock();


    //
    // If this is a sychronous work item, wait for it to complete and
    // then close the event handle.
    //
    // FEATUREFEATURE: Rather than creating and deleting an event for each
    // work item, have a cache of events that can be reused.
    //

    if (fSynchronous)
    {
        LOG((MSP_TRACE, "CMSPThread::QueueWorkItem - "
            "blocked waiting for synchronous work item to complete"));
        
        // Wait for the synchronous work item to complete.

        HANDLE hEvents[2];
        DWORD dwEvent;

        hEvents[0] = hEvent;
        hEvents[1] = m_hThread;

        dwEvent = WaitForMultipleObjects( 
            2,
            hEvents,
            FALSE,
            INFINITE);

        switch (dwEvent)
        {
        case WAIT_OBJECT_0 + 0:
            break;

        case WAIT_OBJECT_0 + 1:
            LOG((MSP_ERROR, "CMSPThread::QueueWorkItem - "
                "thread exited"));

            //
            // if the item is still in the queue, remove it (since the thread 
            // won't)
            //

            m_QueueLock.Lock();
            
            if (IsNodeOnList(&m_CommandQueue, &(pItem->link)))
            {
                RemoveEntryList(&(pItem->link));
                delete pItem;
            }

            m_QueueLock.Unlock();
          

            //
            // time to close event and fail
            //

            ::CloseHandle(hEvent);

            return E_FAIL;        

        default:
            LOG((MSP_ERROR, "CMSPThread::QueueWorkItem - "
                "WaitForSingleObject failed"));
        }

        ::CloseHandle(hEvent);
    }

    LOG((MSP_TRACE, "CMSPThread::QueueWorkItem - exit S_OK"));

    return S_OK;
}

LRESULT CALLBACK CMSPThread::NotifWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{ 
    PNOTIF_LIST pnl;

    if (uMsg == WM_CREATE)
    {
        SetLastError(0);
        if (!SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams)))
        {
            if (GetLastError())  // It isn't really an error unless get last error says so
            {
                LOG((MSP_ERROR, "CMSPThread::NotifWndProc - SetWindowLongPtr failed %ld", GetLastError()));
                _ASSERTE(FALSE);
                return -1;
            }
        }
    }
    else
    {
        CMSPThread *me = (CMSPThread*)GetWindowLongPtr(hwnd, GWLP_USERDATA);

        switch (uMsg) 
        { 
            case WM_DEVICECHANGE: 
                switch(wParam)
                {
                case DBT_DEVICEARRIVAL:
                    LOG((MSP_TRACE, "CMSPThread::NotifWndProc - DBT_DEVICEARRIVAL"));

                    me->m_NotifLock.Lock();
                
                    pnl = me->m_NotifList;
                    while (pnl != NULL)
                    {
                        pnl->addr->PnpNotifHandler(TRUE);
                        pnl = pnl->next;
                    }

                    me->m_NotifLock.Unlock();
                    break;

                case DBT_DEVICEREMOVECOMPLETE:
                    LOG((MSP_TRACE, "CMSPThread::NotifWndProc - DBT_DEVICEREMOVECOMPLETE"));

                    me->m_NotifLock.Lock();
                
                    pnl = me->m_NotifList;
                    while (pnl != NULL)
                    {
                        pnl->addr->PnpNotifHandler(FALSE);
                        pnl = pnl->next;
                    }

                    me->m_NotifLock.Unlock();
                    break;
                }

                return 0; 
 
            case WM_DESTROY: 
                return 0; 
 
            default: 
                return DefWindowProc(hwnd, uMsg, wParam, lParam); 
        } 
    }
    return 0; 
} 

HRESULT CMSPThread::RegisterPnpNotification(CMSPAddress *pCMSPAddress)
{
    PNOTIF_LIST pnl;
    HRESULT hr;

    if (IsBadReadPtr(pCMSPAddress, sizeof(CMSPAddress)))
    {
        LOG((MSP_ERROR, "CMSPThread::RegisterPnpNotification - bad address pointer"));
        return E_POINTER;
    }
    
    m_NotifLock.Lock();

    // Add a new node to the list
    pnl = new NOTIF_LIST;

    if (pnl == NULL)
    {
        LOG((MSP_ERROR, "CMSPThread::RegisterPnpNotification - out of memory"));
        hr = E_OUTOFMEMORY;
    }
    else
    {


        //
        // note that we don't keep addref the address -- it is the 
        // caller's responsibility to ensure we are notified through 
        // UnregisterPnpNotification when the address is going away
        //

        pnl->next = m_NotifList;
        pnl->addr = pCMSPAddress;
        m_NotifList = pnl;
        hr = S_OK;
    }

    m_NotifLock.Unlock();
    return hr;
}

HRESULT CMSPThread::UnregisterPnpNotification(CMSPAddress *pCMSPAddress)
{
    PNOTIF_LIST pnl, pnlLast;
    HRESULT hr = E_FAIL;

    if (IsBadReadPtr(pCMSPAddress, sizeof(CMSPAddress)))
    {
        LOG((MSP_ERROR, "CMSPThread::UnregisterPnpNotification - bad address pointer"));
        return E_POINTER;
    }
    
    m_NotifLock.Lock();

    pnl = m_NotifList;

    if ((pnl != NULL) && (pnl->addr == pCMSPAddress))
    {
        // It is fist in the list, remove it
        m_NotifList = pnl->next;
        delete pnl;

        hr = S_OK;
    }
    else while (pnl != NULL)
    {
        pnlLast = pnl;
        pnl = pnl->next;

        if ((pnl != NULL) && (pnl->addr == pCMSPAddress))
        {
            // Found it in the list, remove it
            pnlLast->next = pnl->next;
            delete pnl;

            hr = S_OK;

            break;
        }
    }

    if (pnl == NULL)
    {
        LOG(( MSP_WARN, "CMSPThread::UnregisterPnpNotification - address pointer not found in notification list." ));
        hr = E_FAIL;
    }

    m_NotifLock.Unlock();
    return hr;
}

// eof