malloc_info man page on Kali

Man page or keyword search:  
man Server   9211 pages
apropos Keyword Search (all sections)
Output format
Kali logo
[printable version]

MALLOC_INFO(3)		   Linux Programmer's Manual		MALLOC_INFO(3)

NAME
       malloc_info - export malloc state to a stream

SYNOPSIS
       #include <malloc.h>

       int malloc_info(int options, FILE *stream);

DESCRIPTION
       The  malloc_info()  function  exports  an XML string that describes the
       current state of the memory-allocation implementation  in  the  caller.
       The  string  is printed on the file stream stream.  The exported string
       includes information about all arenas (see malloc(3)).

       As currently implemented, options must be zero.

RETURN VALUE
       On success, malloc_info() returns 0; on	error,	it  returns  -1,  with
       errno set to indicate the cause.

ERRORS
       EINVAL options was nonzero.

VERSIONS
       malloc_info() was added to glibc in version 2.10.

ATTRIBUTES
       For   an	  explanation	of   the  terms	 used  in  this	 section,  see
       attributes(7).

       ┌──────────────┬───────────────┬─────────┐
       │Interface     │ Attribute     │ Value	│
       ├──────────────┼───────────────┼─────────┤
       │malloc_info() │ Thread safety │ MT-Safe │
       └──────────────┴───────────────┴─────────┘

CONFORMING TO
       This function is a GNU extension.

NOTES
       The memory-allocation information is provided as an XML string  (rather
       than  a	C  structure)  because	the  information  may change over time
       (according to changes in the underlying	implementation).   The	output
       XML string includes a version field.

       The  open_memstream(3)  function can be used to send the output of mal‐
       loc_info() directly into a buffer in memory, rather than to a file.

       The malloc_info() function is designed to address deficiencies in  mal‐
       loc_stats(3) and mallinfo(3).

EXAMPLE
       The program below takes up to four command-line arguments, of which the
       first three are mandatory.  The first argument specifies the number  of
       threads	that the program should create.	 All of the threads, including
       the main thread, allocate the number of blocks of memory	 specified  by
       the  second  argument.	The  third  argument  controls the size of the
       blocks to be allocated.	The main thread creates blocks of  this	 size,
       the second thread created by the program allocates blocks of twice this
       size, the third thread allocates blocks of three times this  size,  and
       so on.

       The  program calls malloc_info() twice to display the memory-allocation
       state.  The first call takes place before any threads  are  created  or
       memory  allocated.  The second call is performed after all threads have
       allocated memory.

       In the following example, the command-line arguments specify  the  cre‐
       ation  of one additional thread, and both the main thread and the addi‐
       tional thread allocate 10000 blocks of memory.	After  the  blocks  of
       memory  have been allocated, malloc_info() shows the state of two allo‐
       cation arenas.

	   $ getconf GNU_LIBC_VERSION
	   glibc 2.13
	   $ ./a.out 1 10000 100
	   ============ Before allocating blocks ============
	   <malloc version="1">
	   <heap nr="0">
	   <sizes>
	   </sizes>
	   <total type="fast" count="0" size="0"/>
	   <total type="rest" count="0" size="0"/>
	   <system type="current" size="135168"/>
	   <system type="max" size="135168"/>
	   <aspace type="total" size="135168"/>
	   <aspace type="mprotect" size="135168"/>
	   </heap>
	   <total type="fast" count="0" size="0"/>
	   <total type="rest" count="0" size="0"/>
	   <system type="current" size="135168"/>
	   <system type="max" size="135168"/>
	   <aspace type="total" size="135168"/>
	   <aspace type="mprotect" size="135168"/>
	   </malloc>

	   ============ After allocating blocks ============
	   <malloc version="1">
	   <heap nr="0">
	   <sizes>
	   </sizes>
	   <total type="fast" count="0" size="0"/>
	   <total type="rest" count="0" size="0"/>
	   <system type="current" size="1081344"/>
	   <system type="max" size="1081344"/>
	   <aspace type="total" size="1081344"/>
	   <aspace type="mprotect" size="1081344"/>
	   </heap>
	   <heap nr="1">
	   <sizes>
	   </sizes>
	   <total type="fast" count="0" size="0"/>
	   <total type="rest" count="0" size="0"/>
	   <system type="current" size="1032192"/>
	   <system type="max" size="1032192"/>
	   <aspace type="total" size="1032192"/>
	   <aspace type="mprotect" size="1032192"/>
	   </heap>
	   <total type="fast" count="0" size="0"/>
	   <total type="rest" count="0" size="0"/>
	   <system type="current" size="2113536"/>
	   <system type="max" size="2113536"/>
	   <aspace type="total" size="2113536"/>
	   <aspace type="mprotect" size="2113536"/>
	   </malloc>

   Program source
       #include <unistd.h>
       #include <stdlib.h>
       #include <pthread.h>
       #include <malloc.h>
       #include <errno.h>

       static size_t blockSize;
       static int numThreads, numBlocks;

       #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
			       } while (0)

       static void *
       thread_func(void *arg)
       {
	   int j;
	   int tn = (int) arg;

	   /* The multiplier '(2 + tn)' ensures that each thread (including
	      the main thread) allocates a different amount of memory */

	   for (j = 0; j < numBlocks; j++)
	       if (malloc(blockSize * (2 + tn)) == NULL)
		   errExit("malloc-thread");

	   sleep(100);	       /* Sleep until main thread terminates */
	   return NULL;
       }

       int
       main(int argc, char *argv[])
       {
	   int j, tn, sleepTime;
	   pthread_t *thr;

	   if (argc < 4) {
	       fprintf(stderr,
		       "%s num-threads num-blocks block-size [sleep-time]\n",
		       argv[0]);
	       exit(EXIT_FAILURE);
	   }

	   numThreads = atoi(argv[1]);
	   numBlocks = atoi(argv[2]);
	   blockSize = atoi(argv[3]);
	   sleepTime = (argc > 4) ? atoi(argv[4]) : 0;

	   thr = calloc(numThreads, sizeof(pthread_t));
	   if (thr == NULL)
	       errExit("calloc");

	   printf("============ Before allocating blocks ============\n");
	   malloc_info(0, stdout);

	   /* Create threads that allocate different amounts of memory */

	   for (tn = 0; tn < numThreads; tn++) {
	       errno = pthread_create(&thr[tn], NULL, thread_func,
				      (void *) tn);
	       if (errno != 0)
		   errExit("pthread_create");

	       /* If we add a sleep interval after the start-up of each
		  thread, the threads likely won't contend for malloc
		  mutexes, and therefore additional arenas won't be
		  allocated (see malloc(3)). */

	       if (sleepTime > 0)
		   sleep(sleepTime);
	   }

	   /* The main thread also allocates some memory */

	   for (j = 0; j < numBlocks; j++)
	       if (malloc(blockSize) == NULL)
		   errExit("malloc");

	   sleep(2);	       /* Give all threads a chance to
				  complete allocations */

	   printf("\n============ After allocating blocks ============\n");
	   malloc_info(0, stdout);

	   exit(EXIT_SUCCESS);
       }

SEE ALSO
       mallinfo(3), malloc(3), malloc_stats(3), mallopt(3), open_memstream(3)

COLOPHON
       This page is part of release 4.14 of the Linux  man-pages  project.   A
       description  of	the project, information about reporting bugs, and the
       latest	 version    of	  this	  page,	   can	   be	  found	    at
       https://www.kernel.org/doc/man-pages/.

GNU				  2017-09-15			MALLOC_INFO(3)
[top]

List of man pages available for Kali

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net