FREE(9r)FREE(9r)NAME
FREE - General: Deallocates (frees) the allocated kernel virtual memory
SYNOPSIS
#include <sys/malloc.h>
FREE(
void *addr,
int type );
ARGUMENTS
Specifies the memory pointer that points to the allocated memory to be freed. You must have previously set this pointer in the call to MAL-
LOC. You also define the data type for this argument in the call to MALLOC. Specifies the purpose for which the memory is being allocated.
The memory types are defined in the file <malloc.h>. Typically, kernel modules use the constant M_DEVBUF to indicate that kernel module
memory is being allocated (or freed).
DESCRIPTION
The FREE routine deallocates (frees) the allocated kernel virtual memory, which you allocated in a previous call to MALLOC.
NOTES
A memory corruption can occur if a kernel module continues to use the memory after freeing it. The operating system provides a built-in
mechanism to debug such erroneous use of memory. You can enable this debugging feature at boot time by providing the following boot parame-
ter: kmem_debug=1. When you enable this debugging feature, the FREE routine stores the following in the last word of freed memory: The pro-
gram counter (pc) of the module that last freed the memory The checksum of the memory content
The MALLOC routine checks the checksum of the memory content before reallocating this corrupted memory. If the checksum of the memory con-
tent does not match the corrupted memory, MALLOC stores the debug information and then causes the kernel to panic. The MALLOC routine
stores the address and size of the corrupted memory and the pc of the routine that last freed it in a kmem_corrupt_data structure.
You should consider the following when using this debugging feature: This debugging feature does not detect cases where the corruption
occurs after malloc reallocates the freed memory to some other module. There is a small chance that the pc of the routine that freed the
memory (stored in the last word of freed memory) may itself become corrupted.
RETURN VALUES
None
SEE ALSO
Routines: MALLOC(9r)FREE(9r)
Check Out this Related Man Page
MALLOC(3) Linux Programmer's Manual MALLOC(3)NAME
calloc, malloc, free, realloc - Allocate and free dynamic memory
SYNOPSIS
#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
DESCRIPTION
calloc() allocates memory for an array of nmemb elements of size bytes each and returns a pointer to the allocated memory. The memory is
set to zero.
malloc() allocates size bytes and returns a pointer to the allocated memory. The memory is not cleared.
free() frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(), calloc() or realloc(). Oth-
erwise, or if free(ptr) has already been called before, undefined behaviour occurs. If ptr is NULL, no operation is performed.
realloc() changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged to the minimum of the old
and new sizes; newly allocated memory will be uninitialized. If ptr is NULL, the call is equivalent to malloc(size); if size is equal to
zero, the call is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc() or
realloc().
RETURN VALUE
For calloc() and malloc(), the value returned is a pointer to the allocated memory, which is suitably aligned for any kind of variable, or
NULL if the request fails.
free() returns no value.
realloc() returns a pointer to the newly allocated memory, which is suitably aligned for any kind of variable and may be different from
ptr, or NULL if the request fails. If size was equal to 0, either NULL or a pointer suitable to be passed to free() is returned. If real-
loc() fails the original block is left untouched - it is not freed or moved.
CONFORMING TO
ANSI-C
SEE ALSO brk(2), posix_memalign(3)NOTES
The Unix98 standard requires malloc(), calloc(), and realloc() to set errno to ENOMEM upon failure. Glibc assumes that this is done (and
the glibc versions of these routines do this); if you use a private malloc implementation that does not set errno, then certain library
routines may fail without having a reason in errno.
Crashes in malloc(), free() or realloc() are almost always related to heap corruption, such as overflowing an allocated chunk or freeing
the same pointer twice.
Recent versions of Linux libc (later than 5.4.23) and GNU libc (2.x) include a malloc implementation which is tunable via environment vari-
ables. When MALLOC_CHECK_ is set, a special (less efficient) implementation is used which is designed to be tolerant against simple
errors, such as double calls of free() with the same argument, or overruns of a single byte (off-by-one bugs). Not all such errors can be
protected against, however, and memory leaks can result. If MALLOC_CHECK_ is set to 0, any detected heap corruption is silently ignored;
if set to 1, a diagnostic is printed on stderr; if set to 2, abort() is called immediately. This can be useful because otherwise a crash
may happen much later, and the true cause for the problem is then very hard to track down.
Linux follows an optimistic memory allocation strategy. This means that when malloc() returns non-NULL there is no guarantee that the mem-
ory really is available. In case it turns out that the system is out of memory, one or more processes will be killed by the infamous OOM
killer.
GNU 1993-04-04 MALLOC(3)