Memory Pool Functions
[Apache Portability Runtime library]


Modules

 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_sub_make(newpool, parent, abort_fn)   (void)apr_pool_create_ex(newpool, parent, abort_fn, NULL)

Typedefs

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

Functions

apr_status_t apr_pool_initialize (void)
void apr_pool_terminate (void)
apr_status_t apr_pool_create_ex (apr_pool_t **newpool, apr_pool_t *parent, apr_abortfunc_t abort_fn, apr_allocator_t *allocator)
apr_status_t apr_pool_create_ex_debug (apr_pool_t **newpool, apr_pool_t *parent, apr_abortfunc_t abort_fn, apr_allocator_t *allocator, const char *file_line)
apr_status_t apr_pool_create (apr_pool_t **newpool, apr_pool_t *parent)
apr_allocator_tapr_pool_allocator_get (apr_pool_t *pool)
void apr_pool_clear (apr_pool_t *p)
void apr_pool_clear_debug (apr_pool_t *p, const char *file_line)
void apr_pool_destroy (apr_pool_t *p)
void apr_pool_destroy_debug (apr_pool_t *p, const char *file_line)
void * apr_palloc (apr_pool_t *p, apr_size_t size)
void * apr_palloc_debug (apr_pool_t *p, apr_size_t size, const char *file_line)
void * apr_pcalloc (apr_pool_t *p, apr_size_t size)
void * apr_pcalloc_debug (apr_pool_t *p, apr_size_t size, const char *file_line)
void apr_pool_abort_set (apr_abortfunc_t abortfunc, apr_pool_t *pool)
void apr_pool_set_abort (apr_abortfunc_t abortfunc, apr_pool_t *pool)
apr_abortfunc_t apr_pool_abort_get (apr_pool_t *pool)
apr_abortfunc_t apr_pool_get_abort (apr_pool_t *pool)
apr_pool_tapr_pool_parent_get (apr_pool_t *pool)
apr_pool_tapr_pool_get_parent (apr_pool_t *pool)
int apr_pool_is_ancestor (apr_pool_t *a, apr_pool_t *b)
void apr_pool_tag (apr_pool_t *pool, const char *tag)
apr_status_t apr_pool_userdata_set (const void *data, const char *key, apr_status_t(*cleanup)(void *), apr_pool_t *pool)
apr_status_t apr_pool_userdata_setn (const void *data, const char *key, apr_status_t(*cleanup)(void *), apr_pool_t *pool)
apr_status_t apr_pool_userdata_get (void **data, const char *key, apr_pool_t *pool)
void apr_pool_cleanup_register (apr_pool_t *p, const void *data, apr_status_t(*plain_cleanup)(void *), apr_status_t(*child_cleanup)(void *))
void apr_pool_cleanup_kill (apr_pool_t *p, const void *data, apr_status_t(*cleanup)(void *))
void apr_pool_child_cleanup_set (apr_pool_t *p, const void *data, apr_status_t(*plain_cleanup)(void *), apr_status_t(*child_cleanup)(void *))
apr_status_t apr_pool_cleanup_run (apr_pool_t *p, void *data, apr_status_t(*cleanup)(void *))
apr_status_t apr_pool_cleanup_null (void *data)
void apr_pool_cleanup_for_exec (void)

Define Documentation

#define APR_POOL__FILE_LINE__   __FILE__ ":" APR_STRINGIFY(__LINE__)

the place in the code where the particular function was called

#define APR_POOL_DEBUG   0

Pool debug levels

 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
 ---------------------------------
 |   |   |   |   |   |   |   | x |  General debug code enabled (usefull 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
 

#define APR_POOL_DECLARE_ACCESSOR ( type   ) 

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.

#define APR_POOL_IMPLEMENT_ACCESSOR ( type   ) 

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".

#define apr_pool_sub_make ( newpool,
parent,
abort_fn   )     (void)apr_pool_create_ex(newpool, parent, abort_fn, NULL)

Deprecated:
See also:
apr_pool_create_ex


Typedef Documentation

typedef int(*) apr_abortfunc_t(int retcode)

A function that is called when allocation fails.

typedef struct apr_pool_t apr_pool_t

The fundamental pool type


Function Documentation

void* apr_palloc ( apr_pool_t p,
apr_size_t  size 
)

Allocate a block of memory from a pool

Parameters:
p The pool to allocate from
size The amount of memory to allocate
Returns:
The allocated memory

void* apr_palloc_debug ( apr_pool_t p,
apr_size_t  size,
const char *  file_line 
)

Debug version of apr_palloc

Parameters:
p See: apr_palloc
size See: apr_palloc
file_line Where the function is called from. This is usually APR_POOL__FILE_LINE__.
Returns:
See: apr_palloc

void* apr_pcalloc ( apr_pool_t p,
apr_size_t  size 
)

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

Parameters:
p The pool to allocate from
size The amount of memory to allocate
Returns:
The allocated memory

void* apr_pcalloc_debug ( apr_pool_t p,
apr_size_t  size,
const char *  file_line 
)

Debug version of apr_pcalloc

Parameters:
p See: apr_pcalloc
size See: apr_pcalloc
file_line Where the function is called from. This is usually APR_POOL__FILE_LINE__.
Returns:
See: apr_pcalloc

apr_abortfunc_t apr_pool_abort_get ( apr_pool_t pool  ) 

Get the abort function associated with the specified pool.

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

void apr_pool_abort_set ( apr_abortfunc_t  abortfunc,
apr_pool_t pool 
)

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.

apr_allocator_t* apr_pool_allocator_get ( apr_pool_t pool  ) 

