'library/WIN32API'에 해당되는 글 10건

DllMain이 언제, 왜 호출되는지에 대하여 알아보자.

DllMain의 정의는 아래와 같다.

-------------------------- DllMain의 원형 -------------------------------

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);

----------------------------------------------------------------------

1. HINSTANCE hinstDll
   - DLL이 가상주소에 매핑되었을 때의 핸들이다. WinMain의 hInstance 와 동일한 셩격을 갖고있다.
   - IMAGE_OPTIONAL_HEADER 의 ImageBase 필드에 지정된 값이다.  보통 디폴트로 0x10000000 번지에 로드된다.

2. DWORD fdwReason
   - DllMain 이 호출한 이유를 나타낸다.
   - fdwReason 의 값으로는
     -> DLL_PROCESS_ATTACH : DLL이 프로세스의 주소 공간에 최초로 매핑됬을때

     -> DLL_PROCESS_DETACH : DLL이 프로세스의 주소 공간으로 부터 해제될 때

     -> DLL_THREAD_ATTACH : 어떤 프로세스 내에서 스레드가 생성될 때 해당 프로세스 주소공간에 매핑되어 있는 모든 DLL의 파일이미지검사하여 DLL_THREAD_ATTACH 로 호출

     -> DLL_THREAD_DETACH : 스레드 엔트리 포인트 함수로부터 리턴될때 시스템은 ExitThread를 호출한다 이때 스레드를 바로 없애지 않고 매핑되어 있는 모든 DLL의 DllMain에 DLL_THREAD_DETACH를 호출

-----------------------------------------------------------------------------------------------------------------------------------------

DllMain을 정의할 때 주의할 점이 있는데 DllMain을 호출할때 동기화를 맞추어야 한다.

예를 들어 스레드가 생성될 때 DLL_THREAD_ATTACH 를 매개 변수로 하여 DllMain이 호출된다. 이때 다른 스레드가 종료되는 상황이라면

DllMain이 동시에 두 개의 스레드에 대하여 호출되는 상황이 발생할 것앋. 이 경우 동기화 문제를 고려할 필요가 없도록 시스템이 알아서

앞에 호출된 DllMain의 실행이 끝날 때까지 DllMain의 실행을 대기시키게 된다. 이런 상황 때문에 DllMain 내에서 대기 함수(WaitForXXX 함수군들)를 호출할 때 신중을 기해야 한다.

아니 이런 상황이 발생하지 않도록 코딩해야 한다.  제프리 책 Programming Applications for Microsoft Windows 2000에 이런 상황이 발생할 수 있는 문제점에 대한 예제가 나오는데

확인해보자

------------------------------------- 데드락이 발생하는 DllMain의 예) ----------------------------------------

BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, PVOID lpvReserved)
{
 HWND hThread;
 DWOIRD dwThreadld;

 switch(fdwReason)
 {
 case DLL_PROCESS_ATTACH:
 hThred = CreateThread(NULL,0,SomeFunction,NULL,0,&dwThreadld); // 스레드하나 생성
 
  WaitForSingleObject(hThread, INFINITE);  // 스레드가 끝날때 까지 DllMain 실행을 대기 시킨다.

  CloseHandle(hThread);
 break;

 case DLL_PROCESS_DETACH:
 break;

 case DLL_THREAD_ATTACH:
 break;

 case DLL_THREAD_DETACH:
 break;

 }

}

----------------------------------------------------------------------------------------------------

위 코드를 보면 Dll 로드시에 호출되는 DllMain에서 스레드를 하나 생성하였다.

이 스레드가 종료할때까지 메인 스레드를 대기하는 코드다

이 프로그램은 데드락 상태에 빠지게 되는데  메인스레드는 SomeFuction을 실행하는 스레드를 생성키기고

WaitForSingleObject 를 통해 SomeFuction 의 실행이 종료될 때까지 대기한다.

하지만 여기서 문제가 되는것은 스레드 생성시에도 DLL_THREAD_ATTACHG를 매개변수로 하여 DllMain이 호출된다는 것이다.

그리고 앞서 언급한 것처럼 이미 DLL_PROCESS_ATTACH를 매개 변수로 하여 메인 스레드에 의해 DllMain이 호출 중이기 때문에

시스템은 메인 스레드가 실행 중인 DllMain 실행이 끝날때까지 SomFunction을 실행하는 스레드를 위한

DllMain 실행을 대기시킨다. 이 상황, 즉 메인 스레드에 의한 DllMain 실행은 SomeFunction 을 실행하는 스레드가 종료되기를 기다리고 있으며

