GME  13
Modules | Defines | Typedefs | Functions | Variables
Memory Pool Functions
Collaboration diagram for Memory Pool Functions:

Modules

 Pool Cleanup Functions
 Pool Debugging functions.

Defines

#define APR_POOL_DECLARE_ACCESSOR(type)
#define APR_POOL_IMPLEMENT_ACCESSOR(type)
#define APR_POOL_DEBUG   0
#define APR_POOL__FILE_LINE__   __FILE__ ":" APR_STRINGIFY(__LINE__)
#define apr_pool_create(newpool, parent)   apr_pool_create_ex(newpool, parent, NULL, NULL)
#define apr_pool_create_core(newpool)   apr_pool_create_unmanaged_ex(newpool, NULL, NULL)
#define apr_pool_create_unmanaged(newpool)   apr_pool_create_unmanaged_ex(newpool, NULL, NULL)
#define apr_pcalloc(p, size)   memset(apr_palloc(p, size), 0, size)

Typedefs

typedef struct apr_pool_t apr_pool_t
typedef int(* apr_abortfunc_t )(int retcode)

Functions

 APR_DECLARE (apr_status_t) apr_pool_initialize(void)
 APR_DECLARE (void) apr_pool_terminate(void)
apr_pool_t apr_abortfunc_t
apr_allocator_t *allocator 
__attribute__ ((nonnull(1)))
 APR_DECLARE (apr_allocator_t *) apr_pool_allocator_get(apr_pool_t *pool) __attribute__((nonnull(1)))
 APR_DECLARE (void *) apr_palloc(apr_pool_t *p
apr_pool_t *pool __attribute__ ((nonnull(2)))
 APR_DECLARE (apr_abortfunc_t) apr_pool_abort_get(apr_pool_t *pool) __attribute__((nonnull(1)))
 APR_DECLARE (apr_pool_t *) apr_pool_parent_get(apr_pool_t *pool) __attribute__((nonnull(1)))
const char apr_pool_t *pool __attribute__ ((nonnull(1, 2, 3)))

Variables

apr_pool_tparent
apr_pool_t apr_abortfunc_t abort_fn
apr_abortfunc_t apr_allocator_tallocator
apr_abortfunc_t
apr_allocator_t const char * 
file_line
apr_size_t size
apr_pool_tb
const char * key
const char apr_status_t(* cleanup )(void *)
const char apr_status_t(*)
apr_pool_t *poo 
__attribute__ )((nonnull(2, 4)))

Define Documentation

#define apr_pcalloc (   p,
  size 
)    memset(apr_palloc(p, size), 0, size)

Allocate a block of memory from a pool and set all of the memory to 0

Parameters:
pThe pool to allocate from
sizeThe amount of memory to allocate
Returns:
The allocated memory

Definition at line 461 of file apr_pools.h.

#define APR_POOL__FILE_LINE__   __FILE__ ":" APR_STRINGIFY(__LINE__)

the place in the code where the particular function was called

Definition at line 143 of file apr_pools.h.

#define apr_pool_create (   newpool,
  parent 
)    apr_pool_create_ex(newpool, parent, NULL, NULL)

Create a new pool.

Parameters:
newpoolThe pool we have just created.
parentThe parent pool. If this is NULL, the new pool is a root pool. If it is non-NULL, the new pool will inherit all of its parent pool's attributes, except the apr_pool_t will be a sub-pool.
Remarks:
This function is thread-safe, in the sense that multiple threads can safely create subpools of the same parent pool concurrently. Similarly, a subpool can be created by one thread at the same time that another thread accesses the parent pool.

Definition at line 318 of file apr_pools.h.

#define apr_pool_create_core (   newpool)    apr_pool_create_unmanaged_ex(newpool, NULL, NULL)

Create a new pool.

Parameters:
newpoolThe pool we have just created.

Definition at line 339 of file apr_pools.h.

#define apr_pool_create_unmanaged (   newpool)    apr_pool_create_unmanaged_ex(newpool, NULL, NULL)

Definition at line 341 of file apr_pools.h.

