Commit | Line | Data |
---|---|---|
a80b95ba | 1 | /* Darwin support for GDB, the GNU debugger. |
0fb0cc75 | 2 | Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008, 2009 |
a80b95ba TG |
3 | Free Software Foundation, Inc. |
4 | ||
5 | Contributed by Apple Computer, Inc. | |
6 | ||
7 | This file is part of GDB. | |
8 | ||
9 | This program is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
11 | the Free Software Foundation; either version 2 of the License, or | |
12 | (at your option) any later version. | |
13 | ||
14 | This program is distributed in the hope that it will be useful, | |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | GNU General Public License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
20 | along with this program; if not, write to the Free Software | |
21 | Foundation, Inc., 59 Temple Place - Suite 330, | |
22 | Boston, MA 02111-1307, USA. */ | |
23 | ||
24 | /* The name of the ppc_thread_state structure, and the names of its | |
25 | members, have been changed for Unix conformance reasons. The easiest | |
26 | way to have gdb build on systems with the older names and systems | |
27 | with the newer names is to build this compilation unit with the | |
28 | non-conformant define below. This doesn't seem to cause the resulting | |
29 | binary any problems but it seems like it could cause us problems in | |
30 | the future. It'd be good to remove this at some point when compiling on | |
31 | Tiger is no longer important. */ | |
32 | ||
33 | #include "defs.h" | |
34 | #include "symtab.h" | |
35 | #include "gdbtypes.h" | |
36 | #include "gdbcore.h" | |
37 | #include "value.h" | |
38 | #include "gdbcmd.h" | |
39 | #include "inferior.h" | |
40 | ||
41 | #include <sys/param.h> | |
42 | #include <sys/sysctl.h> | |
43 | ||
44 | #include "darwin-nat.h" | |
45 | ||
46 | #include <mach/thread_info.h> | |
47 | #include <mach/thread_act.h> | |
48 | #include <mach/task.h> | |
49 | #include <mach/vm_map.h> | |
50 | #include <mach/mach_port.h> | |
51 | #include <mach/mach_init.h> | |
52 | #include <mach/mach_vm.h> | |
53 | ||
54 | #define CHECK_ARGS(what, args) do { \ | |
55 | if ((NULL == args) || ((args[0] != '0') && (args[1] != 'x'))) \ | |
56 | error("%s must be specified with 0x...", what); \ | |
57 | } while (0) | |
58 | ||
59 | #define PRINT_FIELD(structure, field) \ | |
60 | printf_unfiltered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field) | |
61 | ||
62 | #define PRINT_TV_FIELD(structure, field) \ | |
63 | printf_unfiltered(_(#field":\t%u.%06u sec\n"), \ | |
64 | (unsigned) (structure)->field.seconds, \ | |
65 | (unsigned) (structure)->field.microseconds) | |
66 | ||
67 | #define task_self mach_task_self | |
68 | #define task_by_unix_pid task_for_pid | |
69 | #define port_name_array_t mach_port_array_t | |
70 | #define port_type_array_t mach_port_array_t | |
71 | ||
72 | static void | |
73 | info_mach_tasks_command (char *args, int from_tty) | |
74 | { | |
75 | int sysControl[4]; | |
76 | int count, index; | |
77 | size_t length; | |
78 | struct kinfo_proc *procInfo; | |
79 | ||
80 | sysControl[0] = CTL_KERN; | |
81 | sysControl[1] = KERN_PROC; | |
82 | sysControl[2] = KERN_PROC_ALL; | |
83 | ||
84 | sysctl (sysControl, 3, NULL, &length, NULL, 0); | |
85 | procInfo = (struct kinfo_proc *) xmalloc (length); | |
86 | sysctl (sysControl, 3, procInfo, &length, NULL, 0); | |
87 | ||
88 | count = (length / sizeof (struct kinfo_proc)); | |
89 | printf_unfiltered (_("%d processes:\n"), count); | |
90 | for (index = 0; index < count; ++index) | |
91 | { | |
92 | kern_return_t result; | |
93 | mach_port_t taskPort; | |
94 | ||
95 | result = | |
96 | task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid, | |
97 | &taskPort); | |
98 | if (KERN_SUCCESS == result) | |
99 | { | |
100 | printf_unfiltered (_(" %s is %d has task %#x\n"), | |
101 | procInfo[index].kp_proc.p_comm, | |
102 | procInfo[index].kp_proc.p_pid, taskPort); | |
103 | } | |
104 | else | |
105 | { | |
106 | printf_unfiltered (_(" %s is %d unknown task port\n"), | |
107 | procInfo[index].kp_proc.p_comm, | |
108 | procInfo[index].kp_proc.p_pid); | |
109 | } | |
110 | } | |
111 | ||
112 | xfree (procInfo); | |
113 | } | |
114 | ||
115 | static task_t | |
116 | get_task_from_args (char *args) | |
117 | { | |
118 | task_t task; | |
119 | char *eptr; | |
120 | ||
121 | if (args == NULL || *args == 0) | |
122 | { | |
123 | if (darwin_inf->task == TASK_NULL) | |
124 | printf_unfiltered (_("No inferior running\n")); | |
125 | return darwin_inf->task; | |
126 | } | |
127 | if (strcmp (args, "gdb") == 0) | |
128 | return mach_task_self (); | |
129 | task = strtoul (args, &eptr, 0); | |
130 | if (*eptr) | |
131 | { | |
132 | printf_unfiltered (_("cannot parse task id '%s'\n"), args); | |
133 | return TASK_NULL; | |
134 | } | |
135 | return task; | |
136 | } | |
137 | ||
138 | static void | |
139 | info_mach_task_command (char *args, int from_tty) | |
140 | { | |
141 | union | |
142 | { | |
143 | struct task_basic_info basic; | |
144 | struct task_events_info events; | |
145 | struct task_thread_times_info thread_times; | |
146 | } task_info_data; | |
147 | ||
148 | kern_return_t result; | |
149 | unsigned int info_count; | |
150 | task_t task; | |
151 | ||
152 | task = get_task_from_args (args); | |
153 | if (task == TASK_NULL) | |
154 | return; | |
155 | ||
156 | printf_unfiltered (_("TASK_BASIC_INFO for 0x%x:\n"), task); | |
157 | info_count = TASK_BASIC_INFO_COUNT; | |
158 | result = task_info (task, | |
159 | TASK_BASIC_INFO, | |
160 | (task_info_t) & task_info_data.basic, &info_count); | |
161 | MACH_CHECK_ERROR (result); | |
162 | ||
163 | PRINT_FIELD (&task_info_data.basic, suspend_count); | |
164 | PRINT_FIELD (&task_info_data.basic, virtual_size); | |
165 | PRINT_FIELD (&task_info_data.basic, resident_size); | |
166 | PRINT_TV_FIELD (&task_info_data.basic, user_time); | |
167 | PRINT_TV_FIELD (&task_info_data.basic, system_time); | |
168 | printf_unfiltered (_("\nTASK_EVENTS_INFO:\n")); | |
169 | info_count = TASK_EVENTS_INFO_COUNT; | |
170 | result = task_info (task, | |
171 | TASK_EVENTS_INFO, | |
172 | (task_info_t) & task_info_data.events, &info_count); | |
173 | MACH_CHECK_ERROR (result); | |
174 | ||
175 | PRINT_FIELD (&task_info_data.events, faults); | |
176 | #if 0 | |
177 | PRINT_FIELD (&task_info_data.events, zero_fills); | |
178 | PRINT_FIELD (&task_info_data.events, reactivations); | |
179 | #endif | |
180 | PRINT_FIELD (&task_info_data.events, pageins); | |
181 | PRINT_FIELD (&task_info_data.events, cow_faults); | |
182 | PRINT_FIELD (&task_info_data.events, messages_sent); | |
183 | PRINT_FIELD (&task_info_data.events, messages_received); | |
184 | printf_unfiltered (_("\nTASK_THREAD_TIMES_INFO:\n")); | |
185 | info_count = TASK_THREAD_TIMES_INFO_COUNT; | |
186 | result = task_info (task, | |
187 | TASK_THREAD_TIMES_INFO, | |
188 | (task_info_t) & task_info_data.thread_times, | |
189 | &info_count); | |
190 | MACH_CHECK_ERROR (result); | |
191 | PRINT_TV_FIELD (&task_info_data.thread_times, user_time); | |
192 | PRINT_TV_FIELD (&task_info_data.thread_times, system_time); | |
193 | } | |
194 | ||
195 | static void | |
196 | info_mach_ports_command (char *args, int from_tty) | |
197 | { | |
198 | port_name_array_t names; | |
199 | port_type_array_t types; | |
200 | unsigned int name_count, type_count; | |
201 | kern_return_t result; | |
202 | int index; | |
203 | task_t task; | |
204 | ||
205 | task = get_task_from_args (args); | |
206 | if (task == TASK_NULL) | |
207 | return; | |
208 | ||
209 | result = mach_port_names (task, &names, &name_count, &types, &type_count); | |
210 | MACH_CHECK_ERROR (result); | |
211 | ||
212 | gdb_assert (name_count == type_count); | |
213 | ||
214 | printf_unfiltered (_("Ports for task 0x%x:\n"), task); | |
215 | printf_unfiltered (_("port type\n")); | |
216 | for (index = 0; index < name_count; ++index) | |
217 | { | |
218 | mach_port_t port = names[index]; | |
219 | unsigned int j; | |
220 | struct type_descr | |
221 | { | |
222 | mach_port_type_t type; | |
223 | const char *name; | |
224 | mach_port_right_t right; | |
225 | }; | |
226 | static struct type_descr descrs[] = | |
227 | { | |
228 | {MACH_PORT_TYPE_SEND, "send", MACH_PORT_RIGHT_SEND}, | |
229 | {MACH_PORT_TYPE_SEND_ONCE, "send-once", MACH_PORT_RIGHT_SEND_ONCE}, | |
230 | {MACH_PORT_TYPE_RECEIVE, "receive", MACH_PORT_RIGHT_RECEIVE}, | |
231 | {MACH_PORT_TYPE_PORT_SET, "port-set", MACH_PORT_RIGHT_PORT_SET}, | |
232 | {MACH_PORT_TYPE_DEAD_NAME, "dead", MACH_PORT_RIGHT_DEAD_NAME} | |
233 | }; | |
234 | ||
235 | printf_unfiltered (_("%04x: %08x "), port, types[index]); | |
236 | for (j = 0; j < sizeof(descrs) / sizeof(*descrs); j++) | |
237 | if (types[index] & descrs[j].type) | |
238 | { | |
239 | mach_port_urefs_t ref; | |
240 | kern_return_t ret; | |
241 | ||
242 | printf_unfiltered (_(" %s("), descrs[j].name); | |
243 | ret = mach_port_get_refs (task, port, descrs[j].right, &ref); | |
244 | if (ret != KERN_SUCCESS) | |
245 | printf_unfiltered (_("??")); | |
246 | else | |
247 | printf_unfiltered (_("%u"), ref); | |
248 | printf_unfiltered (_(" refs)")); | |
249 | } | |
250 | ||
251 | if (task == task_self ()) | |
252 | { | |
253 | if (port == task_self()) | |
254 | printf_unfiltered (_(" gdb-task")); | |
255 | else if (port == darwin_host_self) | |
256 | printf_unfiltered (_(" host-self")); | |
257 | else if (port == darwin_not_port) | |
258 | printf_unfiltered (_(" gdb-notifier")); | |
259 | else if (port == darwin_ex_port) | |
260 | printf_unfiltered (_(" gdb-exception")); | |
261 | else if (port == darwin_port_set) | |
262 | printf_unfiltered (_(" gdb-port_set")); | |
263 | else if (darwin_inf && port == darwin_inf->task) | |
264 | printf_unfiltered (_(" inferior-task")); | |
265 | else if (darwin_inf && darwin_inf->threads) | |
266 | { | |
267 | int k; | |
268 | thread_t t; | |
269 | for (k = 0; VEC_iterate(thread_t, darwin_inf->threads, k, t); k++) | |
270 | if (port == t) | |
271 | { | |
272 | printf_unfiltered (_(" inferior-thread for 0x%x"), | |
273 | darwin_inf->task); | |
274 | break; | |
275 | } | |
276 | } | |
277 | } | |
278 | printf_unfiltered (_("\n")); | |
279 | } | |
280 | ||
281 | vm_deallocate (task_self (), (vm_address_t) names, | |
282 | (name_count * sizeof (mach_port_t))); | |
283 | vm_deallocate (task_self (), (vm_address_t) types, | |
284 | (type_count * sizeof (mach_port_type_t))); | |
285 | } | |
286 | ||
287 | ||
288 | void | |
289 | darwin_debug_port_info (task_t task, mach_port_t port) | |
290 | { | |
291 | kern_return_t kret; | |
292 | mach_port_status_t status; | |
293 | mach_msg_type_number_t len = sizeof (status); | |
294 | ||
295 | kret = mach_port_get_attributes | |
296 | (task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len); | |
297 | MACH_CHECK_ERROR (kret); | |
298 | ||
299 | printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port, | |
300 | (unsigned long) task); | |
301 | printf_unfiltered (_(" port set: 0x%x\n"), status.mps_pset); | |
302 | printf_unfiltered (_(" seqno: 0x%x\n"), status.mps_seqno); | |
303 | printf_unfiltered (_(" mscount: 0x%x\n"), status.mps_mscount); | |
304 | printf_unfiltered (_(" qlimit: 0x%x\n"), status.mps_qlimit); | |
305 | printf_unfiltered (_(" msgcount: 0x%x\n"), status.mps_msgcount); | |
306 | printf_unfiltered (_(" sorights: 0x%x\n"), status.mps_sorights); | |
307 | printf_unfiltered (_(" srights: 0x%x\n"), status.mps_srights); | |
308 | printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest); | |
309 | printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest); | |
310 | printf_unfiltered (_(" flags: 0x%x\n"), status.mps_flags); | |
311 | } | |
312 | ||
313 | static void | |
314 | info_mach_port_command (char *args, int from_tty) | |
315 | { | |
316 | task_t task; | |
317 | mach_port_t port; | |
318 | ||
319 | CHECK_ARGS (_("Task and port"), args); | |
320 | sscanf (args, "0x%x 0x%x", &task, &port); | |
321 | ||
322 | darwin_debug_port_info (task, port); | |
323 | } | |
324 | ||
325 | static void | |
326 | info_mach_threads_command (char *args, int from_tty) | |
327 | { | |
328 | thread_array_t threads; | |
329 | unsigned int thread_count; | |
330 | kern_return_t result; | |
331 | task_t task; | |
332 | int i; | |
333 | ||
334 | task = get_task_from_args (args); | |
335 | if (task == TASK_NULL) | |
336 | return; | |
337 | ||
338 | result = task_threads (task, &threads, &thread_count); | |
339 | MACH_CHECK_ERROR (result); | |
340 | ||
341 | printf_unfiltered (_("Threads in task %#x:\n"), task); | |
342 | for (i = 0; i < thread_count; ++i) | |
343 | { | |
344 | printf_unfiltered (_(" %#x\n"), threads[i]); | |
345 | mach_port_deallocate (task_self (), threads[i]); | |
346 | } | |
347 | ||
348 | vm_deallocate (task_self (), (vm_address_t) threads, | |
349 | (thread_count * sizeof (thread_t))); | |
350 | } | |
351 | ||
352 | static void | |
353 | info_mach_thread_command (char *args, int from_tty) | |
354 | { | |
355 | union | |
356 | { | |
357 | struct thread_basic_info basic; | |
358 | } thread_info_data; | |
359 | ||
360 | thread_t thread; | |
361 | kern_return_t result; | |
362 | unsigned int info_count; | |
363 | ||
364 | CHECK_ARGS (_("Thread"), args); | |
365 | sscanf (args, "0x%x", &thread); | |
366 | ||
367 | printf_unfiltered (_("THREAD_BASIC_INFO\n")); | |
368 | info_count = THREAD_BASIC_INFO_COUNT; | |
369 | result = thread_info (thread, | |
370 | THREAD_BASIC_INFO, | |
371 | (thread_info_t) & thread_info_data.basic, | |
372 | &info_count); | |
373 | MACH_CHECK_ERROR (result); | |
374 | ||
375 | #if 0 | |
376 | PRINT_FIELD (&thread_info_data.basic, user_time); | |
377 | PRINT_FIELD (&thread_info_data.basic, system_time); | |
378 | #endif | |
379 | PRINT_FIELD (&thread_info_data.basic, cpu_usage); | |
380 | PRINT_FIELD (&thread_info_data.basic, run_state); | |
381 | PRINT_FIELD (&thread_info_data.basic, flags); | |
382 | PRINT_FIELD (&thread_info_data.basic, suspend_count); | |
383 | PRINT_FIELD (&thread_info_data.basic, sleep_time); | |
384 | } | |
385 | ||
386 | static const char * | |
387 | unparse_protection (vm_prot_t p) | |
388 | { | |
389 | switch (p) | |
390 | { | |
391 | case VM_PROT_NONE: | |
392 | return "---"; | |
393 | case VM_PROT_READ: | |
394 | return "r--"; | |
395 | case VM_PROT_WRITE: | |
396 | return "-w-"; | |
397 | case VM_PROT_READ | VM_PROT_WRITE: | |
398 | return "rw-"; | |
399 | case VM_PROT_EXECUTE: | |
400 | return "--x"; | |
401 | case VM_PROT_EXECUTE | VM_PROT_READ: | |
402 | return "r-x"; | |
403 | case VM_PROT_EXECUTE | VM_PROT_WRITE: | |
404 | return "-wx"; | |
405 | case VM_PROT_EXECUTE | VM_PROT_WRITE | VM_PROT_READ: | |
406 | return "rwx"; | |
407 | default: | |
408 | return "???"; | |
409 | } | |
410 | } | |
411 | ||
412 | static const char * | |
413 | unparse_inheritance (vm_inherit_t i) | |
414 | { | |
415 | switch (i) | |
416 | { | |
417 | case VM_INHERIT_SHARE: | |
418 | return _("share"); | |
419 | case VM_INHERIT_COPY: | |
420 | return _("copy "); | |
421 | case VM_INHERIT_NONE: | |
422 | return _("none "); | |
423 | default: | |
424 | return _("??? "); | |
425 | } | |
426 | } | |
427 | ||
428 | static const char * | |
429 | unparse_share_mode (unsigned char p) | |
430 | { | |
431 | switch (p) | |
432 | { | |
433 | case SM_COW: | |
434 | return _("cow"); | |
435 | case SM_PRIVATE: | |
436 | return _("private"); | |
437 | case SM_EMPTY: | |
438 | return _("empty"); | |
439 | case SM_SHARED: | |
440 | return _("shared"); | |
441 | case SM_TRUESHARED: | |
442 | return _("true-shrd"); | |
443 | case SM_PRIVATE_ALIASED: | |
444 | return _("prv-alias"); | |
445 | case SM_SHARED_ALIASED: | |
446 | return _("shr-alias"); | |
447 | default: | |
448 | return _("???"); | |
449 | } | |
450 | } | |
451 | ||
452 | static const char * | |
453 | unparse_user_tag (unsigned int tag) | |
454 | { | |
455 | switch (tag) | |
456 | { | |
457 | case 0: | |
458 | return _("default"); | |
459 | case VM_MEMORY_MALLOC: | |
460 | return _("malloc"); | |
461 | case VM_MEMORY_MALLOC_SMALL: | |
462 | return _("malloc_small"); | |
463 | case VM_MEMORY_MALLOC_LARGE: | |
464 | return _("malloc_large"); | |
465 | case VM_MEMORY_MALLOC_HUGE: | |
466 | return _("malloc_huge"); | |
467 | case VM_MEMORY_SBRK: | |
468 | return _("sbrk"); | |
469 | case VM_MEMORY_REALLOC: | |
470 | return _("realloc"); | |
471 | case VM_MEMORY_MALLOC_TINY: | |
472 | return _("malloc_tiny"); | |
473 | case VM_MEMORY_ANALYSIS_TOOL: | |
474 | return _("analysis_tool"); | |
475 | case VM_MEMORY_MACH_MSG: | |
476 | return _("mach_msg"); | |
477 | case VM_MEMORY_IOKIT: | |
478 | return _("iokit"); | |
479 | case VM_MEMORY_STACK: | |
480 | return _("stack"); | |
481 | case VM_MEMORY_GUARD: | |
482 | return _("guard"); | |
483 | case VM_MEMORY_SHARED_PMAP: | |
484 | return _("shared_pmap"); | |
485 | case VM_MEMORY_DYLIB: | |
486 | return _("dylib"); | |
487 | case VM_MEMORY_APPKIT: | |
488 | return _("appkit"); | |
489 | case VM_MEMORY_FOUNDATION: | |
490 | return _("foundation"); | |
491 | default: | |
492 | return NULL; | |
493 | } | |
494 | } | |
495 | ||
496 | static void | |
497 | darwin_debug_regions (task_t task, mach_vm_address_t address, int max) | |
498 | { | |
499 | kern_return_t kret; | |
500 | vm_region_basic_info_data_64_t info, prev_info; | |
501 | mach_vm_address_t prev_address; | |
502 | mach_vm_size_t size, prev_size; | |
503 | ||
504 | mach_port_t object_name; | |
505 | mach_msg_type_number_t count; | |
506 | ||
507 | int nsubregions = 0; | |
508 | int num_printed = 0; | |
509 | ||
510 | count = VM_REGION_BASIC_INFO_COUNT_64; | |
511 | kret = mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64, | |
512 | (vm_region_info_t) &info, &count, &object_name); | |
513 | if (kret != KERN_SUCCESS) | |
514 | { | |
515 | printf_filtered (_("No memory regions.")); | |
516 | return; | |
517 | } | |
518 | memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t)); | |
519 | prev_address = address; | |
520 | prev_size = size; | |
521 | nsubregions = 1; | |
522 | ||
523 | for (;;) | |
524 | { | |
525 | int print = 0; | |
526 | int done = 0; | |
527 | ||
528 | address = prev_address + prev_size; | |
529 | ||
530 | /* Check to see if address space has wrapped around. */ | |
531 | if (address == 0) | |
532 | print = done = 1; | |
533 | ||
534 | if (!done) | |
535 | { | |
536 | count = VM_REGION_BASIC_INFO_COUNT_64; | |
537 | kret = | |
538 | mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64, | |
539 | (vm_region_info_t) &info, &count, &object_name); | |
540 | if (kret != KERN_SUCCESS) | |
541 | { | |
542 | size = 0; | |
543 | print = done = 1; | |
544 | } | |
545 | } | |
546 | ||
547 | if (address != prev_address + prev_size) | |
548 | print = 1; | |
549 | ||
550 | if ((info.protection != prev_info.protection) | |
551 | || (info.max_protection != prev_info.max_protection) | |
552 | || (info.inheritance != prev_info.inheritance) | |
553 | || (info.shared != prev_info.reserved) | |
554 | || (info.reserved != prev_info.reserved)) | |
555 | print = 1; | |
556 | ||
557 | if (print) | |
558 | { | |
559 | printf_filtered (_("%s-%s %s/%s %s %s %s"), | |
560 | paddr(prev_address), | |
561 | paddr(prev_address + prev_size), | |
562 | unparse_protection (prev_info.protection), | |
563 | unparse_protection (prev_info.max_protection), | |
564 | unparse_inheritance (prev_info.inheritance), | |
565 | prev_info.shared ? _("shrd") : _("priv"), | |
566 | prev_info.reserved ? _("reserved") : _("not-rsvd")); | |
567 | ||
568 | if (nsubregions > 1) | |
569 | printf_filtered (_(" (%d sub-rgn)"), nsubregions); | |
570 | ||
571 | printf_filtered (_("\n")); | |
572 | ||
573 | prev_address = address; | |
574 | prev_size = size; | |
575 | memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t)); | |
576 | nsubregions = 1; | |
577 | ||
578 | num_printed++; | |
579 | } | |
580 | else | |
581 | { | |
582 | prev_size += size; | |
583 | nsubregions++; | |
584 | } | |
585 | ||
586 | if ((max > 0) && (num_printed >= max)) | |
587 | done = 1; | |
588 | ||
589 | if (done) | |
590 | break; | |
591 | } | |
592 | } | |
593 | ||
594 | static void | |
595 | darwin_debug_regions_recurse (task_t task) | |
596 | { | |
597 | mach_vm_address_t r_addr; | |
598 | mach_vm_address_t r_start; | |
599 | mach_vm_size_t r_size; | |
600 | natural_t r_depth; | |
601 | mach_msg_type_number_t r_info_size; | |
602 | vm_region_submap_short_info_data_64_t r_info; | |
603 | kern_return_t kret; | |
604 | int ret; | |
605 | ||
606 | r_start = 0; | |
607 | r_depth = 0; | |
608 | while (1) | |
609 | { | |
610 | const char *tag; | |
611 | ||
612 | r_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64; | |
613 | r_size = -1; | |
614 | kret = mach_vm_region_recurse (task, &r_start, &r_size, &r_depth, | |
615 | (vm_region_recurse_info_t) &r_info, | |
616 | &r_info_size); | |
617 | if (kret != KERN_SUCCESS) | |
618 | break; | |
619 | printf_filtered (_("%s-%s %s/%s %-5s %-10s %2d %s"), | |
620 | paddr(r_start), | |
621 | paddr(r_start + r_size), | |
622 | unparse_protection (r_info.protection), | |
623 | unparse_protection (r_info.max_protection), | |
624 | unparse_inheritance (r_info.inheritance), | |
625 | unparse_share_mode (r_info.share_mode), | |
626 | r_depth, | |
627 | r_info.is_submap ? _("sm ") : _("obj")); | |
628 | tag = unparse_user_tag (r_info.user_tag); | |
629 | if (tag) | |
630 | printf_unfiltered (_(" %s\n"), tag); | |
631 | else | |
632 | printf_unfiltered (_(" %u\n"), r_info.user_tag); | |
633 | if (r_info.is_submap) | |
634 | r_depth++; | |
635 | else | |
636 | r_start += r_size; | |
637 | } | |
638 | } | |
639 | ||
640 | ||
641 | static void | |
642 | darwin_debug_region (task_t task, mach_vm_address_t address) | |
643 | { | |
644 | darwin_debug_regions (task, address, 1); | |
645 | } | |
646 | ||
647 | static void | |
648 | info_mach_regions_command (char *args, int from_tty) | |
649 | { | |
650 | task_t task; | |
651 | ||
652 | task = get_task_from_args (args); | |
653 | if (task == TASK_NULL) | |
654 | return; | |
655 | ||
656 | darwin_debug_regions (task, 0, -1); | |
657 | } | |
658 | ||
659 | static void | |
660 | info_mach_regions_recurse_command (char *args, int from_tty) | |
661 | { | |
662 | task_t task; | |
663 | ||
664 | task = get_task_from_args (args); | |
665 | if (task == TASK_NULL) | |
666 | return; | |
667 | ||
668 | darwin_debug_regions_recurse (task); | |
669 | } | |
670 | ||
671 | static void | |
672 | info_mach_region_command (char *exp, int from_tty) | |
673 | { | |
674 | struct expression *expr; | |
675 | struct value *val; | |
676 | mach_vm_address_t address; | |
677 | ||
678 | expr = parse_expression (exp); | |
679 | val = evaluate_expression (expr); | |
680 | if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF) | |
681 | { | |
682 | val = value_ind (val); | |
683 | } | |
684 | /* In rvalue contexts, such as this, functions are coerced into | |
685 | pointers to functions. */ | |
686 | if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC | |
687 | && VALUE_LVAL (val) == lval_memory) | |
688 | { | |
689 | address = VALUE_ADDRESS (val); | |
690 | } | |
691 | else | |
692 | { | |
693 | address = value_as_address (val); | |
694 | } | |
695 | ||
696 | if ((!darwin_inf) || (darwin_inf->task == TASK_NULL)) | |
697 | error (_("Inferior not available")); | |
698 | ||
699 | darwin_debug_region (darwin_inf->task, address); | |
700 | } | |
701 | ||
702 | static void | |
703 | disp_exception (const darwin_exception_info *info) | |
704 | { | |
705 | int i; | |
706 | ||
707 | printf_filtered (_("%d exceptions:\n"), info->count); | |
708 | for (i = 0; i < info->count; i++) | |
709 | { | |
710 | exception_mask_t mask = info->masks[i]; | |
711 | ||
712 | printf_filtered (_("port 0x%04x, behavior: "), info->ports[i]); | |
713 | switch (info->behaviors[i]) | |
714 | { | |
715 | case EXCEPTION_DEFAULT: | |
716 | printf_unfiltered (_("default")); | |
717 | break; | |
718 | case EXCEPTION_STATE: | |
719 | printf_unfiltered (_("state")); | |
720 | break; | |
721 | case EXCEPTION_STATE_IDENTITY: | |
722 | printf_unfiltered (_("state-identity")); | |
723 | break; | |
724 | default: | |
725 | printf_unfiltered (_("0x%x"), info->behaviors[i]); | |
726 | } | |
727 | printf_unfiltered (_(", masks:")); | |
728 | if (mask & EXC_MASK_BAD_ACCESS) | |
729 | printf_unfiltered (_(" BAD_ACCESS")); | |
730 | if (mask & EXC_MASK_BAD_INSTRUCTION) | |
731 | printf_unfiltered (_(" BAD_INSTRUCTION")); | |
732 | if (mask & EXC_MASK_ARITHMETIC) | |
733 | printf_unfiltered (_(" ARITHMETIC")); | |
734 | if (mask & EXC_MASK_EMULATION) | |
735 | printf_unfiltered (_(" EMULATION")); | |
736 | if (mask & EXC_MASK_SOFTWARE) | |
737 | printf_unfiltered (_(" SOFTWARE")); | |
738 | if (mask & EXC_MASK_BREAKPOINT) | |
739 | printf_unfiltered (_(" BREAKPOINT")); | |
740 | if (mask & EXC_MASK_SYSCALL) | |
741 | printf_unfiltered (_(" SYSCALL")); | |
742 | if (mask & EXC_MASK_MACH_SYSCALL) | |
743 | printf_unfiltered (_(" MACH_SYSCALL")); | |
744 | if (mask & EXC_MASK_RPC_ALERT) | |
745 | printf_unfiltered (_(" RPC_ALERT")); | |
746 | if (mask & EXC_MASK_CRASH) | |
747 | printf_unfiltered (_(" CRASH")); | |
748 | printf_unfiltered (_("\n")); | |
749 | } | |
750 | } | |
751 | ||
752 | static void | |
753 | info_mach_exceptions_command (char *args, int from_tty) | |
754 | { | |
755 | int i; | |
756 | task_t task; | |
757 | kern_return_t kret; | |
758 | darwin_exception_info info; | |
759 | ||
760 | info.count = sizeof (info.ports) / sizeof (info.ports[0]); | |
761 | ||
762 | if (args != NULL) | |
763 | { | |
764 | if (strcmp (args, "saved") == 0) | |
765 | { | |
766 | if (darwin_inf->task == TASK_NULL) | |
767 | error (_("No inferior running\n")); | |
768 | disp_exception (&darwin_inf->exception_info); | |
769 | return; | |
770 | } | |
771 | else if (strcmp (args, "host") == 0) | |
772 | { | |
773 | /* FIXME: This need a the privilegied host port! */ | |
774 | kret = host_get_exception_ports | |
775 | (darwin_host_self, EXC_MASK_ALL, info.masks, | |
776 | &info.count, info.ports, info.behaviors, info.flavors); | |
777 | MACH_CHECK_ERROR (kret); | |
778 | disp_exception (&info); | |
779 | } | |
780 | else | |
781 | error (_("Parameter is saved, host or none")); | |
782 | } | |
783 | else | |
784 | { | |
785 | if (darwin_inf->task == TASK_NULL) | |
786 | error (_("No inferior running\n")); | |
787 | ||
788 | kret = task_get_exception_ports | |
789 | (darwin_inf->task, EXC_MASK_ALL, info.masks, | |
790 | &info.count, info.ports, info.behaviors, info.flavors); | |
791 | MACH_CHECK_ERROR (kret); | |
792 | disp_exception (&info); | |
793 | } | |
794 | } | |
795 | ||
796 | static void | |
797 | darwin_list_gdb_ports (const char *msg) | |
798 | { | |
799 | mach_port_name_array_t names; | |
800 | mach_port_type_array_t types; | |
801 | unsigned int name_count, type_count; | |
802 | kern_return_t result; | |
803 | int i; | |
804 | ||
805 | result = mach_port_names (mach_task_self (), | |
806 | &names, &name_count, &types, &type_count); | |
807 | MACH_CHECK_ERROR (result); | |
808 | ||
809 | gdb_assert (name_count == type_count); | |
810 | ||
811 | printf_unfiltered (_("Ports for %s:"), msg); | |
812 | for (i = 0; i < name_count; ++i) | |
813 | printf_unfiltered (_(" 0x%04x"), names[i]); | |
814 | printf_unfiltered (_("\n")); | |
815 | ||
816 | vm_deallocate (mach_task_self (), (vm_address_t) names, | |
817 | (name_count * sizeof (mach_port_t))); | |
818 | vm_deallocate (mach_task_self (), (vm_address_t) types, | |
819 | (type_count * sizeof (mach_port_type_t))); | |
820 | } | |
821 | ||
822 | void | |
823 | _initialize_darwin_info_commands (void) | |
824 | { | |
825 | add_info ("mach-tasks", info_mach_tasks_command, | |
826 | _("Get list of tasks in system.")); | |
827 | add_info ("mach-ports", info_mach_ports_command, | |
828 | _("Get list of ports in a task.")); | |
829 | add_info ("mach-port", info_mach_port_command, | |
830 | _("Get info on a specific port.")); | |
831 | add_info ("mach-task", info_mach_task_command, | |
832 | _("Get info on a specific task.")); | |
833 | add_info ("mach-threads", info_mach_threads_command, | |
834 | _("Get list of threads in a task.")); | |
835 | add_info ("mach-thread", info_mach_thread_command, | |
836 | _("Get info on a specific thread.")); | |
837 | ||
838 | add_info ("mach-regions", info_mach_regions_command, | |
839 | _("Get information on all mach region for the task.")); | |
840 | add_info ("mach-regions-rec", info_mach_regions_recurse_command, | |
841 | _("Get information on all mach sub region for the task.")); | |
842 | add_info ("mach-region", info_mach_region_command, | |
843 | _("Get information on mach region at given address.")); | |
844 | ||
845 | add_info ("mach-exceptions", info_mach_exceptions_command, | |
846 | _("Disp mach exceptions.")); | |
847 | } |