SomeFuction 을 실행할 스레드는 SomeFunction을 실행하기 전에 DllMain을 호출하기 위하여 메인 스레드에 의한 DllMain의 호출이 끝나기를 기다리고 있다.

서로가 서로를 끝나기만 기다리고 있는 것이다. 이런 실수를 범하지 않도록 DllMain정의 시에 신중을 기해야 한다.

• SetTimer(...)
• KillTimer(...)

• timeGetDevCaps(...)
• timeBeginPeriod(...)
• timeSetEvent(...)
• TimeProc(...)
• timeKillEvent(...)
• timeEndPeriod(...)

• CreateWaitableTimer(...)
• SetWaitableTimer(...)
• CancelWaitableTimer(...)

Alerable 관련 함수

• SleepEx(...)
• WaitForSingleObjectEx(...)
• WaitForMultipleObjectsEx(...)
• MsgWaitForMultipleObjectsEx(...)
• SignalObjectAndWait(...)

• CreateTimerQueueTimer(...)
• WaitOrTimerCallback(...)
• DeleteTimerQueueTimer(...)

뮤텍스, 이벤트, 세마포어등등으로 프로세스간 동기화가 가능하다
다음 예제는 뮤텍스를 이용하여 먼저 실행된 프로세스가 종료되기를 3초간 대기 후 결과를 메세지박스로 보여준다.

  HANDLE m_hMutex = CreateMutex(NULL, TRUE, "MTXTEST");
  if (GetLastError() == ERROR_ALREADY_EXISTS){
    DWORD dwRet = WaitForSingleObject(m_hMutex, 3000);
    //error, 뮤텍스를 최초 생성한 프로세스가 해제(신호상태로 만듦)할 수 있다.
    //BOOL bRet = ReleaseMutex(m_hMutex); 
    CloseHandle(m_hMutex);        
    if (dwRet == WAIT_FAILED){
      DWORD dwErr = GetLastError();
      MessageBox(NULL, "mtx err", "", MB_OK);
      return;
    }

    if (dwRet == WAIT_TIMEOUT){
      MessageBox(NULL, "mtx timeout", "", MB_OK);
      return;
    }

    MessageBox(NULL, "mtx terminated", "", MB_OK);
  }else{
    MessageBox(NULL, "mtx first running", "", MB_OK);
    ReleaseMutex(m_hMutex);
    CloseHandle(m_hMutex);
  }

* 이기탁님이 작성한 문서를 요약함

1. Overlapped IO

 1.1. 넌블러킹, 비동기적으로 IO처리
 1.2. 쓰레드가 Device Driver에게 IO요청 후 신경쓰지 않음
 1.3. Device Driver가 IO감시하면서 완료되면 알려 줌
  1) 이벤트 객체 멤버 이용
  2) 콜백함수
  3) 직접 조회
  4) IOCP
 1.4. IO blocking없음, FIFO로 IO처리하지 않음
 1.5. 소켓생성
      SOCKET sock=WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
 1.6. 송신
  int WSASend(SOCKET s,
        LPWSABUF lpBuffers,
              DWORD dwBufferCount,
              LPDWORD lpNumberOfBytesSent,
              DWORD dwFlags,
              LPWSAOVERLAPPED lpOverlapped,
              LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  1) IO가 끝나기 전에 lpOverlapped가 메모리에서 사라지면 안됨.
  2) lpCompletionRoutine: 1.3.2)의 콜백함수
  3) 리턴값이 SOCKET_ERROR이면서 WSAGetLastError()==ERROR_IO_PENDING인 경우는
     IO진행중이라는 의미