#define APR_POOL_DEBUG   0

Pool debug levels

 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
 ---------------------------------
 |   |   |   |   |   |   |   | x |  General debug code enabled (useful in
                                    combination with --with-efence).
 |   |   |   |   |   |   | x |   |  Verbose output on stderr (report
                                    CREATE, CLEAR, DESTROY).
 |   |   |   | x |   |   |   |   |  Verbose output on stderr (report
                                    PALLOC, PCALLOC).
 |   |   |   |   |   | x |   |   |  Lifetime checking. On each use of a
                                    pool, check its lifetime.  If the pool
                                    is out of scope, abort().
                                    In combination with the verbose flag
                                    above, it will output LIFE in such an
                                    event prior to aborting.
 |   |   |   |   | x |   |   |   |  Pool owner checking.  On each use of a
                                    pool, check if the current thread is the
                                    pools owner.  If not, abort().  In
                                    combination with the verbose flag above,
                                    it will output OWNER in such an event
                                    prior to aborting.  Use the debug
                                    function apr_pool_owner_set() to switch
                                    a pools ownership.
 When no debug level was specified, assume general debug mode.
 If level 0 was specified, debugging is switched off
 

Definition at line 139 of file apr_pools.h.

Value:
APR_DECLARE(apr_pool_t *) apr_##type##_pool_get \
        (const apr_##type##_t *the##type)

Declaration helper macro to construct apr_foo_pool_get()s.

This standardized macro is used by opaque (APR) data types to return the apr_pool_t that is associated with the data type.

APR_POOL_DECLARE_ACCESSOR() is used in a header file to declare the accessor function. A typical usage and result would be:

    APR_POOL_DECLARE_ACCESSOR(file);
 becomes:
    APR_DECLARE(apr_pool_t *) apr_file_pool_get(apr_file_t *ob);
 
Remarks:
Doxygen unwraps this macro (via doxygen.conf) to provide actual help for each specific occurance of apr_foo_pool_get.
the linkage is specified for APR. It would be possible to expand the macros to support other linkages.

Definition at line 81 of file apr_pools.h.

Value:
APR_DECLARE(apr_pool_t *) apr_##type##_pool_get \
            (const apr_##type##_t *the##type) \
        { return the##type->pool; }

Implementation helper macro to provide apr_foo_pool_get()s.

In the implementation, the APR_POOL_IMPLEMENT_ACCESSOR() is used to actually define the function. It assumes the field is named "pool".

Definition at line 91 of file apr_pools.h.


Typedef Documentation

typedef int(* apr_abortfunc_t)(int retcode)

A function that is called when allocation fails.

Definition at line 148 of file apr_pools.h.

typedef struct apr_pool_t apr_pool_t

The fundamental pool type

Definition at line 60 of file apr_pools.h.


Function Documentation

apr_pool_t* pool __attribute__ ( (nonnull(2))  )
const char apr_pool_t* pool __attribute__ ( (nonnull(1, 2, 3))  )

Setup all of the internal structures required to use pools

Remarks:
Programs do NOT need to call this directly. APR will call this automatically from apr_initialize.

Create a new pool.

Parameters:
newpoolThe pool we have just created.
parentThe parent pool. If this is NULL, the new pool is a root pool. If it is non-NULL, the new pool will inherit all of its parent pool's attributes, except the apr_pool_t will be a sub-pool.
abort_fnA function to use if the pool cannot allocate more memory.
allocatorThe allocator to use with the new pool. If NULL the allocator of the parent pool will be used.
Remarks:
This function is thread-safe, in the sense that multiple threads can safely create subpools of the same parent pool concurrently. Similarly, a subpool can be created by one thread at the same time that another thread accesses the parent pool.

Create a new pool.

Deprecated:
See also:
apr_pool_create_unmanaged_ex.

Create a new unmanaged pool.

Parameters:
newpoolThe pool we have just created.
abort_fnA function to use if the pool cannot allocate more memory.
allocatorThe allocator to use with the new pool. If NULL a new allocator will be crated with newpool as owner.
Remarks:
An unmanaged pool is a special pool without a parent; it will NOT be destroyed upon apr_terminate. It must be explicitly destroyed by calling apr_pool_destroy, to prevent memory leaks. Use of this function is discouraged, think twice about whether you really really need it.

Debug version of apr_pool_create_ex.

Parameters:
newpool
See also:
apr_pool_create.
Parameters:
parent
See also:
apr_pool_create.
Parameters:
abort_fn
See also:
apr_pool_create.
Parameters:
allocator
See also:
apr_pool_create.
Parameters:
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Remarks:
Only available when APR_POOL_DEBUG is defined. Call this directly if you have you apr_pool_create_ex calls in a wrapper function and wish to override the file_line argument to reflect the caller of your wrapper function. If you do not have apr_pool_create_ex in a wrapper, trust the macro and don't call apr_pool_create_ex_debug directly.

Debug version of apr_pool_create_core_ex.

Deprecated:
See also:
apr_pool_create_unmanaged_ex_debug.

Debug version of apr_pool_create_unmanaged_ex.

Parameters:
newpool
See also:
apr_pool_create_unmanaged.
Parameters:
abort_fn
See also:
apr_pool_create_unmanaged.
Parameters:
allocator
See also:
apr_pool_create_unmanaged.
Parameters:
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Remarks:
Only available when APR_POOL_DEBUG is defined. Call this directly if you have you apr_pool_create_unmanaged_ex calls in a wrapper function and wish to override the file_line argument to reflect the caller of your wrapper function. If you do not have apr_pool_create_core_ex in a wrapper, trust the macro and don't call apr_pool_create_core_ex_debug directly.

Determine if pool a is an ancestor of pool b.

Parameters:
aThe pool to search
bThe pool to search for
Returns:
True if a is an ancestor of b, NULL is considered an ancestor of all pools.
Remarks:
if compiled with APR_POOL_DEBUG, this function will also return true if A is a pool which has been guaranteed by the caller (using apr_pool_join) to have a lifetime at least as long as some ancestor of pool B.

Set the data associated with the current pool

Parameters:
dataThe user data associated with the pool.
keyThe key to use for association
cleanupThe cleanup program to use to cleanup the data (NULL if none)
poolThe current pool
Warning:
The data to be attached to the pool should have a life span at least as long as the pool it is being attached to.

Users of APR must take EXTREME care when choosing a key to use for their data. It is possible to accidentally overwrite data by choosing a key that another part of the program is using. Therefore it is advised that steps are taken to ensure that unique keys are used for all of the userdata objects in a particular pool (the same key in two different pools or a pool and one of its subpools is okay) at all times. Careful namespace prefixing of key names is a typical way to help ensure this uniqueness.

Set the data associated with the current pool

Parameters:
dataThe user data associated with the pool.
keyThe key to use for association
cleanupThe cleanup program to use to cleanup the data (NULL if none)
poolThe current pool
Note:
same as apr_pool_userdata_set(), except that this version doesn't make a copy of the key (this function is useful, for example, when the key is a string literal)
Warning:
This should NOT be used if the key could change addresses by any means between the apr_pool_userdata_setn() call and a subsequent apr_pool_userdata_get() on that key, such as if a static string is used as a userdata key in a DSO and the DSO could be unloaded and reloaded between the _setn() and the _get(). You MUST use apr_pool_userdata_set() in such cases.
More generally, the key and the data to be attached to the pool should have a life span at least as long as the pool itself.

Return the data associated with the current pool.

Parameters:
dataThe user data associated with the pool.
keyThe key for the data to retrieve
poolThe current pool.
APR_DECLARE ( void  )

Tear down all of the internal structures required to use pools

Remarks:
Programs do NOT need to call this directly. APR will call this automatically from apr_terminate.

Clear all memory in the pool and run all the cleanups. This also destroys all subpools.

Parameters:
pThe pool to clear
Remarks:
This does not actually free the memory, it just allows the pool to re-use this memory for the next allocation.
See also:
apr_pool_destroy()

Debug version of apr_pool_clear.

Parameters:
pSee: apr_pool_clear.
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Remarks:
Only available when APR_POOL_DEBUG is defined. Call this directly if you have you apr_pool_clear calls in a wrapper function and wish to override the file_line argument to reflect the caller of your wrapper function. If you do not have apr_pool_clear in a wrapper, trust the macro and don't call apr_pool_destroy_clear directly.

Destroy the pool. This takes similar action as apr_pool_clear() and then frees all the memory.

Parameters:
pThe pool to destroy
Remarks:
This will actually free the memory

Debug version of apr_pool_destroy.

Parameters:
pSee: apr_pool_destroy.
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Remarks:
Only available when APR_POOL_DEBUG is defined. Call this directly if you have you apr_pool_destroy calls in a wrapper function and wish to override the file_line argument to reflect the caller of your wrapper function. If you do not have apr_pool_destroy in a wrapper, trust the macro and don't call apr_pool_destroy_debug directly.

Set the function to be called when an allocation failure occurs.

Remarks:
If the program wants APR to exit on a memory allocation error, then this function can be called to set the callback to use (for performing cleanup and then exiting). If this function is not called, then APR will return an error and expect the calling program to deal with the error accordingly.

Tag a pool (give it a name)

Parameters:
poolThe pool to tag
tagThe tag

Register a function to be called when a pool is cleared or destroyed

Parameters:
pThe pool register the cleanup with
dataThe data to pass to the cleanup function.
plain_cleanupThe function to call when the pool is cleared or destroyed
child_cleanupThe function to call when a child process is about to exec - this function is called in the child, obviously!

Remove a previously registered cleanup function.

The cleanup most recently registered with p having the same values of data and cleanup will be removed.

Parameters:
pThe pool to remove the cleanup from
dataThe data of the registered cleanup
cleanupThe function to remove from cleanup
Remarks:
For some strange reason only the plain_cleanup is handled by this function

Replace the child cleanup function of a previously registered cleanup.

The cleanup most recently registered with p having the same values of data and plain_cleanup will have the registered child cleanup function replaced with child_cleanup.

Parameters:
pThe pool of the registered cleanup
dataThe data of the registered cleanup
plain_cleanupThe plain cleanup function of the registered cleanup
child_cleanupThe function to register as the child cleanup

Run all registered child cleanups, in preparation for an exec() call in a forked child -- close files, etc., but *don't* flush I/O buffers, *don't* wait for subprocesses, and *don't* free any memory.

Find the pool's allocator

Parameters:
poolThe pool to get the allocator from.
APR_DECLARE ( void *  )

Allocate a block of memory from a pool

Parameters:
pThe pool to allocate from
sizeThe amount of memory to allocate
Returns:
The allocated memory

Debug version of apr_palloc

Parameters:
pSee: apr_palloc
sizeSee: apr_palloc
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Returns:
See: apr_palloc

Debug version of apr_pcalloc

Parameters:
pSee: apr_pcalloc
sizeSee: apr_pcalloc
file_lineWhere the function is called from. This is usually APR_POOL__FILE_LINE__.
Returns:
See: apr_pcalloc

Get the abort function associated with the specified pool.

Parameters:
poolThe pool for retrieving the abort function.
Returns:
The abort function for the given pool.

Get the parent pool of the specified pool.

Parameters:
poolThe pool for retrieving the parent pool.
Returns:
The parent of the given pool.

Variable Documentation

const char *tag __attribute__ ( (nonnull(2, 4))  )

Definition at line 563 of file apr_pools.h.

Definition at line 197 of file apr_pools.h.

Definition at line 207 of file apr_pools.h.

Definition at line 525 of file apr_pools.h.

const void apr_status_t(*) apr_status_t(*) void apr_status_t(* cleanup)(void *)) __attribute__((nonnull(3)))

Definition at line 561 of file apr_pools.h.

Definition at line 261 of file apr_pools.h.

const char* key

Definition at line 560 of file apr_pools.h.

Definition at line 197 of file apr_pools.h.

apr_size_t size

Definition at line 440 of file apr_pools.h.