?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winspool/tests: Use 0xdeadbeef as magic value.
[wine/multimedia.git] / programs / winedbg / info.c
blobb64a3dfa08ba908ae9f9b95566eb744551b6497c
1 /*
2 * Wine debugger utility routines
3 *
4 * Copyright 1993 Eric Youngdale
5 * Copyright 1995 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <stdarg.h>
28
29 #include "debugger.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "tlhelp32.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
36
37 /***********************************************************************
38 * print_help
39 *
40 * Implementation of the 'help' command.
41 */
42 void print_help(void)
43 {
44 int i = 0;
45 static const char * const helptext[] =
46 {
47 "The commands accepted by the Wine debugger are a reasonable",
48 "subset of the commands that gdb accepts.",
49 "The commands currently are:",
50 " help quit",
51 " break [*<addr>] watch *<addr>",
52 " delete break bpnum disable bpnum",
53 " enable bpnum condition <bpnum> [<expr>]",
54 " finish cont [N]",
55 " step [N] next [N]",
56 " stepi [N] nexti [N]",
57 " x <addr> print <expr>",
58 " display <expr> undisplay <disnum>",
59 " local display <expr> delete display <disnum>",
60 " enable display <disnum> disable display <disnum>",
61 " bt [<tid>|all] frame <n>",
62 " up down",
63 " list <lines> disassemble [<addr>][,<addr>]",
64 " show dir dir <path>",
65 " set <reg> = <expr> set *<addr> = <expr>",
66 " mode [16,32,vm86] pass",
67 " whatis info (see 'help info' for options)",
68
69 "The 'x' command accepts repeat counts and formats (including 'i') in the",
70 "same way that gdb does.\n",
71
72 "The following are examples of legal expressions:",
73 " $eax $eax+0x3 0x1000 ($eip + 256) *$eax *($esp + 3)",
74 " Also, a nm format symbol table can be read from a file using the",
75 " symbolfile command.", /* Symbols can also be defined individually with",
76 " the define command.", */
77 "",
78 NULL
79 };
80
81 while (helptext[i]) dbg_printf("%s\n", helptext[i++]);
82 }
83
84
85 /***********************************************************************
86 * info_help
87 *
88 * Implementation of the 'help info' command.
89 */
90 void info_help(void)
91 {
92 int i = 0;
93 static const char * const infotext[] =
94 {
95 "The info commands allow you to get assorted bits of interesting stuff",
96 "to be displayed. The options are:",
97 " info break Displays information about breakpoints",
98 " info class <name> Displays information about window class <name>",
99 " info display Shows auto-display expressions in use",
100 " info except <pid> Shows exception handler chain (in a given process)",
101 " info locals Displays values of all local vars for current frame",
102 " info maps <pid> Shows virtual mappings (in a given process)",
103 " info process Shows all running processes",
104 " info reg Displays values of the general registers at top of stack",
105 " info all-reg Displays the general and floating point registers",
106 " info segments <pid> Displays information about all known segments",
107 " info share Displays all loaded modules",
108 " info share <addr> Displays internal module state",
109 " info stack Dumps information about top of stack",
110 " info symbol <sym> Displays information about a given symbol",
111 " info thread Shows all running threads",
112 " info wnd <handle> Displays internal window state",
113 "",
114 NULL
115 };
116
117 while (infotext[i]) dbg_printf("%s\n", infotext[i++]);
118 }
119
120 static const char* get_symtype_str(SYM_TYPE st)
121 {
122 switch (st)
123 {
124 case -1: return "\\";
125 default:
126 case SymNone: return "--none--";
127 case SymCoff: return "COFF";
128 case SymCv: return "CodeView";
129 case SymPdb: return "PDB";
130 case SymExport: return "Export";
131 case SymDeferred: return "Deferred";
132 case SymSym: return "Sym";
133 case SymDia: return "DIA";
134 case NumSymTypes: return "Stabs";
135 }
136 }
137
138 struct info_module
139 {
140 IMAGEHLP_MODULE* mi;
141 unsigned num_alloc;
142 unsigned num_used;
143 };
144
145 static void module_print_info(const IMAGEHLP_MODULE* mi, SYM_TYPE st)
146 {
147 dbg_printf("0x%08lx-%08lx\t%-16s%s\n",
148 mi->BaseOfImage, mi->BaseOfImage + mi->ImageSize,
149 get_symtype_str(st), mi->ModuleName);
150 }
151
152 static int module_compare(const void* p1, const void* p2)
153 {
154 return (char*)(((const IMAGEHLP_MODULE*)p1)->BaseOfImage) -
155 (char*)(((const IMAGEHLP_MODULE*)p2)->BaseOfImage);
156 }
157
158 static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
159 const IMAGEHLP_MODULE* wmod_child)
160 {
161 return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
162 (DWORD)wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
163 (DWORD)wmod_child->BaseOfImage + wmod_child->ImageSize;
164 }
165
166 static BOOL CALLBACK info_mod_cb(PSTR mod_name, DWORD base, void* ctx)
167 {
168 struct info_module* im = (struct info_module*)ctx;
169
170 if (im->num_used + 1 > im->num_alloc)
171 {
172 im->num_alloc += 16;
173 im->mi = dbg_heap_realloc(im->mi, im->num_alloc * sizeof(*im->mi));
174 }
175 im->mi[im->num_used].SizeOfStruct = sizeof(im->mi[im->num_used]);
176 if (SymGetModuleInfo(dbg_curr_process->handle, base, &im->mi[im->num_used]))
177 {
178 im->num_used++;
179 }
180 return TRUE;
181 }
182
183 /***********************************************************************
184 * info_win32_module
185 *
186 * Display information about a given module (DLL or EXE), or about all modules
187 */
188 void info_win32_module(DWORD base)
189 {
190 if (!dbg_curr_process || !dbg_curr_thread)
191 {
192 dbg_printf("Cannot get info on module while no process is loaded\n");
193 return;
194 }
195
196 if (base)
197 {
198 IMAGEHLP_MODULE mi;
199
200 mi.SizeOfStruct = sizeof(mi);
201
202 if (!SymGetModuleInfo(dbg_curr_process->handle, base, &mi))
203 {
204 dbg_printf("'0x%08lx' is not a valid module address\n", base);
205 return;
206 }
207 module_print_info(&mi, mi.SymType);
208 }
209 else
210 {
211 struct info_module im;
212 int i, j;
213 DWORD opt;
214
215 im.mi = NULL;
216 im.num_alloc = im.num_used = 0;
217
218 /* this is a wine specific options to return also ELF modules in the
219 * enumeration
220 */
221 SymSetOptions((opt = SymGetOptions()) | 0x40000000);
222 SymEnumerateModules(dbg_curr_process->handle, info_mod_cb, (void*)&im);
223 SymSetOptions(opt);
224
225 qsort(im.mi, im.num_used, sizeof(im.mi[0]), module_compare);
226
227 dbg_printf("Module\tAddress\t\t\tDebug info\tName (%d modules)\n", im.num_used);
228
229 for (i = 0; i < im.num_used; i++)
230 {
231 if (strstr(im.mi[i].ModuleName, "<elf>"))
232 {
233 dbg_printf("ELF\t");
234 module_print_info(&im.mi[i], (im.mi[i].SymType == SymDia) ? NumSymTypes : im.mi[i].SymType);
235 /* print all modules embedded in this one */
236 for (j = 0; j < im.num_used; j++)
237 {
238 if (!strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[i], &im.mi[j]))
239 {
240 dbg_printf(" \\-PE\t");
241 module_print_info(&im.mi[j], -1);
242 }
243 }
244 }
245 else
246 {
247 /* check module is not embedded in another module */
248 for (j = 0; j < im.num_used; j++)
249 {
250 if (strstr(im.mi[j].ModuleName, "<elf>") && module_is_container(&im.mi[j], &im.mi[i]))
251 break;
252 }
253 if (j < im.num_used) continue;
254 if (strstr(im.mi[i].ModuleName, ".so") || strchr(im.mi[i].ModuleName, '<'))
255 dbg_printf("ELF\t");
256 else
257 dbg_printf("PE\t");
258 module_print_info(&im.mi[i], im.mi[i].SymType);
259 }
260 }
261 HeapFree(GetProcessHeap(), 0, im.mi);
262 }
263 }
264
265 struct class_walker
266 {
267 ATOM* table;
268 int used;
269 int alloc;
270 };
271
272 static void class_walker(HWND hWnd, struct class_walker* cw)
273 {
274 char clsName[128];
275 int i;
276 ATOM atom;
277 HWND child;
278
279 if (!GetClassName(hWnd, clsName, sizeof(clsName)))
280 return;
281 if ((atom = FindAtom(clsName)) == 0)
282 return;
283
284 for (i = 0; i < cw->used; i++)
285 {
286 if (cw->table[i] == atom)
287 break;
288 }
289 if (i == cw->used)
290 {
291 if (cw->used >= cw->alloc)
292 {
293 cw->alloc += 16;
294 cw->table = dbg_heap_realloc(cw->table, cw->alloc * sizeof(ATOM));
295 }
296 cw->table[cw->used++] = atom;
297 info_win32_class(hWnd, clsName);
298 }
299 do
300 {
301 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
302 class_walker(child, cw);
303 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
304 }
305
306 void info_win32_class(HWND hWnd, const char* name)
307 {
308 WNDCLASSEXA wca;
309 HINSTANCE hInst = hWnd ? (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE) : 0;
310
311 if (!name)
312 {
313 struct class_walker cw;
314
315 cw.table = NULL;
316 cw.used = cw.alloc = 0;
317 class_walker(GetDesktopWindow(), &cw);
318 HeapFree(GetProcessHeap(), 0, cw.table);
319 return;
320 }
321
322 if (!GetClassInfoEx(hInst, name, &wca))
323 {
324 dbg_printf("Cannot find class '%s'\n", name);
325 return;
326 }
327
328 dbg_printf("Class '%s':\n", name);
329 dbg_printf("style=0x%08x wndProc=0x%08lx\n"
330 "inst=%p icon=%p cursor=%p bkgnd=%p\n"
331 "clsExtra=%d winExtra=%d\n",
332 wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
333 wca.hIcon, wca.hCursor, wca.hbrBackground,
334 wca.cbClsExtra, wca.cbWndExtra);
335
336 if (hWnd && wca.cbClsExtra)
337 {
338 int i;
339 WORD w;
340
341 dbg_printf("Extra bytes:");
342 for (i = 0; i < wca.cbClsExtra / 2; i++)
343 {
344 w = GetClassWord(hWnd, i * 2);
345 /* FIXME: depends on i386 endian-ity */
346 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
347 }
348 dbg_printf("\n");
349 }
350 dbg_printf("\n");
351 /* FIXME:
352 * + print #windows (or even list of windows...)
353 * + print extra bytes => this requires a window handle on this very class...
354 */
355 }
356
357 static void info_window(HWND hWnd, int indent)
358 {
359 char clsName[128];
360 char wndName[128];
361 HWND child;
362
363 do
364 {
365 if (!GetClassName(hWnd, clsName, sizeof(clsName)))
366 strcpy(clsName, "-- Unknown --");
367 if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
368 strcpy(wndName, "-- Empty --");
369
370 dbg_printf("%*s%08x%*s %-17.17s %08lx %08lx %08lx %.14s\n",
371 indent, "", (UINT)hWnd, 12 - indent, "",
372 clsName, GetWindowLong(hWnd, GWL_STYLE),
373 GetWindowLongPtr(hWnd, GWLP_WNDPROC),
374 GetWindowThreadProcessId(hWnd, NULL), wndName);
375
376 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
377 info_window(child, indent + 1);
378 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
379 }
380
381 void info_win32_window(HWND hWnd, BOOL detailed)
382 {
383 char clsName[128];
384 char wndName[128];
385 RECT clientRect;
386 RECT windowRect;
387 int i;
388 WORD w;
389
390 if (!IsWindow(hWnd)) hWnd = GetDesktopWindow();
391
392 if (!detailed)
393 {
394 dbg_printf("%-20.20s %-17.17s %-8.8s %-8.8s %-8.8s %s\n",
395 "Window handle", "Class Name", "Style", "WndProc", "Thread", "Text");
396 info_window(hWnd, 0);
397 return;
398 }
399
400 if (!GetClassName(hWnd, clsName, sizeof(clsName)))
401 strcpy(clsName, "-- Unknown --");
402 if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
403 strcpy(wndName, "-- Empty --");
404 if (!GetClientRect(hWnd, &clientRect) ||
405 !MapWindowPoints(hWnd, 0, (LPPOINT) &clientRect, 2))
406 SetRectEmpty(&clientRect);
407 if (!GetWindowRect(hWnd, &windowRect))
408 SetRectEmpty(&windowRect);
409
410 /* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
411 dbg_printf("next=%p child=%p parent=%p owner=%p class='%s'\n"
412 "inst=%p active=%p idmenu=%08lx\n"
413 "style=0x%08lx exstyle=0x%08lx wndproc=0x%08lx text='%s'\n"
414 "client=%ld,%ld-%ld,%ld window=%ld,%ld-%ld,%ld sysmenu=%p\n",
415 GetWindow(hWnd, GW_HWNDNEXT),
416 GetWindow(hWnd, GW_CHILD),
417 GetParent(hWnd),
418 GetWindow(hWnd, GW_OWNER),
419 clsName,
420 (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE),
421 GetLastActivePopup(hWnd),
422 GetWindowLongPtr(hWnd, GWLP_ID),
423 GetWindowLong(hWnd, GWL_STYLE),
424 GetWindowLong(hWnd, GWL_EXSTYLE),
425 GetWindowLongPtr(hWnd, GWLP_WNDPROC),
426 wndName,
427 clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
428 windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
429 GetSystemMenu(hWnd, FALSE));
430
431 if (GetClassLong(hWnd, GCL_CBWNDEXTRA))
432 {
433 dbg_printf("Extra bytes:");
434 for (i = 0; i < GetClassLong(hWnd, GCL_CBWNDEXTRA) / 2; i++)
435 {
436 w = GetWindowWord(hWnd, i * 2);
437 /* FIXME: depends on i386 endian-ity */
438 dbg_printf(" %02x %02x", HIBYTE(w), LOBYTE(w));
439 }
440 dbg_printf("\n");
441 }
442 dbg_printf("\n");
443 }
444
445 void info_win32_processes(void)
446 {
447 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
448 if (snap != INVALID_HANDLE_VALUE)
449 {
450 PROCESSENTRY32 entry;
451 DWORD current = dbg_curr_process ? dbg_curr_process->pid : 0;
452 BOOL ok;
453
454 entry.dwSize = sizeof(entry);
455 ok = Process32First(snap, &entry);
456
457 dbg_printf(" %-8.8s %-8.8s %-8.8s %s (all id:s are in hex)\n",
458 "pid", "threads", "parent", "executable");
459 while (ok)
460 {
461 if (entry.th32ProcessID != GetCurrentProcessId())
462 dbg_printf("%c%08lx %-8ld %08lx '%s'\n",
463 (entry.th32ProcessID == current) ? '>' : ' ',
464 entry.th32ProcessID, entry.cntThreads,
465 entry.th32ParentProcessID, entry.szExeFile);
466 ok = Process32Next(snap, &entry);
467 }
468 CloseHandle(snap);
469 }
470 }
471
472 void info_win32_threads(void)
473 {
474 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
475 if (snap != INVALID_HANDLE_VALUE)
476 {
477 THREADENTRY32 entry;
478 BOOL ok;
479 DWORD lastProcessId = 0;
480
481 entry.dwSize = sizeof(entry);
482 ok = Thread32First(snap, &entry);
483
484 dbg_printf("%-8.8s %-8.8s %s (all id:s are in hex)\n",
485 "process", "tid", "prio");
486 while (ok)
487 {
488 if (entry.th32OwnerProcessID != GetCurrentProcessId())
489 {
490 /* FIXME: this assumes that, in the snapshot, all threads of a same process are
491 * listed sequentially, which is not specified in the doc (Wine's implementation
492 * does it)
493 */
494 if (entry.th32OwnerProcessID != lastProcessId)
495 {
496 struct dbg_process* p = dbg_get_process(entry.th32OwnerProcessID);
497
498 dbg_printf("%08lx%s %s\n",
499 entry.th32OwnerProcessID, p ? " (D)" : "", p ? p->imageName : "");
500 lastProcessId = entry.th32OwnerProcessID;
501 }
502 dbg_printf("\t%08lx %4ld%s\n",
503 entry.th32ThreadID, entry.tpBasePri,
504 (entry.th32ThreadID == dbg_curr_tid) ? " <==" : "");
505
506 }
507 ok = Thread32Next(snap, &entry);
508 }
509
510 CloseHandle(snap);
511 }
512 }
513
514 /***********************************************************************
515 * info_win32_exceptions
516 *
517 * Get info on the exception frames of a given thread.
518 */
519 void info_win32_exceptions(DWORD tid)
520 {
521 struct dbg_thread* thread;
522 void* next_frame;
523
524 if (!dbg_curr_process || !dbg_curr_thread)
525 {
526 dbg_printf("Cannot get info on exceptions while no process is loaded\n");
527 return;
528 }
529
530 dbg_printf("Exception frames:\n");
531
532 if (tid == dbg_curr_tid) thread = dbg_curr_thread;
533 else
534 {
535 thread = dbg_get_thread(dbg_curr_process, tid);
536
537 if (!thread)
538 {
539 dbg_printf("Unknown thread id (0x%08lx) in current process\n", tid);
540 return;
541 }
542 if (SuspendThread(thread->handle) == -1)
543 {
544 dbg_printf("Can't suspend thread id (0x%08lx)\n", tid);
545 return;
546 }
547 }
548
549 if (!dbg_read_memory(thread->teb, &next_frame, sizeof(next_frame)))
550 {
551 dbg_printf("Can't read TEB:except_frame\n");
552 return;
553 }
554
555 while (next_frame != (void*)-1)
556 {
557 EXCEPTION_REGISTRATION_RECORD frame;
558
559 dbg_printf("%p: ", next_frame);
560 if (!dbg_read_memory(next_frame, &frame, sizeof(frame)))
561 {
562 dbg_printf("Invalid frame address\n");
563 break;
564 }
565 dbg_printf("prev=%p handler=%p\n", frame.Prev, frame.Handler);
566 next_frame = frame.Prev;
567 }
568
569 if (tid != dbg_curr_tid) ResumeThread(thread->handle);
570 }
571
572 void info_win32_segments(DWORD start, int length)
573 {
574 char flags[3];
575 DWORD i;
576 LDT_ENTRY le;
577
578 if (length == -1) length = (8192 - start);
579
580 for (i = start; i < start + length; i++)
581 {
582 if (!GetThreadSelectorEntry(dbg_curr_thread->handle, (i << 3) | 7, &le))
583 continue;
584
585 if (le.HighWord.Bits.Type & 0x08)
586 {
587 flags[0] = (le.HighWord.Bits.Type & 0x2) ? 'r' : '-';
588 flags[1] = '-';
589 flags[2] = 'x';
590 }
591 else
592 {
593 flags[0] = 'r';
594 flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
595 flags[2] = '-';
596 }
597 dbg_printf("%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
598 i, (i << 3) | 7,
599 (le.HighWord.Bits.BaseHi << 24) +
600 (le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
601 ((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
602 (le.HighWord.Bits.Granularity ? 12 : 0),
603 le.HighWord.Bits.Default_Big ? 32 : 16,
604 flags[0], flags[1], flags[2]);
605 }
606 }
607
608 void info_win32_virtual(DWORD pid)
609 {
610 MEMORY_BASIC_INFORMATION mbi;
611 char* addr = 0;
612 const char* state;
613 const char* type;
614 char prot[3+1];
615 HANDLE hProc;
616
617 if (pid == dbg_curr_pid)
618 {
619 if (dbg_curr_process == NULL)
620 {
621 dbg_printf("Cannot look at mapping of current process, while no process is loaded\n");
622 return;
623 }
624 hProc = dbg_curr_process->handle;
625 }
626 else
627 {
628 hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
629 if (hProc == NULL)
630 {
631 dbg_printf("Cannot open process <%lu>\n", pid);
632 return;
633 }
634 }
635
636 dbg_printf("Address Size State Type RWX\n");
637
638 while (VirtualQueryEx(hProc, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
639 {
640 switch (mbi.State)
641 {
642 case MEM_COMMIT: state = "commit "; break;
643 case MEM_FREE: state = "free "; break;
644 case MEM_RESERVE: state = "reserve"; break;
645 default: state = "??? "; break;
646 }
647 if (mbi.State != MEM_FREE)
648 {
649 switch (mbi.Type)
650 {
651 case MEM_IMAGE: type = "image "; break;
652 case MEM_MAPPED: type = "mapped "; break;
653 case MEM_PRIVATE: type = "private"; break;
654 case 0: type = " "; break;
655 default: type = "??? "; break;
656 }
657 memset(prot, ' ' , sizeof(prot) - 1);
658 prot[sizeof(prot) - 1] = '\0';
659 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
660 prot[0] = 'R';
661 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
662 prot[1] = 'W';
663 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
664 prot[1] = 'C';
665 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
666 prot[2] = 'X';
667 }
668 else
669 {
670 type = "";
671 prot[0] = '\0';
672 }
673 dbg_printf("%08lx %08lx %s %s %s\n",
674 (DWORD)addr, (DWORD)addr + mbi.RegionSize - 1, state, type, prot);
675 if (addr + mbi.RegionSize < addr) /* wrap around ? */
676 break;
677 addr += mbi.RegionSize;
678 }
679 if (pid != dbg_curr_pid) CloseHandle(hProc);
680 }
681
682 void info_wine_dbg_channel(BOOL turn_on, const char* cls, const char* name)
683 {
684 struct dbg_lvalue lvalue;
685 struct __wine_debug_channel channel;
686 unsigned char mask;
687 int done = 0;
688 BOOL bAll;
689 void* addr;
690
691 if (!dbg_curr_process || !dbg_curr_thread)
692 {
693 dbg_printf("Cannot set/get debug channels while no process is loaded\n");
694 return;
695 }
696
697 if (symbol_get_lvalue("debug_options", -1, &lvalue, FALSE) != sglv_found)
698 {
699 return;
700 }
701 addr = memory_to_linear_addr(&lvalue.addr);
702
703 if (!cls) mask = ~0;
704 else if (!strcmp(cls, "fixme")) mask = (1 << __WINE_DBCL_FIXME);
705 else if (!strcmp(cls, "err")) mask = (1 << __WINE_DBCL_ERR);
706 else if (!strcmp(cls, "warn")) mask = (1 << __WINE_DBCL_WARN);
707 else if (!strcmp(cls, "trace")) mask = (1 << __WINE_DBCL_TRACE);
708 else
709 {
710 dbg_printf("Unknown debug class %s\n", cls);
711 return;
712 }
713
714 bAll = !strcmp("all", name);
715 while (addr && dbg_read_memory(addr, &channel, sizeof(channel)))
716 {
717 if (!channel.name[0]) break;
718 if (bAll || !strcmp( channel.name, name ))
719 {
720 if (turn_on) channel.flags |= mask;
721 else channel.flags &= ~mask;
722 if (dbg_write_memory(addr, &channel, sizeof(channel))) done++;
723 }
724 addr = (struct __wine_debug_channel *)addr + 1;
725 }
726 if (!done) dbg_printf("Unable to find debug channel %s\n", name);
727 else WINE_TRACE("Changed %d channel instances\n", done);
728 }
Maarten's multimedia branch