2. IOCP

 2.1. 커널 오브젝트중 하나
 2.2. 재사용 가능한  쓰레드풀 유지
 2.3. CPU에 dispatch되는 쓰레드 조절
 2.4. 생성
  HANDLE CreateIoCompletionPort (
  HANDLE FileHandle,              // handle to file
  HANDLE ExistingCompletionPort,  // handle to I/O completion port
  ULONG_PTR CompletionKey,        // completion key
  DWORD NumberOfConcurrentThreads // number of threads to execute concurrently);
    두가지 일을 한다.
    1) IOCP커널 객체 생성
        hiocp = CreateCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 쓰레드숫자);
    2) Device와 IOCP객체 연결
        CreateCompletionPort(sock, hIocp, 컴플리션 키, 0 );
 2.5. 쓰레드풀 생성
 2.6. 동작에 필요한 자료구조
  2.6.1. Device List
   1) hDevice - dwCompletionKey
   2) hDevice와 관련된 IO가 완료되었을 때 dwCompletionKey를 던짐
   3) 생성: CreateIoCompletionPort가 호출될 때
   4) 제거: hDevice가 close될 때

  2.6.2. IO Completion Queue(IOCQ)
   1) dwBytesTransferred - dwCompletionKey - pOverlapped - dwError
   2) IO의 결과를 저장
   3) worker 쓰레드에서 하나하나 빼서 처리
   4) PostQueuedCompletionStatus함수를 이용해서 직접 넣을 수 있음.
      쓰레드간 큐나 쓰레드 종료 시 활용
   5) 생성: - IO 요청이 완료되었을 때 
            - PostQueuedCompletionStatus를 호출하였을 때
      제거: - Waiting Thread Queue로부터 Entry를 하나 제거할 때
              즉 IOCP Worker Thread를 하나 깨우고 이 쓰레드에서 레코드 하나를
              꺼낼 때

  2.6.3. Waiting Thread Queue(WTQ)
   1) dwThreadid
   2) IOCP Worker 쓰레드 풀
   3) GetQueuedCompletionStatus(GQCS)함수가 호출되면 Worker 쓰레드가 이 큐에
      쌓고 대기.
   4) 2.6.2의 IOCQ에 레코드가 들어오면 IOCP가 이 큐에서 쓰레드 하나를 깨우고
      GQCS함수를 리턴 시킴
      (CreateIoCompletionPort호출시 마지막 인자인 Concurrent Thread 개수만큼만)
   5) 실제로는 LIFO구조인데 Queue라는 이름이 붙었음
      LIFO구조를 이용해서 사용되는 쓰레드수를 최소화 함(CPU scheduling이 최소화됨)
   6) 제거: IOCQ가 비어있지 않고 Release Thread List(RTL)에 있는 쓰레드 수가
            Concurrent Thread수를 넘지 않을 때, IOCQ에서 레코드 entry가 하나
            제거되고, WTQ에 있던 dwThreadid가 RTL로 옮겨감.

  2.6.4. Released Thread List(RTL)
   1) 쓰레드 풀에서 꺼내온 쓰레드들
   2) 생성: - IOCP가 WTQ에서 쓰레드를 깨울 때
            - Paused Thread가 깨어날 때
   3) 제거: - 쓰레드가 다시 GetQueuedCompletionStatus 함수를 부를 때
            - 쓰레드가 스스로 Suspend(Sleep, WaitForSinglObject등으로 블록) 될 때

  2.6.5 Paused Thread List(PTL)
   1) 어떤 이유로 Suspend된 쓰레드들의 모임
   2) 생성: Released Thread 즉 돌고 있는 쓰레드가 스스로 멈출 때
      제거: Suspend된 쓰레드가 깨어날 때(dwThreadid는 RTL로 옮겨감)

  2.6.6. Concurrent Thread 수와 PTL, RTL
   1) Concurrent Thread 수: RTL에 들어갈 쓰레드 수
   2) Suspend된 쓰레드가 있다면 PTL에에 옮겨 놓고 WTQ에 대기중인 쓰레드를
      RTL로 가져와 처리.
   3) Suspend된 쓰레드가 깨어나면 RTL에 쓰레드가 Concurrent Thread 수보다
      초과될 수도 있다. 적어질 때까지 IOCP는 WTQ에서 쓰레드를 가져오지
      않는다. (효율적인 Thread Context Switching)

#include 

//  Forward declarations:
BOOL GetProcessList( );
BOOL ListProcessModules( DWORD dwPID );
BOOL ListProcessThreads( DWORD dwOwnerPID );
void printError( TCHAR* msg );

void main( )
{
  GetProcessList( );
}

BOOL GetProcessList( )
{
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;

  // Take a snapshot of all processes in the system.
  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  if( hProcessSnap == INVALID_HANDLE_VALUE )
  {
    printError( "CreateToolhelp32Snapshot (of processes)" );
    return( FALSE );
  }

  // Set the size of the structure before using it.
  pe32.dwSize = sizeof( PROCESSENTRY32 );

  // Retrieve information about the first process,
  // and exit if unsuccessful
  if( !Process32First( hProcessSnap, &pe32 ) )
  {
    printError( "Process32First" ); // Show cause of failure
    CloseHandle( hProcessSnap );    // Must clean up the
                                    //   snapshot object!
    return( FALSE );
  }

  // Now walk the snapshot of processes, and
  // display information about each process in turn
  do
  {
   //if ( lstrcmp(pe32.szExeFile, "notepad.exe") != 0 ) continue;
    printf( "\n\n"
      "=====================================================" );
    printf( "\nPROCESS NAME:  %s", pe32.szExeFile );
    printf( "\n"
      "-----------------------------------------------------" );

    // Retrieve the priority class.
    dwPriorityClass = 0;
    hProcess = OpenProcess(
      PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID );
    if( hProcess == NULL )
      printError( "OpenProcess" );
    else
    {
      dwPriorityClass = GetPriorityClass( hProcess );
      if( !dwPriorityClass )
        printError( "GetPriorityClass" );
      CloseHandle( hProcess );
    }

    printf( "\n  process ID        = 0x%08X", pe32.th32ProcessID );
    printf( "\n  thread count      = %d",   pe32.cntThreads );
    printf( "\n  parent process ID = 0x%08X",
      pe32.th32ParentProcessID );
    printf( "\n  Priority Base     = %d", pe32.pcPriClassBase );
    if( dwPriorityClass )
      printf( "\n  Priority Class    = %d", dwPriorityClass );

    // List the modules and threads associated with this process
    ListProcessModules( pe32.th32ProcessID );
    ListProcessThreads( pe32.th32ProcessID );

  } while( Process32Next( hProcessSnap, &pe32 ) );

  CloseHandle( hProcessSnap );
  return( TRUE );
}


