headers/os/kernel/debugger.h

   1 /*
   2  * Copyright 2005-2016 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5 #ifndef _DEBUGGER_H
   6 #define _DEBUGGER_H
   7
   8
   9 #include <signal.h>
  10
  11 #include <image.h>
  12 #include <OS.h>
  13
  14 // include architecture specific definitions
  15 #include <arch/x86/arch_debugger.h>
  16 #include <arch/x86_64/arch_debugger.h>
  17 #include <arch/ppc/arch_debugger.h>
  18 #include <arch/m68k/arch_debugger.h>
  19 #include <arch/mipsel/arch_debugger.h>
  20 #include <arch/arm/arch_debugger.h>
  21
  22
  23 #ifdef __x86_64__
  24         typedef struct x86_64_debug_cpu_state debug_cpu_state;
  25 #elif __INTEL__
  26         typedef struct x86_debug_cpu_state debug_cpu_state;
  27 #elif __POWERPC__
  28         typedef struct ppc_debug_cpu_state debug_cpu_state;
  29 #elif __M68K__
  30         typedef struct m68k_debug_cpu_state debug_cpu_state;
  31 #elif __MIPSEL__
  32         typedef struct mipsel_debug_cpu_state debug_cpu_state;
  33 #elif __ARM__
  34         typedef struct arm_debug_cpu_state debug_cpu_state;
  35 #else
  36         #error unsupported architecture
  37 #endif
  38
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 extern status_t install_default_debugger(port_id debuggerPort);
  45 extern port_id  install_team_debugger(team_id team, port_id debuggerPort);
  46 extern status_t remove_team_debugger(team_id team);
  47 extern status_t debug_thread(thread_id thread);
  48 extern void             wait_for_debugger(void);
  49
  50 // EXPERIMENTAL: Self-debugging functions. Will fail when a team debugger is
  51 // installed. A breakpoint/watchpoint hit will cause the default debugger to
  52 // be installed for the team.
  53 extern status_t set_debugger_breakpoint(void *address);
  54 extern status_t clear_debugger_breakpoint(void *address);
  55 extern status_t set_debugger_watchpoint(void *address, uint32 type,
  56                                         int32 length);
  57 extern status_t clear_debugger_watchpoint(void *address);
  58
  59
  60 // team debugging flags
  61 enum {
  62         // event mask: If a flag is set, any of the team's threads will stop when
  63         // the respective event occurs. None of the flags are enabled by default.
  64         // Always enabled are debugger() calls and hardware exceptions, as well as
  65         // the deletion of the debugged team.
  66         B_TEAM_DEBUG_SIGNALS                                            = 0x00010000,
  67         B_TEAM_DEBUG_PRE_SYSCALL                                        = 0x00020000,
  68         B_TEAM_DEBUG_POST_SYSCALL                                       = 0x00040000,
  69         B_TEAM_DEBUG_TEAM_CREATION                                      = 0x00080000,
  70         B_TEAM_DEBUG_THREADS                                            = 0x00100000,
  71         B_TEAM_DEBUG_IMAGES                                                     = 0x00200000,
  72         B_TEAM_DEBUG_PREVENT_EXIT                                       = 0x00400000,
  73
  74         // new thread handling
  75         B_TEAM_DEBUG_STOP_NEW_THREADS                           = 0x01000000,
  76
  77         B_TEAM_DEBUG_USER_FLAG_MASK                                     = 0xffff0000,
  78 };
  79
  80 // per-thread debugging flags
  81 enum {
  82         // event mask: If a flag is set, the thread will stop when the respective
  83         // event occurs. If there is a corresponding team flag, it is sufficient,
  84         // if either is set. Per default none of the flags is set.
  85         B_THREAD_DEBUG_PRE_SYSCALL                                      = 0x00010000,
  86         B_THREAD_DEBUG_POST_SYSCALL                                     = 0x00020000,
  87
  88         // child thread handling
  89         B_THREAD_DEBUG_STOP_CHILD_THREADS                       = 0x00100000,
  90         B_THREAD_DEBUG_SYSCALL_TRACE_CHILD_THREADS      = 0x00200000,
  91
  92         B_THREAD_DEBUG_USER_FLAG_MASK                           = 0xffff0000,
  93 };
  94
  95 // in case of a B_EXCEPTION_OCCURRED event: the type of the exception
  96 typedef enum {
  97         B_NON_MASKABLE_INTERRUPT        = 0,
  98         B_MACHINE_CHECK_EXCEPTION,
  99         B_SEGMENT_VIOLATION,
 100         B_ALIGNMENT_EXCEPTION,
 101         B_DIVIDE_ERROR,
 102         B_OVERFLOW_EXCEPTION,
 103         B_BOUNDS_CHECK_EXCEPTION,
 104         B_INVALID_OPCODE_EXCEPTION,
 105         B_SEGMENT_NOT_PRESENT,
 106         B_STACK_FAULT,
 107         B_GENERAL_PROTECTION_FAULT,
 108         B_FLOATING_POINT_EXCEPTION,
 109 } debug_exception_type;
 110
 111 // Value indicating how a stopped thread shall continue.
 112 enum {
 113         B_THREAD_DEBUG_HANDLE_EVENT = 0,        // handle the event normally
 114                                                                                 // (e.g. a signal is delivered, a
 115                                                                                 // CPU fault kills the team,...)
 116         B_THREAD_DEBUG_IGNORE_EVENT,            // ignore the event and continue as if
 117                                                                                 // it didn't occur (e.g. a signal or
 118                                                                                 // a CPU fault will be ignored)
 119 };
 120
 121 // watchpoint types (ToDo: Check PPC support.)
 122 enum {
 123         B_DATA_READ_WATCHPOINT = 0,                     // !x86
 124         B_DATA_WRITE_WATCHPOINT,
 125         B_DATA_READ_WRITE_WATCHPOINT,
 126 };
 127
 128 // how to apply signal ignore masks
 129 typedef enum {
 130         B_DEBUG_SIGNAL_MASK_AND = 0,
 131         B_DEBUG_SIGNAL_MASK_OR,
 132         B_DEBUG_SIGNAL_MASK_SET,
 133 } debug_signal_mask_op;
 134
 135 #define B_DEBUG_SIGNAL_TO_MASK(signal) (1ULL << ((signal) - 1))
 136
 137 // maximal number of bytes to read/write via B_DEBUG_MESSAGE_{READ,WRITE]_MEMORY
 138 enum {
 139         B_MAX_READ_WRITE_MEMORY_SIZE    = 1024,
 140 };
 141
 142 // messages to the debug nub thread
 143 typedef enum {
 144         B_DEBUG_MESSAGE_READ_MEMORY     = 0,    // read from the team's memory
 145         B_DEBUG_MESSAGE_WRITE_MEMORY,           // write to the team's memory
 146         B_DEBUG_MESSAGE_SET_TEAM_FLAGS,         // set the team's debugging flags
 147         B_DEBUG_MESSAGE_SET_THREAD_FLAGS,       // set a thread's debugging flags
 148         B_DEBUG_MESSAGE_CONTINUE_THREAD,        // continue a stopped thread
 149         B_DEBUG_MESSAGE_SET_CPU_STATE,          // change a stopped thread's CPU state
 150         B_DEBUG_MESSAGE_GET_CPU_STATE,          // get the thread's current CPU state
 151         B_DEBUG_MESSAGE_SET_BREAKPOINT,         // set a breakpoint
 152         B_DEBUG_MESSAGE_CLEAR_BREAKPOINT,       // clear a breakpoint
 153         B_DEBUG_MESSAGE_SET_WATCHPOINT,         // set a watchpoint
 154         B_DEBUG_MESSAGE_CLEAR_WATCHPOINT,       // clear a watchpoint
 155         B_DEBUG_MESSAGE_SET_SIGNAL_MASKS,       // set/get a thread's masks of signals
 156         B_DEBUG_MESSAGE_GET_SIGNAL_MASKS,       //  the debugger is interested in
 157         B_DEBUG_MESSAGE_SET_SIGNAL_HANDLER,     // set/get the team's signal handler for
 158         B_DEBUG_MESSAGE_GET_SIGNAL_HANDLER,     //  a signal
 159
 160         B_DEBUG_MESSAGE_PREPARE_HANDOVER,       // prepares the debugged team for being
 161                                                                                 // handed over to another debugger;
 162                                                                                 // the new debugger can just invoke
 163                                                                                 // install_team_debugger()
 164
 165         B_DEBUG_START_PROFILER,                         // start/stop sampling
 166         B_DEBUG_STOP_PROFILER,                          //
 167
 168         B_DEBUG_WRITE_CORE_FILE                         // write a core file
 169 } debug_nub_message;
 170
 171 // messages sent to the debugger
 172 typedef enum {
 173         B_DEBUGGER_MESSAGE_THREAD_DEBUGGED = 0, // debugger message in reaction to
 174                                                                                         // an invocation of debug_thread()
 175         B_DEBUGGER_MESSAGE_DEBUGGER_CALL,               // thread called debugger()
 176         B_DEBUGGER_MESSAGE_BREAKPOINT_HIT,              // thread hit a breakpoint
 177         B_DEBUGGER_MESSAGE_WATCHPOINT_HIT,              // thread hit a watchpoint
 178         B_DEBUGGER_MESSAGE_SINGLE_STEP,                 // thread was single-stepped
 179         B_DEBUGGER_MESSAGE_PRE_SYSCALL,                 // begin of a syscall
 180         B_DEBUGGER_MESSAGE_POST_SYSCALL,                // end of a syscall
 181         B_DEBUGGER_MESSAGE_SIGNAL_RECEIVED,             // thread received a signal
 182         B_DEBUGGER_MESSAGE_EXCEPTION_OCCURRED,  // an exception occurred
 183         B_DEBUGGER_MESSAGE_TEAM_CREATED,                // the debugged team created a new
 184                                                                                         // one
 185         B_DEBUGGER_MESSAGE_TEAM_DELETED,                // the debugged team is gone
 186         B_DEBUGGER_MESSAGE_TEAM_EXEC,                   // the debugged team executes exec()
 187         B_DEBUGGER_MESSAGE_THREAD_CREATED,              // a thread has been created
 188         B_DEBUGGER_MESSAGE_THREAD_DELETED,              // a thread has been deleted
 189         B_DEBUGGER_MESSAGE_IMAGE_CREATED,               // an image has been created
 190         B_DEBUGGER_MESSAGE_IMAGE_DELETED,               // an image has been deleted
 191
 192         B_DEBUGGER_MESSAGE_PROFILER_UPDATE,             // flush the profiling buffer for a
 193                                                                                         // thread
 194
 195         B_DEBUGGER_MESSAGE_HANDED_OVER,                 // the debugged team has been
 196                                                                                         // handed over to another debugger,
 197                                                                                         // sent to both debuggers
 198 } debug_debugger_message;
 199
 200
 201 // profile events -- when the buffer is in variable stack depth format, a sample
 202 // count entry >= B_DEBUG_PROFILE_EVENT_BASE indicates a profile event
 203 enum {
 204         B_DEBUG_PROFILE_EVENT_BASE                              = 0x80000000,
 205         B_DEBUG_PROFILE_EVENT_PARAMETER_MASK    = 0x0000ffff,
 206                 // & with to get the event's parameter count
 207
 208         B_DEBUG_PROFILE_IMAGE_EVENT                             = 0x80010001
 209                 // single parameter: the respective image event counter
 210 };
 211
 212
 213 // #pragma mark -
 214 // #pragma mark ----- messages to the debug nub thread -----
 215
 216 // B_DEBUG_MESSAGE_READ_MEMORY
 217
 218 typedef struct {
 219         port_id         reply_port;             // port to send the reply to
 220         void            *address;               // address from which to read
 221         int32           size;                   // number of bytes to read
 222 } debug_nub_read_memory;
 223
 224 typedef struct {
 225         status_t        error;                  // B_OK, if reading went fine
 226         int32           size;                   // the number of bytes actually read
 227                                                                 // > 0, iff error == B_OK
 228         char            data[B_MAX_READ_WRITE_MEMORY_SIZE];
 229                                                                 // the read data
 230 } debug_nub_read_memory_reply;
 231
 232 // B_DEBUG_MESSAGE_WRITE_MEMORY
 233
 234 typedef struct {
 235         port_id         reply_port;             // port to send the reply to
 236         void            *address;               // address to which to write
 237         int32           size;                   // number of bytes to write
 238         char            data[B_MAX_READ_WRITE_MEMORY_SIZE];
 239                                                                 // data to write
 240 } debug_nub_write_memory;
 241
 242 typedef struct {
 243         status_t        error;                  // B_OK, if writing went fine
 244         int32           size;                   // the number of bytes actually written
 245 } debug_nub_write_memory_reply;
 246
 247 // B_DEBUG_MESSAGE_SET_TEAM_FLAGS
 248
 249 typedef struct {
 250         int32           flags;                  // the new team debugging flags
 251 } debug_nub_set_team_flags;
 252
 253 // B_DEBUG_MESSAGE_SET_THREAD_FLAGS
 254
 255 typedef struct {
 256         thread_id       thread;                 // the thread
 257         int32           flags;                  // the new thread debugging flags
 258 } debug_nub_set_thread_flags;
 259
 260 // B_DEBUG_MESSAGE_CONTINUE_THREAD
 261
 262 typedef struct {
 263         thread_id       thread;                 // the thread
 264         uint32          handle_event;   // how to handle the occurred event
 265         bool            single_step;    // true == single step, false == run full speed
 266 } debug_nub_continue_thread;
 267
 268 // B_DEBUG_MESSAGE_SET_CPU_STATE
 269
 270 typedef struct {
 271         thread_id                       thread;                         // the thread
 272         debug_cpu_state         cpu_state;                      // the new CPU state
 273 } debug_nub_set_cpu_state;
 274
 275 // B_DEBUG_MESSAGE_GET_CPU_STATE
 276
 277 typedef struct {
 278         port_id                                 reply_port;             // port to send the reply to
 279         thread_id                               thread;                 // the thread
 280 } debug_nub_get_cpu_state;
 281
 282 typedef struct {
 283         status_t                                error;          // != B_OK, if something went wrong
 284                                                                                 // (bad thread ID, thread not stopped)
 285         debug_debugger_message  message;        // the reason why the thread stopped
 286         debug_cpu_state                 cpu_state;      // the thread's CPU state
 287 } debug_nub_get_cpu_state_reply;
 288
 289 // B_DEBUG_MESSAGE_SET_BREAKPOINT
 290
 291 typedef struct {
 292         port_id         reply_port;             // port to send the reply to
 293         void            *address;               // breakpoint address
 294 } debug_nub_set_breakpoint;
 295
 296 typedef struct {
 297         status_t        error;                  // B_OK, if the breakpoint has been set
 298                                                                 // successfully
 299 } debug_nub_set_breakpoint_reply;
 300
 301 // B_DEBUG_MESSAGE_CLEAR_BREAKPOINT
 302
 303 typedef struct {
 304         void            *address;               // breakpoint address
 305 } debug_nub_clear_breakpoint;
 306
 307 // B_DEBUG_MESSAGE_SET_WATCHPOINT
 308
 309 typedef struct {
 310         port_id         reply_port;             // port to send the reply to
 311         void            *address;               // watchpoint address
 312         uint32          type;                   // watchpoint type (see type constants above)
 313         int32           length;                 // number of bytes to watch (typically 1, 2,
 314                                                                 // 4); architecture specific alignment
 315                                                                 // restrictions apply.
 316 } debug_nub_set_watchpoint;
 317
 318 typedef struct {
 319         status_t        error;                  // B_OK, if the watchpoint has been set
 320                                                                 // successfully
 321 } debug_nub_set_watchpoint_reply;
 322
 323 // B_DEBUG_MESSAGE_CLEAR_WATCHPOINT
 324
 325 typedef struct {
 326         void            *address;               // watchpoint address
 327 } debug_nub_clear_watchpoint;
 328
 329 // B_DEBUG_MESSAGE_SET_SIGNAL_MASKS
 330
 331 typedef struct {
 332         thread_id                               thread;                         // the thread
 333         uint64                                  ignore_mask;            // the mask for signals the
 334                                                                                                 // debugger wishes not to be
 335                                                                                                 // notified of
 336         uint64                                  ignore_once_mask;       // the mask for signals the
 337                                                                                                 // debugger wishes not to be
 338                                                                                                 // notified of when they next
 339                                                                                                 // occur
 340         debug_signal_mask_op    ignore_op;                      // what to do with ignore_mask
 341         debug_signal_mask_op    ignore_once_op;         // what to do with
 342                                                                                                 // ignore_once_mask
 343 } debug_nub_set_signal_masks;
 344
 345 // B_DEBUG_MESSAGE_GET_SIGNAL_MASKS
 346
 347 typedef struct {
 348         port_id         reply_port;                     // port to send the reply to
 349         thread_id       thread;                         // the thread
 350 } debug_nub_get_signal_masks;
 351
 352 typedef struct {
 353         status_t        error;                          // B_OK, if the thread exists
 354         uint64          ignore_mask;            // the mask for signals the debugger wishes
 355                                                                         // not to be notified of
 356         uint64          ignore_once_mask;       // the mask for signals the debugger wishes
 357                                                                         // not to be notified of when they next
 358                                                                         // occur
 359 } debug_nub_get_signal_masks_reply;
 360
 361 // B_DEBUG_MESSAGE_SET_SIGNAL_HANDLER
 362
 363 typedef struct {
 364         int                                     signal;         // the signal
 365         struct sigaction        handler;        // the new signal handler
 366 } debug_nub_set_signal_handler;
 367
 368 // B_DEBUG_MESSAGE_GET_SIGNAL_HANDLER
 369
 370 typedef struct {
 371         port_id                         reply_port;     // port to send the reply to
 372         int                                     signal;         // the signal
 373 } debug_nub_get_signal_handler;
 374
 375 typedef struct {
 376         status_t                        error;          // B_OK, if the thread exists
 377         struct sigaction        handler;        // the signal handler
 378 } debug_nub_get_signal_handler_reply;
 379
 380 // B_DEBUG_MESSAGE_PREPARE_HANDOVER
 381
 382 // no parameters, no reply
 383
 384 // B_DEBUG_START_PROFILER
 385
 386 struct debug_profile_function {
 387         addr_t                  base;   // function base address
 388         size_t                  size;   // function size
 389 };
 390
 391 typedef struct {
 392         port_id                         reply_port;             // port to send the reply to
 393         thread_id                       thread;                 // thread to profile
 394         bigtime_t                       interval;               // sample interval
 395         area_id                         sample_area;    // area into which the sample will be
 396                                                                                 // written
 397         int32                           stack_depth;    // number of return address per hit
 398         bool                            variable_stack_depth;
 399                                                                                 // variable number of samples per hit;
 400                                                                                 // cf. debug_profiler_update
 401 } debug_nub_start_profiler;
 402
 403 typedef struct {
 404         status_t                        error;
 405         int32                           image_event;    // number of the last image event
 406         bigtime_t                       interval;               // actual sample interval (might
 407                                                                                 // differ from the requested one)
 408 } debug_nub_start_profiler_reply;
 409
 410 // B_DEBUG_STOP_PROFILER
 411
 412 typedef struct {
 413         port_id                         reply_port;             // port to send the reply to
 414         thread_id                       thread;                 // thread to profile
 415 } debug_nub_stop_profiler;
 416
 417 // B_DEBUG_WRITE_CORE_FILE
 418
 419 typedef struct {
 420         port_id                         reply_port;             // port to send the reply to
 421         char                            path[B_PATH_NAME_LENGTH];
 422                                                                                 // path of the core file; must not exist
 423                                                                                 // yet; must be absolute
 424 } debug_nub_write_core_file;
 425
 426 typedef struct {
 427         status_t        error;                                  // B_OK on success
 428 } debug_nub_write_core_file_reply;
 429
 430
 431 // reply is debug_profiler_update
 432
 433 // union of all messages structures sent to the debug nub thread
 434 typedef union {
 435         debug_nub_read_memory                   read_memory;
 436         debug_nub_write_memory                  write_memory;
 437         debug_nub_set_team_flags                set_team_flags;
 438         debug_nub_set_thread_flags              set_thread_flags;
 439         debug_nub_continue_thread               continue_thread;
 440         debug_nub_set_cpu_state                 set_cpu_state;
 441         debug_nub_get_cpu_state                 get_cpu_state;
 442         debug_nub_set_breakpoint                set_breakpoint;
 443         debug_nub_clear_breakpoint              clear_breakpoint;
 444         debug_nub_set_watchpoint                set_watchpoint;
 445         debug_nub_clear_watchpoint              clear_watchpoint;
 446         debug_nub_set_signal_masks              set_signal_masks;
 447         debug_nub_get_signal_masks              get_signal_masks;
 448         debug_nub_set_signal_handler    set_signal_handler;
 449         debug_nub_get_signal_handler    get_signal_handler;
 450         debug_nub_start_profiler                start_profiler;
 451         debug_nub_stop_profiler                 stop_profiler;
 452         debug_nub_write_core_file               write_core_file;
 453 } debug_nub_message_data;
 454
 455
 456 // #pragma mark -
 457 // #pragma mark ----- messages to the debugger -----
 458
 459 // first member of all debugger messages -- not a message by itself
 460 typedef struct {
 461         thread_id       thread;                 // the thread being the event origin
 462         team_id         team;                   // the thread's team
 463         port_id         nub_port;               // port to debug nub for this team (only set
 464                                                                 // for synchronous messages)
 465 } debug_origin;
 466
 467 // B_DEBUGGER_MESSAGE_THREAD_DEBUGGED
 468
 469 typedef struct {
 470         debug_origin            origin;
 471 } debug_thread_debugged;
 472
 473 // B_DEBUGGER_MESSAGE_DEBUGGER_CALL
 474
 475 typedef struct {
 476         debug_origin            origin;
 477         void                            *message;       // address of the message passed to
 478                                                                         // debugger()
 479 } debug_debugger_call;
 480
 481 // B_DEBUGGER_MESSAGE_BREAKPOINT_HIT
 482
 483 typedef struct {
 484         debug_origin            origin;
 485         debug_cpu_state         cpu_state;      // cpu state
 486 } debug_breakpoint_hit;
 487
 488 // B_DEBUGGER_MESSAGE_WATCHPOINT_HIT
 489
 490 typedef struct {
 491         debug_origin            origin;
 492         debug_cpu_state         cpu_state;      // cpu state
 493 } debug_watchpoint_hit;
 494
 495 // B_DEBUGGER_MESSAGE_SINGLE_STEP
 496
 497 typedef struct {
 498         debug_origin            origin;
 499         debug_cpu_state         cpu_state;      // cpu state
 500 } debug_single_step;
 501
 502 // B_DEBUGGER_MESSAGE_PRE_SYSCALL
 503
 504 typedef struct {
 505         debug_origin    origin;
 506         uint32                  syscall;                // the syscall number
 507         uint8                   args[128];              // syscall arguments
 508 } debug_pre_syscall;
 509
 510 // B_DEBUGGER_MESSAGE_POST_SYSCALL
 511
 512 typedef struct {
 513         debug_origin    origin;
 514         bigtime_t               start_time;             // time of syscall start
 515         bigtime_t               end_time;               // time of syscall completion
 516         uint64                  return_value;   // the syscall's return value
 517         uint32                  syscall;                // the syscall number
 518         uint8                   args[128];              // syscall arguments
 519 } debug_post_syscall;
 520
 521 // B_DEBUGGER_MESSAGE_SIGNAL_RECEIVED
 522
 523 typedef struct {
 524         debug_origin            origin;
 525         int                                     signal;         // the signal
 526         struct sigaction        handler;        // the signal handler
 527         bool                            deadly;         // true, if handling the signal will kill
 528                                                                         // the team
 529 } debug_signal_received;
 530
 531 // B_DEBUGGER_MESSAGE_EXCEPTION_OCCURRED
 532
 533 typedef struct {
 534         debug_origin                    origin;
 535         debug_exception_type    exception;              // the exception
 536         int                                             signal;                 // the signal that will be sent,
 537                                                                                         // when the thread continues
 538                                                                                         // normally
 539 } debug_exception_occurred;
 540
 541 // B_DEBUGGER_MESSAGE_TEAM_CREATED
 542
 543 typedef struct {
 544         debug_origin    origin;
 545         team_id                 new_team;               // the newly created team
 546 } debug_team_created;
 547
 548 // B_DEBUGGER_MESSAGE_TEAM_DELETED
 549
 550 typedef struct {
 551         debug_origin    origin;                 // thread is < 0, team is the deleted team
 552                                                                         // (asynchronous message)
 553 } debug_team_deleted;
 554
 555 // B_DEBUGGER_MESSAGE_TEAM_EXEC
 556
 557 typedef struct {
 558         debug_origin    origin;
 559         int32                   image_event;    // number of the image event
 560 } debug_team_exec;
 561
 562 // B_DEBUGGER_MESSAGE_THREAD_CREATED
 563
 564 typedef struct {
 565         debug_origin    origin;                 // the thread that created the new thread
 566         team_id                 new_thread;             // the newly created thread
 567 } debug_thread_created;
 568
 569 // B_DEBUGGER_MESSAGE_THREAD_DELETED
 570
 571 typedef struct {
 572         debug_origin    origin;                 // the deleted thread (asynchronous message)
 573 } debug_thread_deleted;
 574
 575 // B_DEBUGGER_MESSAGE_IMAGE_CREATED
 576
 577 typedef struct {
 578         debug_origin    origin;
 579         image_info              info;                   // info for the image
 580         int32                   image_event;    // number of the image event
 581 } debug_image_created;
 582
 583 // B_DEBUGGER_MESSAGE_IMAGE_DELETED
 584
 585 typedef struct {
 586         debug_origin    origin;
 587         image_info              info;                   // info for the image
 588         int32                   image_event;    // number of the image event
 589 } debug_image_deleted;
 590
 591 // B_DEBUGGER_MESSAGE_PROFILER_UPDATE
 592
 593 typedef struct {
 594         debug_origin            origin;
 595         int32                           image_event;    // number of the last image event; all
 596                                                                                 // samples were recorded after this
 597                                                                                 // event and before the next one
 598         int32                           stack_depth;    // number of return addresses per tick
 599         int32                           sample_count;   // number of samples in the buffer
 600         int32                           dropped_ticks;  // number of ticks that had been
 601                                                                                 // dropped, since the buffer was full
 602         bool                            variable_stack_depth;
 603                                                                                 // the number of samples per hit is
 604                                                                                 // variable, i.e. the format for the
 605                                                                                 // samples of a hit in the buffer is
 606                                                                                 //   <n> <sample 1> ... <sample n>
 607                                                                                 // instead of
 608                                                                                 //   <sample 1> ... <sample stack_depth>
 609         bool                            stopped;                // if true, the thread is no longer
 610                                                                                 // being profiled
 611 } debug_profiler_update;
 612
 613 // B_DEBUGGER_MESSAGE_HANDED_OVER
 614
 615 typedef struct {
 616         debug_origin    origin;                 // thread is < 0, team is the deleted team
 617                                                                         // (asynchronous message)
 618         team_id                 debugger;               // the new debugger
 619         port_id                 debugger_port;  // the port the new debugger uses
 620         thread_id               causing_thread; // the thread that caused entering the
 621                                                                         // debugger in the first place, -1 if the
 622                                                                         // debugger wasn't attached automatically
 623 } debug_handed_over;
 624
 625 // union of all messages structures sent to the debugger
 626 typedef union {
 627         debug_thread_debugged                   thread_debugged;
 628         debug_debugger_call                             debugger_call;
 629         debug_breakpoint_hit                    breakpoint_hit;
 630         debug_watchpoint_hit                    watchpoint_hit;
 631         debug_single_step                               single_step;
 632         debug_pre_syscall                               pre_syscall;
 633         debug_post_syscall                              post_syscall;
 634         debug_signal_received                   signal_received;
 635         debug_exception_occurred                exception_occurred;
 636         debug_team_created                              team_created;
 637         debug_team_deleted                              team_deleted;
 638         debug_team_exec                                 team_exec;
 639         debug_thread_created                    thread_created;
 640         debug_thread_deleted                    thread_deleted;
 641         debug_image_created                             image_created;
 642         debug_image_deleted                             image_deleted;
 643         debug_profiler_update                   profiler_update;
 644         debug_handed_over                               handed_over;
 645
 646         debug_origin                                    origin; // for convenience (no real message)
 647 } debug_debugger_message_data;
 648
 649
 650 extern void get_debug_message_string(debug_debugger_message message,
 651                 char *buffer, int32 bufferSize);
 652 extern void get_debug_exception_string(debug_exception_type exception,
 653                 char *buffer, int32 bufferSize);
 654
 655
 656 #ifdef __cplusplus
 657 }       // extern "C"
 658 #endif
 659
 660 #endif  // _DEBUGGER_H