Find the pools allocator

Parameters:
pool The pool to get the allocator from.

void apr_pool_child_cleanup_set ( apr_pool_t p,
const void *  data,
apr_status_t(*)(void *)  plain_cleanup,
apr_status_t(*)(void *)  child_cleanup 
)

Replace the child cleanup of a previously registered cleanup

Parameters:
p The pool of the registered cleanup
data The data of the registered cleanup
plain_cleanup The plain cleanup function of the registered cleanup
child_cleanup The function to register as the child cleanup

void apr_pool_cleanup_for_exec ( void   ) 

Run all of the child_cleanups, so that any unnecessary files are closed because we are about to exec a new program

void apr_pool_cleanup_kill ( apr_pool_t p,
const void *  data,
apr_status_t(*)(void *)  cleanup 
)

Remove a previously registered cleanup function

Parameters:
p The pool remove the cleanup from
data The data to remove from cleanup
cleanup The function to remove from cleanup
Remarks:
For some strange reason only the plain_cleanup is handled by this function

apr_status_t apr_pool_cleanup_null ( void *  data  ) 

An empty cleanup function

Parameters:
data The data to cleanup

void apr_pool_cleanup_register ( apr_pool_t p,
const void *  data,
apr_status_t(*)(void *)  plain_cleanup,
apr_status_t(*)(void *)  child_cleanup 
)

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

Parameters:
p The pool register the cleanup with
data The data to pass to the cleanup function.
plain_cleanup The function to call when the pool is cleared or destroyed
child_cleanup The function to call when a child process is being shutdown - this function is called in the child, obviously!

apr_status_t apr_pool_cleanup_run ( apr_pool_t p,
void *  data,
apr_status_t(*)(void *)  cleanup 
)

Run the specified cleanup function immediately and unregister it. Use data instead of the data that was registered with the cleanup.

Parameters:
p The pool remove the cleanup from
data The data to remove from cleanup
cleanup The function to remove from cleanup

void apr_pool_clear ( apr_pool_t p  ) 

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

Parameters:
p The 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()

void apr_pool_clear_debug ( apr_pool_t p,
const char *  file_line 
)

Debug version of apr_pool_clear.

Parameters:
p See: apr_pool_clear.
file_line Where 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.

apr_status_t apr_pool_create ( apr_pool_t **  newpool,
apr_pool_t parent 
)

Create a new pool.

Parameters:
newpool The pool we have just created.
parent The 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.

apr_status_t apr_pool_create_ex ( apr_pool_t **  newpool,
apr_pool_t parent,
apr_abortfunc_t  abort_fn,
apr_allocator_t allocator 
)

Create a new pool.

Parameters:
newpool The pool we have just created.
parent The 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_fn A function to use if the pool cannot allocate more memory.
allocator The allocator to use with the new pool. If NULL the allocator of the parent pool will be used.

apr_status_t apr_pool_create_ex_debug ( apr_pool_t **  newpool,
apr_pool_t parent,
apr_abortfunc_t  abort_fn,
apr_allocator_t allocator,
const char *  file_line 
)

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_line Where 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.

void apr_pool_destroy ( apr_pool_t p  ) 

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

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

void apr_pool_destroy_debug ( apr_pool_t p,
const char *  file_line 
)

Debug version of apr_pool_destroy.

Parameters:
p See: apr_pool_destroy.
file_line Where 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.

apr_abortfunc_t apr_pool_get_abort ( apr_pool_t pool  ) 

Deprecated:
See also:
apr_pool_abort_get

apr_pool_t* apr_pool_get_parent ( apr_pool_t pool  ) 

Deprecated:
See also:
apr_pool_parent_get

apr_status_t apr_pool_initialize ( void   ) 

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.

int apr_pool_is_ancestor ( apr_pool_t a,
apr_pool_t b 
)

Determine if pool a is an ancestor of pool b

Parameters:
a The pool to search
b The pool to search for
Returns:
True if a is an ancestor of b, NULL is considered an ancestor of all pools.

apr_pool_t* apr_pool_parent_get ( apr_pool_t pool  ) 

Get the parent pool of the specified pool.

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

void apr_pool_set_abort ( apr_abortfunc_t  abortfunc,
apr_pool_t pool 
)

Deprecated:
See also:
apr_pool_abort_set

void apr_pool_tag ( apr_pool_t pool,
const char *  tag 
)

Tag a pool (give it a name)

Parameters:
pool The pool to tag
tag The tag

void apr_pool_terminate ( 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.

apr_status_t apr_pool_userdata_get ( void **  data,
const char *  key,
apr_pool_t pool 
)

Return the data associated with the current pool.

Parameters:
data The user data associated with the pool.
key The key for the data to retrieve
pool The current pool.

apr_status_t apr_pool_userdata_set ( const void *  data,
const char *  key,
apr_status_t(*)(void *)  cleanup,
apr_pool_t pool 
)

Set the data associated with the current pool

Parameters:
data The user data associated with the pool.
key The key to use for association
cleanup The cleanup program to use to cleanup the data (NULL if none)
pool The 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.

apr_status_t apr_pool_userdata_setn ( const void *  data,
const char *  key,
apr_status_t(*)(void *)  cleanup,
apr_pool_t pool 
)

Set the data associated with the current pool

Parameters:
data The user data associated with the pool.
key The key to use for association
cleanup The cleanup program to use to cleanup the data (NULL if none)
pool The 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.


Generated on Mon Nov 26 11:47:27 2007 for Apache Portable Runtime by  doxygen 1.5.2