BOOL ListProcessModules( DWORD dwPID )
{
  HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
  MODULEENTRY32 me32;

  // Take a snapshot of all modules in the specified process.
  hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwPID );
  if( hModuleSnap == INVALID_HANDLE_VALUE )
  {
    printError( "CreateToolhelp32Snapshot (of modules)" );
    return( FALSE );
  }

  // Set the size of the structure before using it.
  me32.dwSize = sizeof( MODULEENTRY32 );

  // Retrieve information about the first module,
  // and exit if unsuccessful
  if( !Module32First( hModuleSnap, &me32 ) )
  {
    printError( "Module32First" ); // Show cause of failure
    CloseHandle( hModuleSnap );    // Must clean up the
                                   //   snapshot object!
    return( FALSE );
  }

  // Now walk the module list of the process,
  // and display information about each module
  do
  {
    printf( "\n\n     MODULE NAME:     %s",
      me32.szModule );
    printf( "\n     executable     = %s",
      me32.szExePath );
    printf( "\n     process ID     = 0x%08X",
      me32.th32ProcessID );
    printf( "\n     ref count (g)  =     0x%04X",
      me32.GlblcntUsage );
    printf( "\n     ref count (p)  =     0x%04X",
      me32.ProccntUsage );
    printf( "\n     base address   = 0x%08X",
      (DWORD) me32.modBaseAddr );
    printf( "\n     base size      = %d",
      me32.modBaseSize );

  } while( Module32Next( hModuleSnap, &me32 ) );

  CloseHandle( hModuleSnap );
  return( TRUE );
}

BOOL ListProcessThreads( DWORD dwOwnerPID ) 
{ 
  HANDLE hThreadSnap = INVALID_HANDLE_VALUE; 
  THREADENTRY32 te32; 
 
  // Take a snapshot of all running threads  
  hThreadSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 ); 
  if( hThreadSnap == INVALID_HANDLE_VALUE ) 
    return( FALSE ); 
 
  // Fill in the size of the structure before using it. 
  te32.dwSize = sizeof(THREADENTRY32 ); 
 
  // Retrieve information about the first thread,
  // and exit if unsuccessful
  if( !Thread32First( hThreadSnap, &te32 ) ) 
  {
    printError( "Thread32First" ); // Show cause of failure
    CloseHandle( hThreadSnap );    // Must clean up the
                                   //   snapshot object!
    return( FALSE );
  }

  // Now walk the thread list of the system,
  // and display information about each thread
  // associated with the specified process
  do 
  { 
    if( te32.th32OwnerProcessID == dwOwnerPID )
    {
      printf( "\n\n     THREAD ID      = 0x%08X",
        te32.th32ThreadID ); 
      printf( "\n     base priority  = %d", te32.tpBasePri ); 
      printf( "\n     delta priority = %d", te32.tpDeltaPri ); 
    }
  } while( Thread32Next(hThreadSnap, &te32 ) ); 

  CloseHandle( hThreadSnap );
  return( TRUE );
}

void printError( TCHAR* msg )
{
  DWORD eNum;
  TCHAR sysMsg[256];
  TCHAR* p;

  eNum = GetLastError( );
  FormatMessage(
         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
         NULL, eNum,
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default lang.
         sysMsg, 256, NULL );

  // Trim the end of the line and terminate it with a null
  p = sysMsg;
  while( ( *p > 31 ) || ( *p == 9 ) )
    ++p;
  do { *p-- = 0; } while( ( p >= sysMsg ) &&
                          ( ( *p == '.' ) || ( *p < 33 ) ) );

  // Display the message
  printf( "\n  WARNING: %s failed with error %d (%s)",
    msg, eNum, sysMsg );
}