git.oblomov.eu Git - wine/blob - programs/taskmgr/dbgchnl.c

   1 /*
   2  *  ReactOS Task Manager
   3  *
   4  *  dbgchnl.c
   5  *
   6  *  Copyright (C) 2003 - 2004 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #define WIN32_LEAN_AND_MEAN    /* Exclude rarely-used stuff from Windows headers */
  24 #include <windows.h>
  25 #include <commctrl.h>
  26 #include <stdlib.h>
  27 #include <malloc.h>
  28 #include <memory.h>
  29 #include <tchar.h>
  30 #include <stdio.h>
  31 #include <winnt.h>
  32 #include <dbghelp.h>
  33
  34 #include "taskmgr.h"
  35 #include "perfdata.h"
  36 #include "column.h"
  37 #include <ctype.h>
  38
  39 /* TODO:
  40  *      - the dialog box could be non modal
  41  *      - in that case,
  42  *              + could refresh channels from time to time
  43  *              + set the name of exec (and perhaps its pid) in dialog title
  44  *      - get a better UI (replace the 'x' by real tick boxes in list view)
  45  *      - enhance visual feedback: the list is large, and it's hard to get the
  46  *        right line when clicking on rightmost column (trace for example)
  47  *      - get rid of printfs (error reporting) and use real message boxes
  48  *      - include the column width settings in the full column management scheme
  49  *      - use more global settings (like having a temporary on/off
  50  *        setting for a fixme:s or err:s
  51  */
  52
  53 static BOOL  (WINAPI *pSymInitialize)(HANDLE, PSTR, BOOL);
  54 static DWORD (WINAPI *pSymLoadModule)(HANDLE, HANDLE, PSTR, PSTR, DWORD, DWORD);
  55 static BOOL  (WINAPI *pSymCleanup)(HANDLE);
  56 static BOOL  (WINAPI *pSymFromName)(HANDLE, LPSTR, PSYMBOL_INFO);
  57
  58 BOOL AreDebugChannelsSupported(void)
  59 {
  60     static HANDLE   hDbgHelp /* = NULL */;
  61
  62     if (hDbgHelp) return TRUE;
  63
  64     if (!(hDbgHelp = LoadLibrary("dbghelp.dll"))) return FALSE;
  65     pSymInitialize = (void*)GetProcAddress(hDbgHelp, "SymInitialize");
  66     pSymLoadModule = (void*)GetProcAddress(hDbgHelp, "SymLoadModule");
  67     pSymFromName   = (void*)GetProcAddress(hDbgHelp, "SymFromName");
  68     pSymCleanup    = (void*)GetProcAddress(hDbgHelp, "SymCleanup");
  69     if (!pSymInitialize || !pSymLoadModule || !pSymCleanup || !pSymFromName)
  70     {
  71         FreeLibrary(hDbgHelp);
  72         hDbgHelp = NULL;
  73         return FALSE;
  74     }
  75     return TRUE;
  76 }
  77
  78 static DWORD    get_selected_pid(void)
  79 {
  80     LVITEM      lvitem;
  81     ULONG       Index;
  82     DWORD       dwProcessId;
  83
  84     for (Index = 0; Index < (ULONG)ListView_GetItemCount(hProcessPageListCtrl); Index++)
  85     {
  86         memset(&lvitem, 0, sizeof(LVITEM));
  87
  88         lvitem.mask = LVIF_STATE;
  89         lvitem.stateMask = LVIS_SELECTED;
  90         lvitem.iItem = Index;
  91
  92         ListView_GetItem(hProcessPageListCtrl, &lvitem);
  93
  94         if (lvitem.state & LVIS_SELECTED)
  95             break;
  96     }
  97
  98     dwProcessId = PerfDataGetProcessId(Index);
  99
 100     if ((ListView_GetSelectedCount(hProcessPageListCtrl) != 1) || (dwProcessId == 0))
 101         return 0;
 102     return dwProcessId;
 103 }
 104
 105 static int     list_channel_CB(HANDLE hProcess, void* addr, char* buffer, void* user)
 106 {
 107     int         j;
 108     char        val[2];
 109     LVITEMA     lvi;
 110     int         index;
 111     HWND        hChannelLV = (HWND)user;
 112
 113     memset(&lvi, 0, sizeof(lvi));
 114
 115     lvi.mask = LVIF_TEXT;
 116     lvi.pszText = buffer + 1;
 117
 118     index = ListView_InsertItem(hChannelLV, &lvi);
 119     if (index == -1) return 0;
 120
 121     val[1] = '\0';
 122     for (j = 0; j < 4; j++)
 123     {
 124         val[0] = (buffer[0] & (1 << j)) ? 'x' : ' ';
 125         ListView_SetItemText(hChannelLV, index, j + 1, val);
 126     }
 127     return 1;
 128 }
 129
 130 struct cce_user
 131 {
 132     const char* name;           /* channel to look for */
 133     unsigned    value, mask;    /* how to change channel */
 134     unsigned    done;           /* number of successful changes */
 135     unsigned    notdone;        /* number of unsuccessful changes */
 136 };
 137
 138 /******************************************************************
 139  *              change_channel_CB
 140  *
 141  * Callback used for changing a given channel attributes
 142  */
 143 static int change_channel_CB(HANDLE hProcess, void* addr, char* buffer, void* pmt)
 144 {
 145     struct cce_user* user = (struct cce_user*)pmt;
 146
 147     if (!user->name || !strcmp(buffer + 1, user->name))
 148     {
 149         buffer[0] = (buffer[0] & ~user->mask) | (user->value & user->mask);
 150         if (WriteProcessMemory(hProcess, addr, buffer, 1, NULL))
 151             user->done++;
 152         else
 153             user->notdone++;
 154     }
 155     return 1;
 156 }
 157
 158 void* get_symbol(HANDLE hProcess, char* name, char* lib)
 159 {
 160     char                buffer[sizeof(IMAGEHLP_SYMBOL) + 256];
 161     SYMBOL_INFO*        si = (SYMBOL_INFO*)buffer;
 162     void*               ret = NULL;
 163
 164     if (pSymInitialize(hProcess, NULL, FALSE))
 165     {
 166         si->SizeOfStruct = sizeof(*si);
 167         si->MaxNameLen = sizeof(buffer) - sizeof(IMAGEHLP_SYMBOL);
 168         if (pSymLoadModule(hProcess, NULL, lib, NULL, 0, 0) &&
 169             pSymFromName(hProcess, name, si))
 170             ret = (void*)si->Address;
 171         pSymCleanup(hProcess);
 172     }
 173     return ret;
 174 }
 175
 176 struct dll_option_layout
 177 {
 178     void*               next;
 179     void*               prev;
 180     char* const*        channels;
 181     int                 nb_channels;
 182 };
 183
 184 typedef int (*EnumChannelCB)(HANDLE, void*, char*, void*);
 185
 186 /******************************************************************
 187  *              enum_channel
 188  *
 189  * Enumerates all known channels on process hProcess through callback
 190  * ce.
 191  */
 192 static int enum_channel(HANDLE hProcess, EnumChannelCB ce, void* user, unsigned unique)
 193 {
 194     struct dll_option_layout    dol;
 195     int                         i, j, ret = 1;
 196     void*                       buf_addr;
 197     unsigned char               buffer[32];
 198     void*                       addr;
 199     const char**                cache = NULL;
 200     unsigned                    num_cache, used_cache;
 201
 202     if (!(addr = get_symbol(hProcess, "first_dll", "libwine.so"))) return -1;
 203     if (unique)
 204         cache = HeapAlloc(GetProcessHeap(), 0, (num_cache = 32) * sizeof(char*));
 205     else
 206         num_cache = 0;
 207     used_cache = 0;
 208
 209     for (;
 210          ret && addr && ReadProcessMemory(hProcess, addr, &dol, sizeof(dol), NULL);
 211          addr = dol.next)
 212     {
 213         for (i = 0; i < dol.nb_channels; i++)
 214         {
 215             if (ReadProcessMemory(hProcess, (void*)(dol.channels + i), &buf_addr, sizeof(buf_addr), NULL) &&
 216                 ReadProcessMemory(hProcess, buf_addr, buffer, sizeof(buffer), NULL))
 217             {
 218                 if (unique)
 219                 {
 220                     /* since some channels are defined in multiple compilation units,
 221                      * they will appear several times...
 222                      * so cache the channel's names we already reported and don't report
 223                      * them again
 224                      */
 225                     for (j = 0; j < used_cache; j++)
 226                         if (!strcmp(cache[j], buffer + 1)) break;
 227                     if (j != used_cache) continue;
 228                     if (used_cache == num_cache)
 229                         cache = HeapReAlloc(GetProcessHeap(), 0, cache, (num_cache *= 2) * sizeof(char*));
 230                     cache[used_cache++] = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(buffer + 1) + 1),
 231                                                  buffer + 1);
 232                 }
 233                 ret = ce(hProcess, buf_addr, buffer, user);
 234             }
 235         }
 236     }
 237     if (unique)
 238     {
 239         for (j = 0; j < used_cache; j++) HeapFree(GetProcessHeap(), 0, (char*)cache[j]);
 240         HeapFree(GetProcessHeap(), 0, cache);
 241     }
 242     return 0;
 243 }
 244
 245 static void DebugChannels_FillList(HWND hChannelLV)
 246 {
 247     HANDLE      hProcess;
 248
 249     ListView_DeleteAllItems(hChannelLV);
 250
 251     hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ, FALSE, get_selected_pid());
 252     if (!hProcess) return; /* FIXME messagebox */
 253     SendMessage(hChannelLV, WM_SETREDRAW, FALSE, 0);
 254     enum_channel(hProcess, list_channel_CB, (void*)hChannelLV, TRUE);
 255     SendMessage(hChannelLV, WM_SETREDRAW, TRUE, 0);
 256     CloseHandle(hProcess);
 257 }
 258
 259 static void DebugChannels_OnCreate(HWND hwndDlg)
 260 {
 261     HWND        hLV = GetDlgItem(hwndDlg, IDC_DEBUG_CHANNELS_LIST);
 262     LVCOLUMN    lvc;
 263
 264     lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
 265     lvc.fmt = LVCFMT_LEFT;
 266     lvc.pszText = _T("Debug Channel");
 267     lvc.cx = 100;
 268     ListView_InsertColumn(hLV, 0, &lvc);
 269
 270     lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
 271     lvc.fmt = LVCFMT_CENTER;
 272     lvc.pszText = _T("Fixme");
 273     lvc.cx = 55;
 274     ListView_InsertColumn(hLV, 1, &lvc);
 275
 276     lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
 277     lvc.fmt = LVCFMT_CENTER;
 278     lvc.pszText = _T("Err");
 279     lvc.cx = 55;
 280     ListView_InsertColumn(hLV, 2, &lvc);
 281
 282     lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
 283     lvc.fmt = LVCFMT_CENTER;
 284     lvc.pszText = _T("Warn");
 285     lvc.cx = 55;
 286     ListView_InsertColumn(hLV, 3, &lvc);
 287
 288     lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
 289     lvc.fmt = LVCFMT_CENTER;
 290     lvc.pszText = _T("Trace");
 291     lvc.cx = 55;
 292     ListView_InsertColumn(hLV, 4, &lvc);
 293
 294     DebugChannels_FillList(hLV);
 295 }
 296
 297 static void DebugChannels_OnNotify(HWND hDlg, LPARAM lParam)
 298 {
 299     NMHDR*      nmh = (NMHDR*)lParam;
 300
 301     switch (nmh->code)
 302     {
 303     case NM_CLICK:
 304         if (nmh->idFrom == IDC_DEBUG_CHANNELS_LIST)
 305         {
 306             LVHITTESTINFO       lhti;
 307             HWND                hChannelLV;
 308             HANDLE              hProcess;
 309             NMITEMACTIVATE*     nmia = (NMITEMACTIVATE*)lParam;
 310
 311             hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, get_selected_pid());
 312             if (!hProcess) return; /* FIXME message box */
 313             lhti.pt = nmia->ptAction;
 314             hChannelLV = GetDlgItem(hDlg, IDC_DEBUG_CHANNELS_LIST);
 315             SendMessage(hChannelLV, LVM_SUBITEMHITTEST, 0, (LPARAM)&lhti);
 316             if (nmia->iSubItem >= 1 && nmia->iSubItem <= 4)
 317             {
 318                 TCHAR           val[2];
 319                 TCHAR           name[32];
 320                 unsigned        bitmask = 1 << (lhti.iSubItem - 1);
 321                 struct cce_user user;
 322
 323                 ListView_GetItemText(hChannelLV, lhti.iItem, 0, name, sizeof(name) / sizeof(name[0]));
 324                 ListView_GetItemText(hChannelLV, lhti.iItem, lhti.iSubItem, val, sizeof(val) / sizeof(val[0]));
 325                 user.name = name;
 326                 user.value = (val[0] == 'x') ? 0 : bitmask;
 327                 user.mask = bitmask;
 328                 user.done = user.notdone = 0;
 329                 enum_channel(hProcess, change_channel_CB, &user, FALSE);
 330                 if (user.done)
 331                 {
 332                     val[0] ^= ('x' ^ ' ');
 333                     ListView_SetItemText(hChannelLV, lhti.iItem, lhti.iSubItem, val);
 334                 }
 335                 if (user.notdone)
 336                     printf("Some channel instance weren't correctly set\n");
 337             }
 338             CloseHandle(hProcess);
 339         }
 340         break;
 341     }
 342 }
 343
 344 static LRESULT CALLBACK DebugChannelsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 345 {
 346     switch (message)
 347     {
 348     case WM_INITDIALOG:
 349         DebugChannels_OnCreate(hDlg);
 350         return TRUE;
 351     case WM_COMMAND:
 352         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
 353         {
 354             EndDialog(hDlg, LOWORD(wParam));
 355             return TRUE;
 356         }
 357         break;
 358     case WM_NOTIFY:
 359         DebugChannels_OnNotify(hDlg, lParam);
 360         break;
 361     }
 362     return FALSE;
 363 }
 364
 365 void ProcessPage_OnDebugChannels(void)
 366 {
 367     DialogBox(hInst, (LPCTSTR)IDD_DEBUG_CHANNELS_DIALOG, hMainWnd, (DLGPROC)DebugChannelsDlgProc);
 368 }