Using RTC on a Child Process

dbx supports Runtime Checking of a child process if RTC is enabled for the parent and the dbxenv variable follow_fork_mode is set to child. When a fork happens, dbx automatically performs RTC on the child. If the program does an exec(), the RTC settings of the program calling exec() are passed on to the program.

At any given time, just one process can be under RTC control. Following is an example:

% cat -n program1.c
     1 #include <sys/types.h>
     2 #include <unistd.h>
     3 #include <stdio.h>
     4
     5 int
     6 main()
     7 {
     8      pid_t child_pid;
     9      int parent_i, parent_j;
    10
    11      parent_i = parent_j;
    12
    13      child_pid = fork();
    14
    15      if (child_pid == -1) {
    16          printf("parent: Fork failed\n");
    17          return 1;
    18      } else if (child_pid == 0) {
    19          int child_i, child_j;
    20
    21          printf("child: In child\n");
    22          child_i = child_j;
    23          if (execl("./program2", NULL) == -1) {
    24              printf("child: exec of program2 failed\n");
    25              exit(1);
    26          }
    27      } else {
    28          printf("parent: child's pid = %d\n", child_pid);
    29      }
    30      return 0;
    31 }
%

 % cat -n program2.c
     1
     2 #include <stdio.h>
     3
     4 main()
     5 {
     6      int program2_i, program2_j;
     7
     8      printf ("program2: pid = %d\n", getpid());
     9      program2_i = program2_j;
    10
    11      malloc(8);
    12
    13      return 0;
    14 }
% 

RTC reports first error in the parent, program1
 % cc -g -o program1 program1.c
 % cc -g -o program2 program2.c
 % dbx -C program1
 Reading symbolic information for program1
 Reading symbolic information for rtld /usr/lib/ld.so.1
 Reading symbolic information for librtc.so
 Reading symbolic information for libc.so.1
 Reading symbolic information for libdl.so.1
 Reading symbolic information for libc_psr.so.1
 (dbx) check -all 
 access checking - ON
 memuse checking - ON 
 (dbx) dbxenv follow_fork_mode child
 (dbx) run  
 Running: program1 
 (process id 3885)
 Enabling Error Checking... done
 Read from uninitialized (rui):
 Attempting to read 4 bytes at address 0xeffff110
     which is 104 bytes above the current stack pointer
 Variable is 'parent_j'
 Current function is main
   11       parent_i = parent_j;

Because  follow_fork_mode is set to child, when the fork occurs error checking is switched from the parent to the child process




RTC reports an error in the child

 




When the exec of program2 occurs, the RTC settings are inherited by 
program2 so access and memory use checking are enabled for that process






RTC reports an access error in the executed program, program2 
 (dbx) cont
 dbx: warning: Fork occurred; error checking disabled in parent
 detaching from process 3885
 Attached to process 3886
 stopped in _fork at 0xef6b6040
 0xef6b6040: _fork+0x0008:	bgeu    _fork+0x30
 Current function is main
    13       child_pid = fork();
 parent: child's pid = 3886
 (dbx) cont
 child: In child
 Read from uninitialized (rui):
 Attempting to read 4 bytes at address 0xeffff108
     which is 96 bytes above the current stack pointer
 Variable is 'child_j'
 Current function is main
    22   	child_i = child_j;
 (dbx) cont
 dbx: process 3886 about to exec("./program2")
 dbx: program "./program2" just exec'ed
 dbx: to go back to the original program use "debug $oprog"
 Reading symbolic information for program2
 Skipping ld.so.1, already read
 Skipping librtc.so, already read
 Skipping libc.so.1, already read
 Skipping libdl.so.1, already read
 Skipping libc_psr.so.1, already read
 Enabling Error Checking... done
 stopped in main at line 8 in file "program2.c"
     8       printf ("program2: pid = %d\n", getpid());
(dbx) cont
 program2: pid = 3886
 Read from uninitialized (rui):
 Attempting to read 4 bytes at address 0xeffff13c
     which is 100 bytes above the current stack pointer
 Variable is 'program2_j'
 Current function is main
     9       program2_i = program2_j;
 (dbx) cont
 Checking for memory leaks...

RTC prints a memory use and  memory leak report for the process that exited while under RTC control, 
program2
 Actual leaks report   (actual leaks:      1  total size:   8   
 bytes)

  Total  Num of  Leaked      Allocation call stack
  Size   Blocks  Block
                Address
 ======  ====== ========== ====================================
      8       1    0x20c50  main 

 Possible leaks report  (possible leaks:   0  total size:   0 
 bytes)

 execution completed, exit code is 0