The Tor Browser / file revision

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * arena.c

  *

  * This contains the implementation of NSS's thread-safe arenas.

  */

 #ifndef BASE_H

 #include "base.h"

 #endif /* BASE_H */

 #ifdef ARENA_THREADMARK

 #include "prthread.h"

 #endif /* ARENA_THREADMARK */

 #include "prlock.h"

 #include "plarena.h"

 #include <string.h>

 /*

  * NSSArena

  *

  * This is based on NSPR's arena code, but it is threadsafe.

  *

  * The public methods relating to this type are:

  *

  *  NSSArena_Create  -- constructor

  *  NSSArena_Destroy

  *  NSS_ZAlloc

  *  NSS_ZRealloc

  *  NSS_ZFreeIf

  *

  * The nonpublic methods relating to this type are:

  *

  *  nssArena_Create  -- constructor

  *  nssArena_Destroy

  *  nssArena_Mark

  *  nssArena_Release

  *  nssArena_Unmark

  * 

  *  nss_ZAlloc

  *  nss_ZFreeIf

  *  nss_ZRealloc

  *

  * In debug builds, the following calls are available:

  *

  *  nssArena_verifyPointer

  *  nssArena_registerDestructor

  *  nssArena_deregisterDestructor

  */

 struct NSSArenaStr {

   PLArenaPool pool;

   PRLock *lock;

 #ifdef ARENA_THREADMARK

   PRThread *marking_thread;

   nssArenaMark *first_mark;

   nssArenaMark *last_mark;

 #endif /* ARENA_THREADMARK */

 #ifdef ARENA_DESTRUCTOR_LIST

   struct arena_destructor_node *first_destructor;

   struct arena_destructor_node *last_destructor;

 #endif /* ARENA_DESTRUCTOR_LIST */

 };

 /*

  * nssArenaMark

  *

  * This type is used to mark the current state of an NSSArena.

  */

 struct nssArenaMarkStr {

   PRUint32 magic;

   void *mark;

 #ifdef ARENA_THREADMARK

   nssArenaMark *next;

 #endif /* ARENA_THREADMARK */

 #ifdef ARENA_DESTRUCTOR_LIST

   struct arena_destructor_node *next_destructor;

   struct arena_destructor_node *prev_destructor;

 #endif /* ARENA_DESTRUCTOR_LIST */

 };

 #define MARK_MAGIC 0x4d41524b /* "MARK" how original */

 /*

  * But first, the pointer-tracking code

  */

 #ifdef DEBUG

 extern const NSSError NSS_ERROR_INTERNAL_ERROR;

 static nssPointerTracker arena_pointer_tracker;

 static PRStatus

 arena_add_pointer

 (

   const NSSArena *arena

 )

 {

   PRStatus rv;

   rv = nssPointerTracker_initialize(&arena_pointer_tracker);

   if( PR_SUCCESS != rv ) {

     return rv;

   }

   rv = nssPointerTracker_add(&arena_pointer_tracker, arena);

   if( PR_SUCCESS != rv ) {

     NSSError e = NSS_GetError();

     if( NSS_ERROR_NO_MEMORY != e ) {

       nss_SetError(NSS_ERROR_INTERNAL_ERROR);

     }

     return rv;

   }

   return PR_SUCCESS;

 }

 static PRStatus

 arena_remove_pointer

 (

   const NSSArena *arena

 )

 {

   PRStatus rv;

   rv = nssPointerTracker_remove(&arena_pointer_tracker, arena);

   if( PR_SUCCESS != rv ) {

     nss_SetError(NSS_ERROR_INTERNAL_ERROR);

   }

   return rv;

 }

 /*

  * nssArena_verifyPointer

  *

  * This method is only present in debug builds.

  *

  * If the specified pointer is a valid pointer to an NSSArena object,

  * this routine will return PR_SUCCESS.  Otherwise, it will put an

  * error on the error stack and return PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *

  * Return value:

  *  PR_SUCCESS if the pointer is valid

  *  PR_FAILURE if it isn't

  */

 NSS_IMPLEMENT PRStatus

 nssArena_verifyPointer

 (

   const NSSArena *arena

 )

 {

   PRStatus rv;

   rv = nssPointerTracker_initialize(&arena_pointer_tracker);

   if( PR_SUCCESS != rv ) {

     /*

      * This is a little disingenious.  We have to initialize the

      * tracker, because someone could "legitimately" try to verify

      * an arena pointer before one is ever created.  And this step

      * might fail, due to lack of memory.  But the only way that

      * this step can fail is if it's doing the call_once stuff,

      * (later calls just no-op).  And if it didn't no-op, there

      * aren't any valid arenas.. so the argument certainly isn't one.

      */

     nss_SetError(NSS_ERROR_INVALID_ARENA);

     return PR_FAILURE;

   }

   rv = nssPointerTracker_verify(&arena_pointer_tracker, arena);

   if( PR_SUCCESS != rv ) {

     nss_SetError(NSS_ERROR_INVALID_ARENA);

     return PR_FAILURE;

   }

   return PR_SUCCESS;

 }

 #endif /* DEBUG */

 #ifdef ARENA_DESTRUCTOR_LIST

 struct arena_destructor_node {

   struct arena_destructor_node *next;

   struct arena_destructor_node *prev;

   void (*destructor)(void *argument);

   void *arg;

 };

 /*

  * nssArena_registerDestructor

  *

  * This routine stores a pointer to a callback and an arbitrary

  * pointer-sized argument in the arena, at the current point in

  * the mark stack.  If the arena is destroyed, or an "earlier"

  * mark is released, then this destructor will be called at that

  * time.  Note that the destructor will be called with the arena

  * locked, which means the destructor may free memory in that

  * arena, but it may not allocate or cause to be allocated any

  * memory.  This callback facility was included to support our

  * debug-version pointer-tracker feature; overuse runs counter to

  * the the original intent of arenas.  This routine returns a 

  * PRStatus value; if successful, it will return PR_SUCCESS.  If 

  * unsuccessful, it will set an error on the error stack and 

  * return PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_NO_MEMORY

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 nssArena_registerDestructor

 (

   NSSArena *arena,

   void (*destructor)(void *argument),

   void *arg

 )

 {

   struct arena_destructor_node *it;

 #ifdef NSSDEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return PR_FAILURE;

   }

 #endif /* NSSDEBUG */

   it = nss_ZNEW(arena, struct arena_destructor_node);

   if( (struct arena_destructor_node *)NULL == it ) {

     return PR_FAILURE;

   }

   it->prev = arena->last_destructor;

   arena->last_destructor->next = it;

   arena->last_destructor = it;

   it->destructor = destructor;

   it->arg = arg;

   if( (nssArenaMark *)NULL != arena->last_mark ) {

     arena->last_mark->prev_destructor = it->prev;

     arena->last_mark->next_destructor = it->next;

   }

   return PR_SUCCESS;

 }

 NSS_IMPLEMENT PRStatus

 nssArena_deregisterDestructor

 (

   NSSArena *arena,

   void (*destructor)(void *argument),

   void *arg

 )

 {

   struct arena_destructor_node *it;

 #ifdef NSSDEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return PR_FAILURE;

   }

 #endif /* NSSDEBUG */

   for( it = arena->first_destructor; it; it = it->next ) {

     if( (it->destructor == destructor) && (it->arg == arg) ) {

       break;

     }

   }

   if( (struct arena_destructor_node *)NULL == it ) {

     nss_SetError(NSS_ERROR_NOT_FOUND);

     return PR_FAILURE;

   }

   if( it == arena->first_destructor ) {

     arena->first_destructor = it->next;

   }

   if( it == arena->last_destructor ) {

     arena->last_destructor = it->prev;

   }

   if( (struct arena_destructor_node *)NULL != it->prev ) {

     it->prev->next = it->next;

   }

   if( (struct arena_destructor_node *)NULL != it->next ) {

     it->next->prev = it->prev;

   }

   {

     nssArenaMark *m;

     for( m = arena->first_mark; m; m = m->next ) {

       if( m->next_destructor == it ) {

         m->next_destructor = it->next;

       }

       if( m->prev_destructor == it ) {

         m->prev_destructor = it->prev;

       }

     }

   }

   nss_ZFreeIf(it);

   return PR_SUCCESS;

 }

 static void

 nss_arena_call_destructor_chain

 (

   struct arena_destructor_node *it

 )

 {

   for( ; it ; it = it->next ) {

     (*(it->destructor))(it->arg);

   }

 }

 #endif /* ARENA_DESTRUCTOR_LIST */

 /*

  * NSSArena_Create

  *

  * This routine creates a new memory arena.  This routine may return

  * NULL upon error, in which case it will have created an error stack.

  *

  * The top-level error may be one of the following values:

  *  NSS_ERROR_NO_MEMORY

  *

  * Return value:

  *  NULL upon error

  *  A pointer to an NSSArena upon success

  */

 NSS_IMPLEMENT NSSArena *

 NSSArena_Create

 (

   void

 )

 {

   nss_ClearErrorStack();

   return nssArena_Create();

 }

 /*

  * nssArena_Create

  *

  * This routine creates a new memory arena.  This routine may return

  * NULL upon error, in which case it will have set an error on the 

  * error stack.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_NO_MEMORY

  *

  * Return value:

  *  NULL upon error

  *  A pointer to an NSSArena upon success

  */

 NSS_IMPLEMENT NSSArena *

 nssArena_Create

 (

   void

 )

 {

   NSSArena *rv = (NSSArena *)NULL;

   rv = nss_ZNEW((NSSArena *)NULL, NSSArena);

   if( (NSSArena *)NULL == rv ) {

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (NSSArena *)NULL;

   }

   rv->lock = PR_NewLock();

   if( (PRLock *)NULL == rv->lock ) {

     (void)nss_ZFreeIf(rv);

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (NSSArena *)NULL;

   }

   /*

    * Arena sizes.  The current security code has 229 occurrences of

    * PORT_NewArena.  The default chunksizes specified break down as

    *

    *  Size    Mult.   Specified as

    *   512       1    512

    *  1024       7    1024

    *  2048       5    2048

    *  2048       5    CRMF_DEFAULT_ARENA_SIZE

    *  2048     190    DER_DEFAULT_CHUNKSIZE

    *  2048      20    SEC_ASN1_DEFAULT_ARENA_SIZE

    *  4096       1    4096

    *

    * Obviously this "default chunksize" flexibility isn't very 

    * useful to us, so I'll just pick 2048.

    */

   PL_InitArenaPool(&rv->pool, "NSS", 2048, sizeof(double));

 #ifdef DEBUG

   {

     PRStatus st;

     st = arena_add_pointer(rv);

     if( PR_SUCCESS != st ) {

       PL_FinishArenaPool(&rv->pool);

       PR_DestroyLock(rv->lock);

       (void)nss_ZFreeIf(rv);

       return (NSSArena *)NULL;

     }

   }

 #endif /* DEBUG */

   return rv;

 }

 /*

  * NSSArena_Destroy

  *

  * This routine will destroy the specified arena, freeing all memory

  * allocated from it.  This routine returns a PRStatus value; if 

  * successful, it will return PR_SUCCESS.  If unsuccessful, it will

  * create an error stack and return PR_FAILURE.

  *

  * The top-level error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *

  * Return value:

  *  PR_SUCCESS upon success

  *  PR_FAILURE upon failure

  */

 NSS_IMPLEMENT PRStatus

 NSSArena_Destroy

 (

   NSSArena *arena

 )

 {

   nss_ClearErrorStack();

 #ifdef DEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return PR_FAILURE;

   }

 #endif /* DEBUG */

   return nssArena_Destroy(arena);

 }

 /*

  * nssArena_Destroy

  *

  * This routine will destroy the specified arena, freeing all memory

  * allocated from it.  This routine returns a PRStatus value; if 

  * successful, it will return PR_SUCCESS.  If unsuccessful, it will

  * set an error on the error stack and return PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 nssArena_Destroy

 (

   NSSArena *arena

 )

 {

   PRLock *lock;

 #ifdef NSSDEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return PR_FAILURE;

   }

 #endif /* NSSDEBUG */

   if( (PRLock *)NULL == arena->lock ) {

     /* Just got destroyed */

     nss_SetError(NSS_ERROR_INVALID_ARENA);

     return PR_FAILURE;

   }

   PR_Lock(arena->lock);

 #ifdef DEBUG

   if( PR_SUCCESS != arena_remove_pointer(arena) ) {

     PR_Unlock(arena->lock);

     return PR_FAILURE;

   }

 #endif /* DEBUG */

 #ifdef ARENA_DESTRUCTOR_LIST

   /* Note that the arena is locked at this time */

   nss_arena_call_destructor_chain(arena->first_destructor);

 #endif /* ARENA_DESTRUCTOR_LIST */

   PL_FinishArenaPool(&arena->pool);

   lock = arena->lock;

   arena->lock = (PRLock *)NULL;

   PR_Unlock(lock);

   PR_DestroyLock(lock);

   (void)nss_ZFreeIf(arena);

   return PR_SUCCESS;

 }

 static void *nss_zalloc_arena_locked(NSSArena *arena, PRUint32 size);

 /*

  * nssArena_Mark

  *

  * This routine "marks" the current state of an arena.  Space

  * allocated after the arena has been marked can be freed by

  * releasing the arena back to the mark with nssArena_Release,

  * or committed by calling nssArena_Unmark.  When successful, 

  * this routine returns a valid nssArenaMark pointer.  This 

  * routine may return NULL upon error, in which case it will 

  * have set an error on the error stack.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  NULL upon failure

  *  An nssArenaMark pointer upon success

  */

 NSS_IMPLEMENT nssArenaMark *

 nssArena_Mark

 (

   NSSArena *arena

 )

 {

   nssArenaMark *rv;

   void *p;

 #ifdef NSSDEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return (nssArenaMark *)NULL;

   }

 #endif /* NSSDEBUG */

   if( (PRLock *)NULL == arena->lock ) {

     /* Just got destroyed */

     nss_SetError(NSS_ERROR_INVALID_ARENA);

     return (nssArenaMark *)NULL;

   }

   PR_Lock(arena->lock);

 #ifdef ARENA_THREADMARK

   if( (PRThread *)NULL == arena->marking_thread ) {

     /* Unmarked.  Store our thread ID */

     arena->marking_thread = PR_GetCurrentThread();

     /* This call never fails. */

   } else {

     /* Marked.  Verify it's the current thread */

     if( PR_GetCurrentThread() != arena->marking_thread ) {

       PR_Unlock(arena->lock);

       nss_SetError(NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD);

       return (nssArenaMark *)NULL;

     }

   }

 #endif /* ARENA_THREADMARK */

   p = PL_ARENA_MARK(&arena->pool);

   /* No error possible */

   /* Do this after the mark */

   rv = (nssArenaMark *)nss_zalloc_arena_locked(arena, sizeof(nssArenaMark));

   if( (nssArenaMark *)NULL == rv ) {

     PR_Unlock(arena->lock);

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (nssArenaMark *)NULL;

   }

 #ifdef ARENA_THREADMARK

   if ( (nssArenaMark *)NULL == arena->first_mark) {

     arena->first_mark = rv;

     arena->last_mark = rv;

   } else {

     arena->last_mark->next = rv;

     arena->last_mark = rv;

   }

 #endif /* ARENA_THREADMARK */

   rv->mark = p;

   rv->magic = MARK_MAGIC;

 #ifdef ARENA_DESTRUCTOR_LIST

   rv->prev_destructor = arena->last_destructor;

 #endif /* ARENA_DESTRUCTOR_LIST */

   PR_Unlock(arena->lock);

   return rv;

 }

 /*

  * nss_arena_unmark_release

  *

  * This static routine implements the routines nssArena_Release

  * ans nssArena_Unmark, which are almost identical.

  */

 static PRStatus

 nss_arena_unmark_release

 (

   NSSArena *arena,

   nssArenaMark *arenaMark,

   PRBool release

 )

 {

   void *inner_mark;

 #ifdef NSSDEBUG

   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {

     return PR_FAILURE;

   }

 #endif /* NSSDEBUG */

   if( MARK_MAGIC != arenaMark->magic ) {

     nss_SetError(NSS_ERROR_INVALID_ARENA_MARK);

     return PR_FAILURE;

   }

   if( (PRLock *)NULL == arena->lock ) {

     /* Just got destroyed */

     nss_SetError(NSS_ERROR_INVALID_ARENA);

     return PR_FAILURE;

   }

   PR_Lock(arena->lock);

 #ifdef ARENA_THREADMARK

   if( (PRThread *)NULL != arena->marking_thread ) {

     if( PR_GetCurrentThread() != arena->marking_thread ) {

       PR_Unlock(arena->lock);

       nss_SetError(NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD);

       return PR_FAILURE;

     }

   }

 #endif /* ARENA_THREADMARK */

   if( MARK_MAGIC != arenaMark->magic ) {

     /* Just got released */

     PR_Unlock(arena->lock);

     nss_SetError(NSS_ERROR_INVALID_ARENA_MARK);

     return PR_FAILURE;

   }

   arenaMark->magic = 0;

   inner_mark = arenaMark->mark;

 #ifdef ARENA_THREADMARK

   {

     nssArenaMark **pMark = &arena->first_mark;

     nssArenaMark *rest;

     nssArenaMark *last = (nssArenaMark *)NULL;

     /* Find this mark */

     while( *pMark != arenaMark ) {

       last = *pMark;

       pMark = &(*pMark)->next;

     }

     /* Remember the pointer, then zero it */

     rest = (*pMark)->next;

     *pMark = (nssArenaMark *)NULL;

     arena->last_mark = last;

     /* Invalidate any later marks being implicitly released */

     for( ; (nssArenaMark *)NULL != rest; rest = rest->next ) {

       rest->magic = 0;

     }

     /* If we just got rid of the first mark, clear the thread ID */

     if( (nssArenaMark *)NULL == arena->first_mark ) {

       arena->marking_thread = (PRThread *)NULL;

     }

   }

 #endif /* ARENA_THREADMARK */

   if( release ) {

 #ifdef ARENA_DESTRUCTOR_LIST

     if( (struct arena_destructor_node *)NULL != arenaMark->prev_destructor ) {

       arenaMark->prev_destructor->next = (struct arena_destructor_node *)NULL;

     }

     arena->last_destructor = arenaMark->prev_destructor;

     /* Note that the arena is locked at this time */

     nss_arena_call_destructor_chain(arenaMark->next_destructor);

 #endif /* ARENA_DESTRUCTOR_LIST */

     PL_ARENA_RELEASE(&arena->pool, inner_mark);

     /* No error return */

   }

   PR_Unlock(arena->lock);

   return PR_SUCCESS;

 }

 /*

  * nssArena_Release

  *

  * This routine invalidates and releases all memory allocated from

  * the specified arena after the point at which the specified mark

  * was obtained.  This routine returns a PRStatus value; if successful,

  * it will return PR_SUCCESS.  If unsuccessful, it will set an error

  * on the error stack and return PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_INVALID_ARENA_MARK

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 nssArena_Release

 (

   NSSArena *arena,

   nssArenaMark *arenaMark

 )

 {

   return nss_arena_unmark_release(arena, arenaMark, PR_TRUE);

 }

 /*

  * nssArena_Unmark

  *

  * This routine "commits" the indicated mark and any marks after

  * it, making them unreleasable.  Note that any earlier marks can

  * still be released, and such a release will invalidate these

  * later unmarked regions.  If an arena is to be safely shared by

  * more than one thread, all marks must be either released or

  * unmarked.  This routine returns a PRStatus value; if successful,

  * it will return PR_SUCCESS.  If unsuccessful, it will set an error

  * on the error stack and return PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_INVALID_ARENA_MARK

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 nssArena_Unmark

 (

   NSSArena *arena,

   nssArenaMark *arenaMark

 )

 {

   return nss_arena_unmark_release(arena, arenaMark, PR_FALSE);

 }

 /*

  * We prefix this header to all allocated blocks.  It is a multiple

  * of the alignment size.  Note that this usage of a header may make

  * purify spew bogus warnings about "potentially leaked blocks" of

  * memory; if that gets too annoying we can add in a pointer to the

  * header in the header itself.  There's not a lot of safety here;

  * maybe we should add a magic value?

  */

 struct pointer_header {

   NSSArena *arena;

   PRUint32 size;

 };

 static void *

 nss_zalloc_arena_locked

 (

   NSSArena *arena,

   PRUint32 size

 )

 {

   void *p;

   void *rv;

   struct pointer_header *h;

   PRUint32 my_size = size + sizeof(struct pointer_header);

   PL_ARENA_ALLOCATE(p, &arena->pool, my_size);

   if( (void *)NULL == p ) {

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (void *)NULL;

   }

   /* 

    * Do this before we unlock.  This way if the user is using

    * an arena in one thread while destroying it in another, he'll

    * fault/FMR in his code, not ours.

    */

   h = (struct pointer_header *)p;

   h->arena = arena;

   h->size = size;

   rv = (void *)((char *)h + sizeof(struct pointer_header));

   (void)nsslibc_memset(rv, 0, size);

   return rv;

 }

 /*

  * NSS_ZAlloc

  *

  * This routine allocates and zeroes a section of memory of the 

  * size, and returns to the caller a pointer to that memory.  If

  * the optional arena argument is non-null, the memory will be

  * obtained from that arena; otherwise, the memory will be obtained

  * from the heap.  This routine may return NULL upon error, in

  * which case it will have set an error upon the error stack.  The

  * value specified for size may be zero; in which case a valid 

  * zero-length block of memory will be allocated.  This block may

  * be expanded by calling NSS_ZRealloc.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  NULL upon error

  *  A pointer to the new segment of zeroed memory

  */

 NSS_IMPLEMENT void *

 NSS_ZAlloc

 (

   NSSArena *arenaOpt,

   PRUint32 size

 )

 {

   return nss_ZAlloc(arenaOpt, size);

 }

 /*

  * nss_ZAlloc

  *

  * This routine allocates and zeroes a section of memory of the 

  * size, and returns to the caller a pointer to that memory.  If

  * the optional arena argument is non-null, the memory will be

  * obtained from that arena; otherwise, the memory will be obtained

  * from the heap.  This routine may return NULL upon error, in

  * which case it will have set an error upon the error stack.  The

  * value specified for size may be zero; in which case a valid 

  * zero-length block of memory will be allocated.  This block may

  * be expanded by calling nss_ZRealloc.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_ARENA

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  NULL upon error

  *  A pointer to the new segment of zeroed memory

  */

 NSS_IMPLEMENT void *

 nss_ZAlloc

 (

   NSSArena *arenaOpt,

   PRUint32 size

 )

 {

   struct pointer_header *h;

   PRUint32 my_size = size + sizeof(struct pointer_header);

   if( my_size < sizeof(struct pointer_header) ) {

     /* Wrapped */

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (void *)NULL;

   }

   if( (NSSArena *)NULL == arenaOpt ) {

     /* Heap allocation, no locking required. */

     h = (struct pointer_header *)PR_Calloc(1, my_size);

     if( (struct pointer_header *)NULL == h ) {

       nss_SetError(NSS_ERROR_NO_MEMORY);

       return (void *)NULL;

     }

     h->arena = (NSSArena *)NULL;

     h->size = size;

     /* We used calloc: it's already zeroed */

     return (void *)((char *)h + sizeof(struct pointer_header));

   } else {

     void *rv;

     /* Arena allocation */

 #ifdef NSSDEBUG

     if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) {

       return (void *)NULL;

     }

 #endif /* NSSDEBUG */

     if( (PRLock *)NULL == arenaOpt->lock ) {

       /* Just got destroyed */

       nss_SetError(NSS_ERROR_INVALID_ARENA);

       return (void *)NULL;

     }

     PR_Lock(arenaOpt->lock);

 #ifdef ARENA_THREADMARK

     if( (PRThread *)NULL != arenaOpt->marking_thread ) {

       if( PR_GetCurrentThread() != arenaOpt->marking_thread ) {

         nss_SetError(NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD);

         PR_Unlock(arenaOpt->lock);

         return (void *)NULL;

       }

     }

 #endif /* ARENA_THREADMARK */

     rv = nss_zalloc_arena_locked(arenaOpt, size);

     PR_Unlock(arenaOpt->lock);

     return rv;

   }

   /*NOTREACHED*/

 }

 /*

  * NSS_ZFreeIf

  *

  * If the specified pointer is non-null, then the region of memory 

  * to which it points -- which must have been allocated with 

  * NSS_ZAlloc -- will be zeroed and released.  This routine 

  * returns a PRStatus value; if successful, it will return PR_SUCCESS.

  * If unsuccessful, it will set an error on the error stack and return 

  * PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 NSS_ZFreeIf

 (

   void *pointer

 )

 {

    return nss_ZFreeIf(pointer);

 }

 /*

  * nss_ZFreeIf

  *

  * If the specified pointer is non-null, then the region of memory 

  * to which it points -- which must have been allocated with 

  * nss_ZAlloc -- will be zeroed and released.  This routine 

  * returns a PRStatus value; if successful, it will return PR_SUCCESS.

  * If unsuccessful, it will set an error on the error stack and return 

  * PR_FAILURE.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *

  * Return value:

  *  PR_SUCCESS

  *  PR_FAILURE

  */

 NSS_IMPLEMENT PRStatus

 nss_ZFreeIf

 (

   void *pointer

 )

 {

   struct pointer_header *h;

   if( (void *)NULL == pointer ) {

     return PR_SUCCESS;

   }

   h = (struct pointer_header *)((char *)pointer

     - sizeof(struct pointer_header));

   /* Check any magic here */

   if( (NSSArena *)NULL == h->arena ) {

     /* Heap */

     (void)nsslibc_memset(pointer, 0, h->size);

     PR_Free(h);

     return PR_SUCCESS;

   } else {

     /* Arena */

 #ifdef NSSDEBUG

     if( PR_SUCCESS != nssArena_verifyPointer(h->arena) ) {

       return PR_FAILURE;

     }

 #endif /* NSSDEBUG */

     if( (PRLock *)NULL == h->arena->lock ) {

       /* Just got destroyed.. so this pointer is invalid */

       nss_SetError(NSS_ERROR_INVALID_POINTER);

       return PR_FAILURE;

     }

     PR_Lock(h->arena->lock);

     (void)nsslibc_memset(pointer, 0, h->size);

     /* No way to "free" it within an NSPR arena. */

     PR_Unlock(h->arena->lock);

     return PR_SUCCESS;

   }

   /*NOTREACHED*/

 }

 /*

  * NSS_ZRealloc

  *

  * This routine reallocates a block of memory obtained by calling

  * nss_ZAlloc or nss_ZRealloc.  The portion of memory 

  * between the new and old sizes -- which is either being newly

  * obtained or released -- is in either case zeroed.  This routine 

  * may return NULL upon failure, in which case it will have placed 

  * an error on the error stack.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  NULL upon error

  *  A pointer to the replacement segment of memory

  */

 NSS_EXTERN void *

 NSS_ZRealloc

 (

   void *pointer,

   PRUint32 newSize

 )

 {

     return nss_ZRealloc(pointer, newSize);

 }

 /*

  * nss_ZRealloc

  *

  * This routine reallocates a block of memory obtained by calling

  * nss_ZAlloc or nss_ZRealloc.  The portion of memory 

  * between the new and old sizes -- which is either being newly

  * obtained or released -- is in either case zeroed.  This routine 

  * may return NULL upon failure, in which case it will have placed 

  * an error on the error stack.

  *

  * The error may be one of the following values:

  *  NSS_ERROR_INVALID_POINTER

  *  NSS_ERROR_NO_MEMORY

  *  NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD

  *

  * Return value:

  *  NULL upon error

  *  A pointer to the replacement segment of memory

  */

 NSS_EXTERN void *

 nss_ZRealloc

 (

   void *pointer,

   PRUint32 newSize

 )

 {

   NSSArena *arena;

   struct pointer_header *h, *new_h;

   PRUint32 my_newSize = newSize + sizeof(struct pointer_header);

   void *rv;

   if( my_newSize < sizeof(struct pointer_header) ) {

     /* Wrapped */

     nss_SetError(NSS_ERROR_NO_MEMORY);

     return (void *)NULL;

   }

   if( (void *)NULL == pointer ) {

     nss_SetError(NSS_ERROR_INVALID_POINTER);

     return (void *)NULL;

   }

   h = (struct pointer_header *)((char *)pointer

     - sizeof(struct pointer_header));

   /* Check any magic here */

   if( newSize == h->size ) {

     /* saves thrashing */

     return pointer;

   }

   arena = h->arena;

   if (!arena) {

     /* Heap */

     new_h = (struct pointer_header *)PR_Calloc(1, my_newSize);

     if( (struct pointer_header *)NULL == new_h ) {

       nss_SetError(NSS_ERROR_NO_MEMORY);

       return (void *)NULL;

     }

     new_h->arena = (NSSArena *)NULL;

     new_h->size = newSize;

     rv = (void *)((char *)new_h + sizeof(struct pointer_header));

     if( newSize > h->size ) {

       (void)nsslibc_memcpy(rv, pointer, h->size);

       (void)nsslibc_memset(&((char *)rv)[ h->size ], 

                            0, (newSize - h->size));

     } else {

       (void)nsslibc_memcpy(rv, pointer, newSize);

     }

     (void)nsslibc_memset(pointer, 0, h->size);

     h->size = 0;

     PR_Free(h);

     return rv;

   } else {

     void *p;

     /* Arena */

 #ifdef NSSDEBUG

     if (PR_SUCCESS != nssArena_verifyPointer(arena)) {

       return (void *)NULL;

     }

 #endif /* NSSDEBUG */

     if (!arena->lock) {

       /* Just got destroyed.. so this pointer is invalid */

       nss_SetError(NSS_ERROR_INVALID_POINTER);

       return (void *)NULL;

     }

     PR_Lock(arena->lock);

 #ifdef ARENA_THREADMARK

     if (arena->marking_thread) {

       if (PR_GetCurrentThread() != arena->marking_thread) {

         PR_Unlock(arena->lock);

         nss_SetError(NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD);

         return (void *)NULL;

       }

     }

 #endif /* ARENA_THREADMARK */

     if( newSize < h->size ) {

       /*

        * We have no general way of returning memory to the arena

        * (mark/release doesn't work because things may have been

        * allocated after this object), so the memory is gone

        * anyway.  We might as well just return the same pointer to

        * the user, saying "yeah, uh-hunh, you can only use less of

        * it now."  We'll zero the leftover part, of course.  And

        * in fact we might as well *not* adjust h->size-- this way,

        * if the user reallocs back up to something not greater than

        * the original size, then voila, there's the memory!  This

        * way a thrash big/small/big/small doesn't burn up the arena.

        */

       char *extra = &((char *)pointer)[ newSize ];

       (void)nsslibc_memset(extra, 0, (h->size - newSize));

       PR_Unlock(arena->lock);

       return pointer;

     }

     PL_ARENA_ALLOCATE(p, &arena->pool, my_newSize);

     if( (void *)NULL == p ) {

       PR_Unlock(arena->lock);

       nss_SetError(NSS_ERROR_NO_MEMORY);

       return (void *)NULL;

     }

     new_h = (struct pointer_header *)p;

     new_h->arena = arena;

     new_h->size = newSize;

     rv = (void *)((char *)new_h + sizeof(struct pointer_header));

     if (rv != pointer) {

 	(void)nsslibc_memcpy(rv, pointer, h->size);

 	(void)nsslibc_memset(pointer, 0, h->size);

     }

     (void)nsslibc_memset(&((char *)rv)[ h->size ], 0, (newSize - h->size));

     h->arena = (NSSArena *)NULL;

     h->size = 0;

     PR_Unlock(arena->lock);

     return rv;

   }

   /*NOTREACHED*/

 }

 PRStatus 

 nssArena_Shutdown(void)

 {

   PRStatus rv = PR_SUCCESS;

 #ifdef DEBUG

   rv = nssPointerTracker_finalize(&arena_pointer_tracker);

 #endif

   return rv;

 }