% more memleaks.c  <= source file 
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

void allocate() {
        int *x;
        char *y;

        x = (int *) malloc(sizeof(int) * 100);
        y = (char *) malloc (sizeof(char) * 200);

        printf("\nAddress of x = %u, y = %u", x, y);

        x = (int *) malloc (sizeof(int) * 25);
        y = (char *) malloc (sizeof(char) * 25);

        printf("\nNew address of x = %u, y = %u\n", x, y);
        free (y);
}

void main() {
        while (1) {
                allocate();
                sleep(1);
        }
}

% which cc <= Sun Studio 10 C compiler
/software/SS10/SUNWspro/prod/bin/cc

% cc -g -o memleaks memleaks.c <= Compile the code with debug (-g) flag

% setenv LD_AUDIT /software/SS9/SUNWspro/prod/lib/dbxruntime/rtcaudit.so <= Pre-load rtcaudit library

% ./memleaks
Address of x = 134621928, y = 134622336
New address of x = 134622544, y = 134614272

Address of x = 134622656, y = 134623064
New address of x = 134623272, y = 134614272
...
...

In another window:

% ps -eaf | grep memleaks
  techno 11174 10744   0 19:39:09 syscon      0:00 ./memleaks

% dbx - 11174 <= Attach the process to the debugger, dbx
For information about new features see `help changes'
To remove this message, put `dbxenv suppress_startup_message 7.4' in your .dbxrc
Reading -
Reading ld.so.1
Reading libc.so.1
Reading rtcaudit.so
Reading libmapmalloc.so.1
Reading libgen.so.1
Reading libdl.so.1
Reading libm.so.2
Reading libc_psr.so.1
Reading rtcboot.so
Reading librtc.so

(dbx) dbxenv mt_sync_tracking off <= Turn off mutex tracking

(dbx) check -leaks <= Turn on memory leak checking
leaks checking - ON
RTC: Enabling Error Checking...
RTC: Running program...

(dbx) cont <= Resume program execution
Address of x = 134623384, y = 134623792
New address of x = 134624000, y = 134614272

Address of x = 134624112, y = 134624520
New address of x = 134624728, y = 134614272

Address of x = 134624840, y = 134625248
New address of x = 134625456, y = 134614272

Address of x = 134625568, y = 134625976
New address of x = 134626184, y = 134614272

Address of x = 134626296, y = 134626704
New address of x = 134626912, y = 134614272
^C <= Interrupt the execution with Ctrl-C, to get intermediate leak report
dbx: warning: Interrupt ignored but forwarded to child. 
signal INT (Interrupt) in ___nanosleep at 0xed1bc7dc
0xed1bc7dc: ___nanosleep+0x0004:        ta       8
Current function is main
   24                   sleep(1);

(dbx) showleaks  <= showleaks reports new memory leaks since the last showleaks command
Checking for memory leaks...

Actual leaks report    (actual leaks:           15  total size:       3500 bytes)

  Total     Num of  Leaked     Allocation call stack
  Size      Blocks  Block
                    Address
==========  ====== =========== =======================================
      2000       5      -      allocate < main
      1000       5      -      allocate < main
       500       5      -      allocate < main


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

(dbx) cont <= Continue the execution of the program

Address of x = 139208, y = 139632
New address of x = 139856, y = 139984

Address of x = 140040, y = 140464
New address of x = 140688, y = 135824

Address of x = 140816, y = 141240
New address of x = 141464, y = 136656

Address of x = 141592, y = 142016
New address of x = 142240, y = 137488
^C <= Interrupt the execution with Ctrl-C, to get intermediate leak report
dbx: warning: Interrupt ignored but forwarded to child.
signal INT (Interrupt) in ___nanosleep at 0xed1bc7dc
0xed1bc7dc: ___nanosleep+0x0004:        ta       8
Current function is main
   24                   sleep(1);

(dbx) showleaks  <= showleaks reports new memory leaks since the last showleaks command
Checking for memory leaks...

Actual leaks report    (actual leaks:           12  total size:       2800 bytes)

  Total     Num of  Leaked     Allocation call stack
  Size      Blocks  Block
                    Address
==========  ====== =========== =======================================
      1600       4      -      allocate < main
       800       4      -      allocate < main
       400       4      -      allocate < main


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


(dbx) showleaks -a <= showleaks -a show all the leaks generated so far, 
not just the leaks since the last showleaks command
Checking for memory leaks...

Actual leaks report    (actual leaks:           27  total size:       6300 bytes)

  Total     Num of  Leaked     Allocation call stack
  Size      Blocks  Block
                    Address
==========  ====== =========== =======================================
      3600       9      -      allocate < main
      1800       9      -      allocate < main
       900       9      -      allocate < main


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


(dbx) showleaks -v <= Verbose report, since the last showleaks command. Default: Non verbose report
Checking for memory leaks...

Actual leaks report    (actual leaks:           12  total size:       2800 bytes)

Memory Leak (mel):
Found 4 leaked blocks with total size 1600 bytes
At time of each allocation, the call stack was:
        [1] allocate() at line 9 in "memleaks.c"
        [2] main() at line 23 in "memleaks.c"

Memory Leak (mel):
Found 4 leaked blocks with total size 800 bytes
At time of each allocation, the call stack was:
        [1] allocate() at line 10 in "memleaks.c"
        [2] main() at line 23 in "memleaks.c"

Memory Leak (mel):
Found 4 leaked blocks with total size 400 bytes
At time of each allocation, the call stack was:
        [1] allocate() at line 14 in "memleaks.c"
        [2] main() at line 23 in "memleaks.c"

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

(dbx) func allocate <= Change the current function to allocate

(dbx) list 9 <= List line number 9 of function allocate
    9           x = (int *) malloc(sizeof(int) * 100);

(dbx) list 10
   10           y = (char *) malloc (sizeof(char) * 200);

(dbx) list 14
   14           x = (int *) malloc (sizeof(int) * 25);

(dbx) func main
(dbx) list 23
   23                   allocate();

(dbx)

1. Compile your program with -g (debug) flag, to get source line numbers in the runtime checking error messages. However it is not mandatory to compile with -g to do runtime checking (RTC)
   
   
2. Pre-load RTC library, rtcaudit: setenv LD_AUDIT <path-to-rtcaudit-lib>/rtcaudit.so
   
   
3. Load the program with dbx or attach the running process to dbx with dbx - <pid>
   
   
4. Turn off mutex tracking with dbxenv mt_sync_tracking off -- I have no clue why dbx didn't like mutex tracking on; and there's no relevant documentation anywhere in Sun documentation site. Perhaps Chris Quenelle can explain this
   
   
5. Turn on the runtime checking for memory leaks with check -leaks command
   
   
6. Run the program with run command, if it is not running already
   
   
7. Occasionally interrupt the execution with Ctrl-C, and get the leak report with any of showleaks, showleaks -a, showleaks -v commands
   
   
8. Detach the process, once the data has been collected
   
   
9. Unset the LD_AUDIT variable. unsetenv LD_AUDIT

Posted by: Giri Mandalika.    # 4:32 PM Tweet