apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject cvs commit: apr-site/docs/coverage apr_atomic.c.gcov apr_pools.c.gcov global_mutex.c.gcov index.html open.c.gcov proc.c.gcov proc_mutex.c.gcov signals.c.gcov start.c.gcov thread_mutex.c.gcov time.c.gcov
Date Mon, 15 Mar 2004 18:43:29 GMT
rbb         2004/03/15 10:43:29

  Modified:    docs/coverage apr_atomic.c.gcov apr_pools.c.gcov
                        global_mutex.c.gcov index.html open.c.gcov
                        proc.c.gcov proc_mutex.c.gcov signals.c.gcov
                        start.c.gcov thread_mutex.c.gcov time.c.gcov
  Log:
  Update coverage data with newest unified test suite.
  
  Revision  Changes    Path
  1.6       +8 -8      apr-site/docs/coverage/apr_atomic.c.gcov
  
  Index: apr_atomic.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/apr_atomic.c.gcov,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- apr_atomic.c.gcov	15 Mar 2004 03:38:39 -0000	1.5
  +++ apr_atomic.c.gcov	15 Mar 2004 18:43:28 -0000	1.6
  @@ -165,21 +165,21 @@
   		#endif /* APR_HAS_THREADS */
   		
   		apr_status_t apr_atomic_init(apr_pool_t *p)
  -          10    {
  +          14    {
   		#if APR_HAS_THREADS
  -          10        int i;
  -          10        apr_status_t rv;
  -          10        hash_mutex = apr_palloc(p, sizeof(apr_thread_mutex_t*) * NUM_ATOMIC_HASH);
  +          14        int i;
  +          14        apr_status_t rv;
  +          14        hash_mutex = apr_palloc(p, sizeof(apr_thread_mutex_t*) * NUM_ATOMIC_HASH);
   		
  -          80        for (i = 0; i < NUM_ATOMIC_HASH; i++) {
  -          70            rv = apr_thread_mutex_create(&(hash_mutex[i]),
  +         112        for (i = 0; i < NUM_ATOMIC_HASH; i++) {
  +          98            rv = apr_thread_mutex_create(&(hash_mutex[i]),
   		                                     APR_THREAD_MUTEX_DEFAULT, p);
  -          70            if (rv != APR_SUCCESS) {
  +          98            if (rv != APR_SUCCESS) {
         ######               return rv;
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
  -          10        return APR_SUCCESS;
  +          14        return APR_SUCCESS;
   		}
   		#endif /* !defined(APR_OVERRIDE_ATOMIC_INIT) */
   		
  
  
  
  1.6       +224 -224  apr-site/docs/coverage/apr_pools.c.gcov
  
  Index: apr_pools.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/apr_pools.c.gcov,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- apr_pools.c.gcov	15 Mar 2004 03:38:39 -0000	1.5
  +++ apr_pools.c.gcov	15 Mar 2004 18:43:28 -0000	1.6
  @@ -81,61 +81,61 @@
   		 */
   		
   		APR_DECLARE(apr_status_t) apr_allocator_create(apr_allocator_t **allocator)
  -           9    {
  -           9        apr_allocator_t *new_allocator;
  +          13    {
  +          13        apr_allocator_t *new_allocator;
   		
  -           9        *allocator = NULL;
  +          13        *allocator = NULL;
   		
  -           9        if ((new_allocator = malloc(SIZEOF_ALLOCATOR_T)) == NULL)
  +          13        if ((new_allocator = malloc(SIZEOF_ALLOCATOR_T)) == NULL)
         ######            return APR_ENOMEM;
   		
  -           9        memset(new_allocator, 0, SIZEOF_ALLOCATOR_T);
  -           9        new_allocator->max_free_index = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
  +          13        memset(new_allocator, 0, SIZEOF_ALLOCATOR_T);
  +          13        new_allocator->max_free_index = APR_ALLOCATOR_MAX_FREE_UNLIMITED;
   		
  -           9        *allocator = new_allocator;
  +          13        *allocator = new_allocator;
   		
  -           9        return APR_SUCCESS;
  +          13        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(void) apr_allocator_destroy(apr_allocator_t *allocator)
  -           7    {
  -           7        apr_uint32_t index;
  -           7        apr_memnode_t *node, **ref;
  +          11    {
  +          11        apr_uint32_t index;
  +          11        apr_memnode_t *node, **ref;
   		
  -         147        for (index = 0; index < MAX_INDEX; index++) {
  -         140            ref = &allocator->free[index];
  -         300            while ((node = *ref) != NULL) {
  -         160                *ref = node->next;
  -         160                free(node);
  +         231        for (index = 0; index < MAX_INDEX; index++) {
  +         220            ref = &allocator->free[index];
  +         392            while ((node = *ref) != NULL) {
  +         172                *ref = node->next;
  +         172                free(node);
   		        }
   		    }
   		
  -           7        free(allocator);
  +          11        free(allocator);
   		}
   		
   		#if APR_HAS_THREADS
   		APR_DECLARE(void) apr_allocator_mutex_set(apr_allocator_t *allocator,
   		                                          apr_thread_mutex_t *mutex)
  -          16    {
  -          16        allocator->mutex = mutex;
  +          24    {
  +          24        allocator->mutex = mutex;
   		}
   		
   		APR_DECLARE(apr_thread_mutex_t *) apr_allocator_mutex_get(
   		                                      apr_allocator_t *allocator)
  -         344    {
  -         344        return allocator->mutex;
  +         360    {
  +         360        return allocator->mutex;
   		}
   		#endif /* APR_HAS_THREADS */
   		
   		APR_DECLARE(void) apr_allocator_owner_set(apr_allocator_t *allocator,
   		                                          apr_pool_t *pool)
  -           9    {
  -           9        allocator->owner = pool;
  +          13    {
  +          13        allocator->owner = pool;
   		}
   		
   		APR_DECLARE(apr_pool_t *) apr_allocator_owner_get(apr_allocator_t *allocator)
  -         386    {
  -         386        return allocator->owner;
  +         410    {
  +         410        return allocator->owner;
   		}
   		
   		APR_DECLARE(void) apr_allocator_max_free_set(apr_allocator_t *allocator,
  @@ -166,26 +166,26 @@
   		
   		static APR_INLINE
   		apr_memnode_t *allocator_alloc(apr_allocator_t *allocator, apr_size_t size)
  -         202    {
  -         202        apr_memnode_t *node, **ref;
  -         202        apr_uint32_t i, index, max_index;
  +         214    {
  +         214        apr_memnode_t *node, **ref;
  +         214        apr_uint32_t i, index, max_index;
   		
   		    /* Round up the block size to the next boundary, but always
   		     * allocate at least a certain size (MIN_ALLOC).
   		     */
  -         202        size = APR_ALIGN(size + APR_MEMNODE_T_SIZE, BOUNDARY_SIZE);
  -         202        if (size < MIN_ALLOC)
  +         214        size = APR_ALIGN(size + APR_MEMNODE_T_SIZE, BOUNDARY_SIZE);
  +         214        if (size < MIN_ALLOC)
             28            size = MIN_ALLOC;
   		
   		    /* Find the index for this node size by
   		     * dividing its size by the boundary size
   		     */
  -         202        index = (size >> BOUNDARY_INDEX) - 1;
  +         214        index = (size >> BOUNDARY_INDEX) - 1;
   		
   		    /* First see if there are any nodes in the area we know
   		     * our node will fit into.
   		     */
  -         202        if (index <= allocator->max_index) {
  +         214        if (index <= allocator->max_index) {
   		#if APR_HAS_THREADS
            124            if (allocator->mutex)
            124                apr_thread_mutex_lock(allocator->mutex);
  @@ -204,9 +204,9 @@
            124            max_index = allocator->max_index;
            124            ref = &allocator->free[index];
            124            i = index;
  -         132            while (*ref == NULL && i < max_index) {
  -           8               ref++;
  -           8               i++;
  +         128            while (*ref == NULL && i < max_index) {
  +           4               ref++;
  +           4               i++;
   		        }
   		
            124            if ((node = *ref) != NULL) {
  @@ -216,18 +216,18 @@
   		             * available index
   		             */
            124                if ((*ref = node->next) == NULL && i >= max_index) {
  -          54                    do {
  -          54                        ref--;
  -          54                        max_index--;
  -          54                    }
  +          53                    do {
  +          53                        ref--;
  +          53                        max_index--;
  +          53                    }
   		                while (*ref == NULL && max_index > 0);
   		
  -          54                    allocator->max_index = max_index;
  +          53                    allocator->max_index = max_index;
   		            }
   		
            124                allocator->current_free_index += node->index;
            124                if (allocator->current_free_index > allocator->max_free_index)
  -          79                    allocator->current_free_index = allocator->max_free_index;
  +          85                    allocator->current_free_index = allocator->max_free_index;
   		
   		#if APR_HAS_THREADS
            124                if (allocator->mutex)
  @@ -249,7 +249,7 @@
   		    /* If we found nothing, seek the sink (at index 0), if
   		     * it is not empty.
   		     */
  -          78        else if (allocator->free[0]) {
  +          90        else if (allocator->free[0]) {
   		#if APR_HAS_THREADS
         ######            if (allocator->mutex)
         ######                apr_thread_mutex_lock(allocator->mutex);
  @@ -289,55 +289,55 @@
   		    /* If we haven't got a suitable node, malloc a new one
   		     * and initialize it.
   		     */
  -          78        if ((node = malloc(size)) == NULL)
  +          90        if ((node = malloc(size)) == NULL)
         ######            return NULL;
   		
  -          78        node->next = NULL;
  -          78        node->index = index;
  -          78        node->first_avail = (char *)node + APR_MEMNODE_T_SIZE;
  -          78        node->endp = (char *)node + size;
  +          90        node->next = NULL;
  +          90        node->index = index;
  +          90        node->first_avail = (char *)node + APR_MEMNODE_T_SIZE;
  +          90        node->endp = (char *)node + size;
   		
  -          78        return node;
  +          90        return node;
   		}
   		
   		static APR_INLINE
   		void allocator_free(apr_allocator_t *allocator, apr_memnode_t *node)
  -         194    {
  -         194        apr_memnode_t *next, *freelist = NULL;
  -         194        apr_uint32_t index, max_index;
  -         194        apr_uint32_t max_free_index, current_free_index;
  +         206    {
  +         206        apr_memnode_t *next, *freelist = NULL;
  +         206        apr_uint32_t index, max_index;
  +         206        apr_uint32_t max_free_index, current_free_index;
   		
   		#if APR_HAS_THREADS
  -         194        if (allocator->mutex)
  -         187            apr_thread_mutex_lock(allocator->mutex);
  +         206        if (allocator->mutex)
  +         195            apr_thread_mutex_lock(allocator->mutex);
   		#endif /* APR_HAS_THREADS */
   		
  -         194        max_index = allocator->max_index;
  -         194        max_free_index = allocator->max_free_index;
  -         194        current_free_index = allocator->current_free_index;
  +         206        max_index = allocator->max_index;
  +         206        max_free_index = allocator->max_free_index;
  +         206        current_free_index = allocator->current_free_index;
   		
   		    /* Walk the list of submitted nodes and free them one by one,
   		     * shoving them in the right 'size' buckets as we go.
   		     */
  -         284        do {
  -         284            next = node->next;
  -         284            index = node->index;
  +         296        do {
  +         296            next = node->next;
  +         296            index = node->index;
   		
  -         284            if (max_free_index != APR_ALLOCATOR_MAX_FREE_UNLIMITED
  +         296            if (max_free_index != APR_ALLOCATOR_MAX_FREE_UNLIMITED
   		            && index > current_free_index) {
         ######                node->next = freelist;
         ######                freelist = node;
   		        }
  -         284            else if (index < MAX_INDEX) {
  +         296            else if (index < MAX_INDEX) {
   		            /* Add the node to the appropiate 'size' bucket.  Adjust
   		             * the max_index when appropiate.
   		             */
  -         282                if ((node->next = allocator->free[index]) == NULL
  +         294                if ((node->next = allocator->free[index]) == NULL
   		                && index > max_index) {
  -          61                    max_index = index;
  +          64                    max_index = index;
   		            }
  -         282                allocator->free[index] = node;
  -         282                current_free_index -= index;
  +         294                allocator->free[index] = node;
  +         294                current_free_index -= index;
   		        }
   		        else {
   		            /* This node is too large to keep in a specific size bucket,
  @@ -347,17 +347,17 @@
              2                allocator->free[0] = node;
              2                current_free_index -= index;
   		        }
  -         284        } while ((node = next) != NULL);
  +         296        } while ((node = next) != NULL);
   		
  -         194        allocator->max_index = max_index;
  -         194        allocator->current_free_index = current_free_index;
  +         206        allocator->max_index = max_index;
  +         206        allocator->current_free_index = current_free_index;
   		
   		#if APR_HAS_THREADS
  -         194        if (allocator->mutex)
  -         187            apr_thread_mutex_unlock(allocator->mutex);
  +         206        if (allocator->mutex)
  +         195            apr_thread_mutex_unlock(allocator->mutex);
   		#endif /* APR_HAS_THREADS */
   		
  -         194        while (freelist != NULL) {
  +         206        while (freelist != NULL) {
         ######            node = freelist;
         ######            freelist = node->next;
         ######            free(node);
  @@ -496,18 +496,18 @@
   		 */
   		
   		APR_DECLARE(apr_status_t) apr_pool_initialize(void)
  -           9    {
  -           9        apr_status_t rv;
  +          13    {
  +          13        apr_status_t rv;
   		
  -           9        if (apr_pools_initialized++)
  +          13        if (apr_pools_initialized++)
         ######            return APR_SUCCESS;
   		
  -           9        if ((rv = apr_allocator_create(&global_allocator)) != APR_SUCCESS) {
  +          13        if ((rv = apr_allocator_create(&global_allocator)) != APR_SUCCESS) {
         ######            apr_pools_initialized = 0;
         ######            return rv;
   		    }
   		
  -           9        if ((rv = apr_pool_create_ex(&global_pool, NULL, NULL,
  +          13        if ((rv = apr_pool_create_ex(&global_pool, NULL, NULL,
   		                                 global_allocator)) != APR_SUCCESS) {
         ######            apr_allocator_destroy(global_allocator);
         ######            global_allocator = NULL;
  @@ -515,46 +515,46 @@
         ######            return rv;
   		    }
   		
  -           9        apr_pool_tag(global_pool, "apr_global_pool");
  +          13        apr_pool_tag(global_pool, "apr_global_pool");
   		
   		    /* This has to happen here because mutexes might be backed by
   		     * atomics.  It used to be snug and safe in apr_initialize().
   		     */
  -           9        if ((rv = apr_atomic_init(global_pool)) != APR_SUCCESS) {
  +          13        if ((rv = apr_atomic_init(global_pool)) != APR_SUCCESS) {
         ######            return rv;
   		    }
   		
   		#if APR_HAS_THREADS
   		    {
  -           9            apr_thread_mutex_t *mutex;
  +          13            apr_thread_mutex_t *mutex;
   		
  -           9            if ((rv = apr_thread_mutex_create(&mutex,
  +          13            if ((rv = apr_thread_mutex_create(&mutex,
   		                                          APR_THREAD_MUTEX_DEFAULT,
   		                                          global_pool)) != APR_SUCCESS) {
         ######                return rv;
   		        }
   		
  -           9            apr_allocator_mutex_set(global_allocator, mutex);
  +          13            apr_allocator_mutex_set(global_allocator, mutex);
   		    }
   		#endif /* APR_HAS_THREADS */
   		
  -           9        apr_allocator_owner_set(global_allocator, global_pool);
  +          13        apr_allocator_owner_set(global_allocator, global_pool);
   		
  -           9        return APR_SUCCESS;
  +          13        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(void) apr_pool_terminate(void)
  -           7    {
  -           7        if (!apr_pools_initialized)
  +          11    {
  +          11        if (!apr_pools_initialized)
         ######            return;
   		
  -           7        if (--apr_pools_initialized)
  +          11        if (--apr_pools_initialized)
         ######            return;
   		
  -           7        apr_pool_destroy(global_pool); /* This will also destroy the mutex */
  -           7        global_pool = NULL;
  +          11        apr_pool_destroy(global_pool); /* This will also destroy the mutex */
  +          11        global_pool = NULL;
   		
  -           7        global_allocator = NULL;
  +          11        global_allocator = NULL;
   		}
   		
   		
  @@ -578,25 +578,25 @@
   		 */
   		
   		APR_DECLARE(void *) apr_palloc(apr_pool_t *pool, apr_size_t size)
  -        2312    {
  -        2312        apr_memnode_t *active, *node;
  -        2312        void *mem;
  -        2312        apr_uint32_t free_index;
  +        2419    {
  +        2419        apr_memnode_t *active, *node;
  +        2419        void *mem;
  +        2419        apr_uint32_t free_index;
   		
  -        2312        size = APR_ALIGN_DEFAULT(size);
  -        2312        active = pool->active;
  +        2419        size = APR_ALIGN_DEFAULT(size);
  +        2419        active = pool->active;
   		
   		    /* If the active node has enough bytes left, use it. */
  -        2312        if (size < (apr_size_t)(active->endp - active->first_avail)) {
  -        2280            mem = active->first_avail;
  -        2280            active->first_avail += size;
  +        2419        if (size < (apr_size_t)(active->endp - active->first_avail)) {
  +        2385            mem = active->first_avail;
  +        2385            active->first_avail += size;
   		
  -        2280            return mem;
  +        2385            return mem;
   		    }
   		
  -          32        node = active->next;
  -          32        if (size < (apr_size_t)(node->endp - node->first_avail)) {
  -           3            list_remove(node);
  +          34        node = active->next;
  +          34        if (size < (apr_size_t)(node->endp - node->first_avail)) {
  +           5            list_remove(node);
   		    }
   		    else {
             29            if ((node = allocator_alloc(pool->allocator, size)) == NULL) {
  @@ -607,22 +607,22 @@
   		        }
   		    }
   		
  -          32        node->free_index = 0;
  +          34        node->free_index = 0;
   		
  -          32        mem = node->first_avail;
  -          32        node->first_avail += size;
  +          34        mem = node->first_avail;
  +          34        node->first_avail += size;
   		
  -          32        list_insert(node, active);
  +          34        list_insert(node, active);
   		
  -          32        pool->active = node;
  +          34        pool->active = node;
   		
  -          32        free_index = (APR_ALIGN(active->endp - active->first_avail + 1,
  +          34        free_index = (APR_ALIGN(active->endp - active->first_avail + 1,
   		                            BOUNDARY_SIZE) - BOUNDARY_SIZE) >> BOUNDARY_INDEX;
   		
  -          32        active->free_index = free_index;
  -          32        node = active->next;
  -          32        if (free_index >= node->free_index)
  -          32            return mem;
  +          34        active->free_index = free_index;
  +          34        node = active->next;
  +          34        if (free_index >= node->free_index)
  +          34            return mem;
   		
         ######        do {
         ######            node = node->next;
  @@ -698,68 +698,68 @@
   		}
   		
   		APR_DECLARE(void) apr_pool_destroy(apr_pool_t *pool)
  -         193    {
  -         193        apr_memnode_t *active;
  -         193        apr_allocator_t *allocator;
  +         205    {
  +         205        apr_memnode_t *active;
  +         205        apr_allocator_t *allocator;
   		
   		    /* Destroy the subpools.  The subpools will detach themselve from
   		     * this pool thus this loop is safe and easy.
   		     */
  -         255        while (pool->child)
  -          62            apr_pool_destroy(pool->child);
  +         275        while (pool->child)
  +          70            apr_pool_destroy(pool->child);
   		
   		    /* Run cleanups */
  -         193        run_cleanups(&pool->cleanups);
  +         205        run_cleanups(&pool->cleanups);
   		
   		    /* Free subprocesses */
  -         193        free_proc_chain(pool->subprocesses);
  +         205        free_proc_chain(pool->subprocesses);
   		
   		    /* Remove the pool from the parents child list */
  -         193        if (pool->parent) {
  +         205        if (pool->parent) {
   		#if APR_HAS_THREADS
  -         186            apr_thread_mutex_t *mutex;
  +         194            apr_thread_mutex_t *mutex;
   		
  -         186            if ((mutex = apr_allocator_mutex_get(pool->parent->allocator)) != NULL)
  -         186                apr_thread_mutex_lock(mutex);
  +         194            if ((mutex = apr_allocator_mutex_get(pool->parent->allocator)) != NULL)
  +         194                apr_thread_mutex_lock(mutex);
   		#endif /* APR_HAS_THREADS */
   		
  -         186            if ((*pool->ref = pool->sibling) != NULL)
  -         173                pool->sibling->ref = pool->ref;
  +         194            if ((*pool->ref = pool->sibling) != NULL)
  +         177                pool->sibling->ref = pool->ref;
   		
   		#if APR_HAS_THREADS
  -         186            if (mutex)
  -         186                apr_thread_mutex_unlock(mutex);
  +         194            if (mutex)
  +         194                apr_thread_mutex_unlock(mutex);
   		#endif /* APR_HAS_THREADS */
   		    }
   		
   		    /* Find the block attached to the pool structure.  Save a copy of the
   		     * allocator pointer, because the pool struct soon will be no more.
   		     */
  -         193        allocator = pool->allocator;
  -         193        active = pool->self;
  -         193        *active->ref = NULL;
  +         205        allocator = pool->allocator;
  +         205        active = pool->self;
  +         205        *active->ref = NULL;
   		
   		#if APR_HAS_THREADS
  -         193        if (apr_allocator_owner_get(allocator) == pool) {
  +         205        if (apr_allocator_owner_get(allocator) == pool) {
   		        /* Make sure to remove the lock, since it is highly likely to
   		         * be invalid now.
   		         */
  -           7            apr_allocator_mutex_set(allocator, NULL);
  +          11            apr_allocator_mutex_set(allocator, NULL);
   		    }
   		#endif /* APR_HAS_THREADS */
   		
   		    /* Free all the nodes in the pool (including the node holding the
   		     * pool struct), by giving them back to the allocator.
   		     */
  -         193        allocator_free(allocator, active);
  +         205        allocator_free(allocator, active);
   		
   		    /* If this pool happens to be the owner of the allocator, free
   		     * everything in the allocator (that includes the pool struct
   		     * and the allocator).  Don't worry about destroying the optional mutex
   		     * in the allocator, it will have been destroyed by the cleanup function.
   		     */
  -         193        if (apr_allocator_owner_get(allocator) == pool) {
  -           7            apr_allocator_destroy(allocator);
  +         205        if (apr_allocator_owner_get(allocator) == pool) {
  +          11            apr_allocator_destroy(allocator);
   		    }
   		}
   		
  @@ -767,22 +767,22 @@
   		                                             apr_pool_t *parent,
   		                                             apr_abortfunc_t abort_fn,
   		                                             apr_allocator_t *allocator)
  -         167    {
  -         167        apr_pool_t *pool;
  -         167        apr_memnode_t *node;
  +         179    {
  +         179        apr_pool_t *pool;
  +         179        apr_memnode_t *node;
   		
  -         167        *newpool = NULL;
  +         179        *newpool = NULL;
   		
  -         167        if (!parent)
  -          28            parent = global_pool;
  +         179        if (!parent)
  +          40            parent = global_pool;
   		
  -         167        if (!abort_fn && parent)
  -         158            abort_fn = parent->abort_fn;
  +         179        if (!abort_fn && parent)
  +         166            abort_fn = parent->abort_fn;
   		
  -         167        if (allocator == NULL)
  -         158            allocator = parent->allocator;
  +         179        if (allocator == NULL)
  +         166            allocator = parent->allocator;
   		
  -         167        if ((node = allocator_alloc(allocator,
  +         179        if ((node = allocator_alloc(allocator,
   		                                MIN_ALLOC - APR_MEMNODE_T_SIZE)) == NULL) {
         ######            if (abort_fn)
         ######                abort_fn(APR_ENOMEM);
  @@ -790,52 +790,52 @@
         ######            return APR_ENOMEM;
   		    }
   		
  -         167        node->next = node;
  -         167        node->ref = &node->next;
  +         179        node->next = node;
  +         179        node->ref = &node->next;
   		
  -         167        pool = (apr_pool_t *)node->first_avail;
  -         167        node->first_avail = pool->self_first_avail = (char *)pool + SIZEOF_POOL_T;
  +         179        pool = (apr_pool_t *)node->first_avail;
  +         179        node->first_avail = pool->self_first_avail = (char *)pool + SIZEOF_POOL_T;
   		
  -         167        pool->allocator = allocator;
  -         167        pool->active = pool->self = node;
  -         167        pool->abort_fn = abort_fn;
  -         167        pool->child = NULL;
  -         167        pool->cleanups = NULL;
  -         167        pool->subprocesses = NULL;
  -         167        pool->user_data = NULL;
  -         167        pool->tag = NULL;
  +         179        pool->allocator = allocator;
  +         179        pool->active = pool->self = node;
  +         179        pool->abort_fn = abort_fn;
  +         179        pool->child = NULL;
  +         179        pool->cleanups = NULL;
  +         179        pool->subprocesses = NULL;
  +         179        pool->user_data = NULL;
  +         179        pool->tag = NULL;
   		
   		#ifdef NETWARE
   		    pool->owner_proc = (apr_os_proc_t)getnlmhandle();
   		#endif /* defined(NETWARE) */
   		
  -         167        if ((pool->parent = parent) != NULL) {
  +         179        if ((pool->parent = parent) != NULL) {
   		#if APR_HAS_THREADS
  -         158            apr_thread_mutex_t *mutex;
  +         166            apr_thread_mutex_t *mutex;
   		
  -         158            if ((mutex = apr_allocator_mutex_get(parent->allocator)) != NULL)
  -         158                apr_thread_mutex_lock(mutex);
  +         166            if ((mutex = apr_allocator_mutex_get(parent->allocator)) != NULL)
  +         166                apr_thread_mutex_lock(mutex);
   		#endif /* APR_HAS_THREADS */
   		
  -         158            if ((pool->sibling = parent->child) != NULL)
  -         147                pool->sibling->ref = &pool->sibling;
  +         166            if ((pool->sibling = parent->child) != NULL)
  +         151                pool->sibling->ref = &pool->sibling;
   		
  -         158            parent->child = pool;
  -         158            pool->ref = &parent->child;
  +         166            parent->child = pool;
  +         166            pool->ref = &parent->child;
   		
   		#if APR_HAS_THREADS
  -         158            if (mutex)
  -         158                apr_thread_mutex_unlock(mutex);
  +         166            if (mutex)
  +         166                apr_thread_mutex_unlock(mutex);
   		#endif /* APR_HAS_THREADS */
   		    }
   		    else {
  -           9            pool->sibling = NULL;
  -           9            pool->ref = NULL;
  +          13            pool->sibling = NULL;
  +          13            pool->ref = NULL;
   		    }
   		
  -         167        *newpool = pool;
  +         179        *newpool = pool;
   		
  -         167        return APR_SUCCESS;
  +         179        return APR_SUCCESS;
   		}
   		
   		
  @@ -1792,8 +1792,8 @@
   		}
   		
   		APR_DECLARE(void) apr_pool_tag(apr_pool_t *pool, const char *tag)
  -          18    {
  -          18        pool->tag = tag;
  +          26    {
  +          26        pool->tag = tag;
   		}
   		
   		
  @@ -1878,45 +1878,45 @@
   		APR_DECLARE(void) apr_pool_cleanup_register(apr_pool_t *p, const void *data,
   		                      apr_status_t (*plain_cleanup_fn)(void *data),
   		                      apr_status_t (*child_cleanup_fn)(void *data))
  -         250    {
  -         250        cleanup_t *c;
  +         297    {
  +         297        cleanup_t *c;
   		
   		#if APR_POOL_DEBUG
   		    apr_pool_check_integrity(p);
   		#endif /* APR_POOL_DEBUG */
   		
  -         250        if (p != NULL) {
  -         250            c = (cleanup_t *)apr_palloc(p, sizeof(cleanup_t));
  -         250            c->data = data;
  -         250            c->plain_cleanup_fn = plain_cleanup_fn;
  -         250            c->child_cleanup_fn = child_cleanup_fn;
  -         250            c->next = p->cleanups;
  -         250            p->cleanups = c;
  +         297        if (p != NULL) {
  +         297            c = (cleanup_t *)apr_palloc(p, sizeof(cleanup_t));
  +         297            c->data = data;
  +         297            c->plain_cleanup_fn = plain_cleanup_fn;
  +         297            c->child_cleanup_fn = child_cleanup_fn;
  +         297            c->next = p->cleanups;
  +         297            p->cleanups = c;
   		    }
   		}
   		
   		APR_DECLARE(void) apr_pool_cleanup_kill(apr_pool_t *p, const void *data,
   		                      apr_status_t (*cleanup_fn)(void *))
  -         164    {
  -         164        cleanup_t *c, **lastp;
  +         178    {
  +         178        cleanup_t *c, **lastp;
   		
   		#if APR_POOL_DEBUG
   		    apr_pool_check_integrity(p);
   		#endif /* APR_POOL_DEBUG */
   		
  -         164        if (p == NULL)
  +         178        if (p == NULL)
         ######            return;
   		
  -         164        c = p->cleanups;
  -         164        lastp = &p->cleanups;
  -        1450        while (c) {
  -        1432            if (c->data == data && c->plain_cleanup_fn == cleanup_fn) {
  -         146                *lastp = c->next;
  -         146                break;
  +         178        c = p->cleanups;
  +         178        lastp = &p->cleanups;
  +        1471        while (c) {
  +        1453            if (c->data == data && c->plain_cleanup_fn == cleanup_fn) {
  +         160                *lastp = c->next;
  +         160                break;
   		        }
   		
  -        1286            lastp = &c->next;
  -        1286            c = c->next;
  +        1293            lastp = &c->next;
  +        1293            c = c->next;
   		    }
   		}
   		
  @@ -1946,43 +1946,43 @@
   		
   		APR_DECLARE(apr_status_t) apr_pool_cleanup_run(apr_pool_t *p, void *data,
   		                              apr_status_t (*cleanup_fn)(void *))
  -         153    {
  -         153        apr_pool_cleanup_kill(p, data, cleanup_fn);
  -         153        return (*cleanup_fn)(data);
  +         167    {
  +         167        apr_pool_cleanup_kill(p, data, cleanup_fn);
  +         167        return (*cleanup_fn)(data);
   		}
   		
   		static void run_cleanups(cleanup_t **cref)
  -         194    {
  -         194        cleanup_t *c = *cref;
  +         206    {
  +         206        cleanup_t *c = *cref;
   		
  -         360        while (c) {
  -         166            *cref = c->next;
  -         166            (*c->plain_cleanup_fn)((void *)c->data);
  -         166            c = *cref;
  +         411        while (c) {
  +         205            *cref = c->next;
  +         205            (*c->plain_cleanup_fn)((void *)c->data);
  +         205            c = *cref;
   		    }
   		}
   		
   		static void run_child_cleanups(cleanup_t **cref)
  -         175    {
  -         175        cleanup_t *c = *cref;
  +         191    {
  +         191        cleanup_t *c = *cref;
   		
  -         582        while (c) {
  -         407            *cref = c->next;
  -         407            (*c->child_cleanup_fn)((void *)c->data);
  -         407            c = *cref;
  +         717        while (c) {
  +         526            *cref = c->next;
  +         526            (*c->child_cleanup_fn)((void *)c->data);
  +         526            c = *cref;
   		    }
   		}
   		
   		static void cleanup_pool_for_exec(apr_pool_t *p)
  -         175    {
  -         175        run_child_cleanups(&p->cleanups);
  +         191    {
  +         191        run_child_cleanups(&p->cleanups);
   		
  -         339        for (p = p->child; p; p = p->sibling)
  -         164            cleanup_pool_for_exec(p);
  +         367        for (p = p->child; p; p = p->sibling)
  +         176            cleanup_pool_for_exec(p);
   		}
   		
   		APR_DECLARE(void) apr_pool_cleanup_for_exec(void)
  -          11    {
  +          15    {
   		#if !defined(WIN32) && !defined(OS2)
   		    /*
   		     * Don't need to do anything on NT or OS/2, because I
  @@ -1993,14 +1993,14 @@
   		     * I can do about that (except if the child decides
   		     * to go out and close them
   		     */
  -          11        cleanup_pool_for_exec(global_pool);
  +          15        cleanup_pool_for_exec(global_pool);
   		#endif /* !defined(WIN32) && !defined(OS2) */
   		}
   		
   		APR_DECLARE_NONSTD(apr_status_t) apr_pool_cleanup_null(void *data)
  -         384    {
  +         495    {
   		    /* do nothing cleanup routine */
  -         384        return APR_SUCCESS;
  +         495        return APR_SUCCESS;
   		}
   		
   		/* Subprocesses don't use the generic cleanup interface because
  @@ -2022,17 +2022,17 @@
   		}
   		
   		static void free_proc_chain(struct process_chain *procs)
  -         194    {
  +         206    {
   		    /* Dispose of the subprocesses we've spawned off in the course of
   		     * whatever it was we're cleaning up now.  This may involve killing
   		     * some of them off...
   		     */
  -         194        struct process_chain *pc;
  -         194        int need_timeout = 0;
  -         194        apr_time_t timeout_interval;
  +         206        struct process_chain *pc;
  +         206        int need_timeout = 0;
  +         206        apr_time_t timeout_interval;
   		
  -         194        if (!procs)
  -         194            return; /* No work.  Whew! */
  +         206        if (!procs)
  +         206            return; /* No work.  Whew! */
   		
   		    /* First, check to see if we need to do the SIGTERM, sleep, SIGKILL
   		     * dance with any of the processes we're cleaning up.  If we've got
  
  
  
  1.2       +40 -40    apr-site/docs/coverage/global_mutex.c.gcov
  
  Index: global_mutex.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/global_mutex.c.gcov,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- global_mutex.c.gcov	9 Mar 2004 19:07:38 -0000	1.1
  +++ global_mutex.c.gcov	15 Mar 2004 18:43:28 -0000	1.2
  @@ -21,97 +21,97 @@
   		#include "apr_portable.h"
   		
   		static apr_status_t global_mutex_cleanup(void *data)
  -      ######    {
  -      ######        apr_global_mutex_t *m = (apr_global_mutex_t *)data;
  -      ######        apr_status_t rv;
  +           7    {
  +           7        apr_global_mutex_t *m = (apr_global_mutex_t *)data;
  +           7        apr_status_t rv;
   		
  -      ######        rv = apr_proc_mutex_destroy(m->proc_mutex);
  +           7        rv = apr_proc_mutex_destroy(m->proc_mutex);
   		
   		#if APR_HAS_THREADS
  -      ######        if (m->thread_mutex) {
  -      ######            if (rv != APR_SUCCESS) {
  +           7        if (m->thread_mutex) {
  +           7            if (rv != APR_SUCCESS) {
         ######                (void)apr_thread_mutex_destroy(m->thread_mutex);
   		        }
   		        else {
  -      ######                rv = apr_thread_mutex_destroy(m->thread_mutex);
  +           7                rv = apr_thread_mutex_destroy(m->thread_mutex);
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
   		
  -      ######        return rv;
  +           7        return rv;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_global_mutex_create(apr_global_mutex_t **mutex,
   		                                                  const char *fname,
   		                                                  apr_lockmech_e mech,
   		                                                  apr_pool_t *pool)
  -      ######    {
  -      ######        apr_status_t rv;
  -      ######        apr_global_mutex_t *m;
  +           5    {
  +           5        apr_status_t rv;
  +           5        apr_global_mutex_t *m;
   		
  -      ######        m = (apr_global_mutex_t *)apr_palloc(pool, sizeof(*m));
  -      ######        m->pool = pool;
  +           5        m = (apr_global_mutex_t *)apr_palloc(pool, sizeof(*m));
  +           5        m->pool = pool;
   		
  -      ######        rv = apr_proc_mutex_create(&m->proc_mutex, fname, mech, m->pool);
  -      ######        if (rv != APR_SUCCESS) {
  +           5        rv = apr_proc_mutex_create(&m->proc_mutex, fname, mech, m->pool);
  +           5        if (rv != APR_SUCCESS) {
         ######            return rv;
   		    }
   		
   		#if APR_HAS_THREADS
  -      ######        if (m->proc_mutex->inter_meth->flags & APR_PROCESS_LOCK_MECH_IS_GLOBAL) {
  +           5        if (m->proc_mutex->inter_meth->flags & APR_PROCESS_LOCK_MECH_IS_GLOBAL) {
         ######            m->thread_mutex = NULL; /* We don't need a thread lock. */
   		    }
   		    else {
  -      ######            rv = apr_thread_mutex_create(&m->thread_mutex,
  +           5            rv = apr_thread_mutex_create(&m->thread_mutex,
   		                                     APR_THREAD_MUTEX_DEFAULT, m->pool);
  -      ######            if (rv != APR_SUCCESS) {
  +           5            if (rv != APR_SUCCESS) {
         ######                rv = apr_proc_mutex_destroy(m->proc_mutex);
         ######                return rv;
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
   		
  -      ######        apr_pool_cleanup_register(m->pool, (void *)m,
  +           5        apr_pool_cleanup_register(m->pool, (void *)m,
   		                              global_mutex_cleanup, apr_pool_cleanup_null);
  -      ######        *mutex = m;
  -      ######        return APR_SUCCESS;
  +           5        *mutex = m;
  +           5        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_global_mutex_child_init(
   		                              apr_global_mutex_t **mutex,
   		                              const char *fname,
   		                              apr_pool_t *pool)
  -      ######    {
  -      ######        apr_status_t rv;
  +           4    {
  +           4        apr_status_t rv;
   		
  -      ######        rv = apr_proc_mutex_child_init(&((*mutex)->proc_mutex), fname, pool);
  -      ######        return rv;
  +           4        rv = apr_proc_mutex_child_init(&((*mutex)->proc_mutex), fname, pool);
  +           4        return rv;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_global_mutex_lock(apr_global_mutex_t *mutex)
  -      ######    {
  -      ######        apr_status_t rv;
  +        1024    {
  +        1024        apr_status_t rv;
   		
   		#if APR_HAS_THREADS
  -      ######        if (mutex->thread_mutex) {
  -      ######            rv = apr_thread_mutex_lock(mutex->thread_mutex);
  -      ######            if (rv != APR_SUCCESS) {
  +        1024        if (mutex->thread_mutex) {
  +        1024            rv = apr_thread_mutex_lock(mutex->thread_mutex);
  +        1024            if (rv != APR_SUCCESS) {
         ######                return rv;
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
   		
  -      ######        rv = apr_proc_mutex_lock(mutex->proc_mutex);
  +        1024        rv = apr_proc_mutex_lock(mutex->proc_mutex);
   		
   		#if APR_HAS_THREADS
  -      ######        if (rv != APR_SUCCESS) {
  +        1024        if (rv != APR_SUCCESS) {
         ######            if (mutex->thread_mutex) {
         ######                (void)apr_thread_mutex_unlock(mutex->thread_mutex);
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
   		
  -      ######        return rv;
  +        1024        return rv;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_global_mutex_trylock(apr_global_mutex_t *mutex)
  @@ -141,21 +141,21 @@
   		}
   		
   		APR_DECLARE(apr_status_t) apr_global_mutex_unlock(apr_global_mutex_t *mutex)
  -      ######    {
  -      ######        apr_status_t rv;
  +        1024    {
  +        1024        apr_status_t rv;
   		
  -      ######        rv = apr_proc_mutex_unlock(mutex->proc_mutex);
  +        1024        rv = apr_proc_mutex_unlock(mutex->proc_mutex);
   		#if APR_HAS_THREADS
  -      ######        if (mutex->thread_mutex) {
  -      ######            if (rv != APR_SUCCESS) {
  +        1024        if (mutex->thread_mutex) {
  +        1024            if (rv != APR_SUCCESS) {
         ######                (void)apr_thread_mutex_unlock(mutex->thread_mutex);
   		        }
   		        else {
  -      ######                rv = apr_thread_mutex_unlock(mutex->thread_mutex);
  +        1024                rv = apr_thread_mutex_unlock(mutex->thread_mutex);
   		        }
   		    }
   		#endif /* APR_HAS_THREADS */
  -      ######        return rv;
  +        1024        return rv;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_os_global_mutex_get(apr_os_global_mutex_t *ospmutex,
  
  
  
  1.11      +5 -5      apr-site/docs/coverage/index.html
  
  Index: index.html
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/index.html,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- index.html	15 Mar 2004 03:38:39 -0000	1.10
  +++ index.html	15 Mar 2004 18:43:28 -0000	1.11
  @@ -154,8 +154,8 @@
   <td bgcolor=#ffff77><a href="getopt.c.gcov">getopt</a><br>
   <td bgcolor=#ffff77> 35.62% tested
   <tr>
  -<td bgcolor=#ffaaaa><a href="global_mutex.c.gcov">global_mutex</a><br>
  -<td bgcolor=#ffaaaa>  0.00% tested
  +<td bgcolor=#ffff77><a href="global_mutex.c.gcov">global_mutex</a><br>
  +<td bgcolor=#ffff77> 58.82% tested
   <tr>
   <td bgcolor=#aaffaa><a href="groupinfo.c.gcov">groupinfo</a><br>
   <td bgcolor=#aaffaa> 87.50% tested
  @@ -188,7 +188,7 @@
   <td bgcolor=#ffff77> 55.47% tested
   <tr>
   <td bgcolor=#ffff77><a href="proc_mutex.c.gcov">proc_mutex</a><br>
  -<td bgcolor=#ffff77> 36.67% tested
  +<td bgcolor=#ffff77> 37.50% tested
   <tr>
   <td bgcolor=#ffaaaa><a href="procsup.c.gcov">procsup</a><br>
   <td bgcolor=#ffaaaa>  0.00% tested
  @@ -239,7 +239,7 @@
   <td bgcolor=#aaffaa> 73.17% tested
   <tr>
   <td bgcolor=#ffff77><a href="thread_mutex.c.gcov">thread_mutex</a><br>
  -<td bgcolor=#ffff77> 40.32% tested
  +<td bgcolor=#ffff77> 43.55% tested
   <tr>
   <td bgcolor=#ffff77><a href="thread_rwlock.c.gcov">thread_rwlock</a><br>
   <td bgcolor=#ffff77> 61.90% tested
  @@ -261,7 +261,7 @@
   <tr>
   <td bgcolor=#aaffaa><a href="waitio.c.gcov">waitio</a><br>
   <td bgcolor=#aaffaa> 92.86% tested
  -</table><p>Last generated Sun Mar 14 22:21:45 EST 2004</p>
  +</table><p>Last generated Mon Mar 15 13:26:07 EST 2004</p>
   </td></tr>
   </table>
      <!-- FOOTER -->
  
  
  
  1.5       +9 -9      apr-site/docs/coverage/open.c.gcov
  
  Index: open.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/open.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- open.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ open.c.gcov	15 Mar 2004 18:43:28 -0000	1.5
  @@ -26,20 +26,20 @@
   		#endif
   		
   		apr_status_t apr_unix_file_cleanup(void *thefile)
  -         143    {
  -         143        apr_file_t *file = thefile;
  -         143        apr_status_t flush_rv = APR_SUCCESS, rv = APR_SUCCESS;
  +         151    {
  +         151        apr_file_t *file = thefile;
  +         151        apr_status_t flush_rv = APR_SUCCESS, rv = APR_SUCCESS;
   		
  -         143        if (file->buffered) {
  +         151        if (file->buffered) {
              2            flush_rv = apr_file_flush(file);
   		    }
  -         143        if (close(file->filedes) == 0) {
  -         143            file->filedes = -1;
  -         143            if (file->flags & APR_DELONCLOSE) {
  +         151        if (close(file->filedes) == 0) {
  +         151            file->filedes = -1;
  +         151            if (file->flags & APR_DELONCLOSE) {
              8                unlink(file->fname);
   		        }
   		#if APR_HAS_THREADS
  -         143            if (file->thlock) {
  +         151            if (file->thlock) {
         ######                rv = apr_thread_mutex_destroy(file->thlock);
   		        }
   		#endif
  @@ -48,7 +48,7 @@
   		        /* Are there any error conditions other than EINTR or EBADF? */
         ######            rv = errno;
   		    }
  -         143        return rv != APR_SUCCESS ? rv : flush_rv;
  +         151        return rv != APR_SUCCESS ? rv : flush_rv;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new, 
  
  
  
  1.5       +71 -71    apr-site/docs/coverage/proc.c.gcov
  
  Index: proc.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/proc.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- proc.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ proc.c.gcov	15 Mar 2004 18:43:29 -0000	1.5
  @@ -21,24 +21,24 @@
   		
   		APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new,
   		                                              apr_pool_t *pool)
  -          11    {
  -          11        (*new) = (apr_procattr_t *)apr_pcalloc(pool, sizeof(apr_procattr_t));
  +          15    {
  +          15        (*new) = (apr_procattr_t *)apr_pcalloc(pool, sizeof(apr_procattr_t));
   		
  -          11        if ((*new) == NULL) {
  +          15        if ((*new) == NULL) {
         ######            return APR_ENOMEM;
   		    }
  -          11        (*new)->pool = pool;
  -          11        (*new)->cmdtype = APR_PROGRAM;
  -          11        return APR_SUCCESS;
  +          15        (*new)->pool = pool;
  +          15        (*new)->cmdtype = APR_PROGRAM;
  +          15        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr,
   		                                              apr_int32_t in,
   		                                              apr_int32_t out,
   		                                              apr_int32_t err)
  -           8    {
  -           8        apr_status_t status;
  -           8        if (in != 0) {
  +          12    {
  +          12        apr_status_t status;
  +          12        if (in != 0) {
              3            if ((status = apr_file_pipe_create(&attr->child_in, &attr->parent_in,
   		                                           attr->pool)) != APR_SUCCESS) {
         ######                return status;
  @@ -59,7 +59,7 @@
   		        }
   		    }
   		
  -           8        if (out) {
  +          12        if (out) {
              2            if ((status = apr_file_pipe_create(&attr->parent_out, &attr->child_out,
   		                                           attr->pool)) != APR_SUCCESS) {
         ######                return status;
  @@ -80,7 +80,7 @@
   		        }
   		    }
   		
  -           8        if (err) {
  +          12        if (err) {
              1            if ((status = apr_file_pipe_create(&attr->parent_err, &attr->child_err,
   		                                           attr->pool)) != APR_SUCCESS) {
         ######                return status;
  @@ -101,7 +101,7 @@
   		        }
   		    }
   		
  -           8        return APR_SUCCESS;
  +          12        return APR_SUCCESS;
   		}
   		
   		
  @@ -208,31 +208,31 @@
   		}
   		
   		static apr_status_t limit_proc(apr_procattr_t *attr)
  -          11    {
  +          15    {
   		#if APR_HAVE_STRUCT_RLIMIT && APR_HAVE_SETRLIMIT
   		#ifdef RLIMIT_CPU
  -          11        if (attr->limit_cpu != NULL) {
  +          15        if (attr->limit_cpu != NULL) {
         ######            if ((setrlimit(RLIMIT_CPU, attr->limit_cpu)) != 0) {
         ######                return errno;
   		        }
   		    }
   		#endif
   		#ifdef RLIMIT_NPROC
  -          11        if (attr->limit_nproc != NULL) {
  +          15        if (attr->limit_nproc != NULL) {
         ######            if ((setrlimit(RLIMIT_NPROC, attr->limit_nproc)) != 0) {
         ######                return errno;
   		        }
   		    }
   		#endif
   		#ifdef RLIMIT_NOFILE
  -          11        if (attr->limit_nofile != NULL) {
  +          15        if (attr->limit_nofile != NULL) {
         ######            if ((setrlimit(RLIMIT_NOFILE, attr->limit_nofile)) != 0) {
         ######                return errno;
   		        }
   		    }
   		#endif
   		#if defined(RLIMIT_AS)
  -          11        if (attr->limit_mem != NULL) {
  +          15        if (attr->limit_mem != NULL) {
         ######            if ((setrlimit(RLIMIT_AS, attr->limit_mem)) != 0) {
         ######                return errno;
   		        }
  @@ -256,7 +256,7 @@
   		     */
   		
   		#endif
  -          11        return APR_SUCCESS;
  +          15        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_procattr_child_errfn_set(apr_procattr_t *attr,
  @@ -268,9 +268,9 @@
   		
   		APR_DECLARE(apr_status_t) apr_procattr_error_check_set(apr_procattr_t *attr,
   		                                                       apr_int32_t chk)
  -           6    {
  -           6        attr->errchk = chk;
  -           6        return APR_SUCCESS;
  +          10    {
  +          10        attr->errchk = chk;
  +          10        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new,
  @@ -279,22 +279,22 @@
   		                                          const char * const *env,
   		                                          apr_procattr_t *attr,
   		                                          apr_pool_t *pool)
  -          11    {
  -          11        int i;
  +          15    {
  +          15        int i;
   		
  -          11        new->in = attr->parent_in;
  -          11        new->err = attr->parent_err;
  -          11        new->out = attr->parent_out;
  +          15        new->in = attr->parent_in;
  +          15        new->err = attr->parent_err;
  +          15        new->out = attr->parent_out;
   		
  -          11        if (attr->errchk) {
  -           6            if (attr->currdir) {
  +          15        if (attr->errchk) {
  +          10            if (attr->currdir) {
         ######                if (access(attr->currdir, R_OK|X_OK) == -1) {
   		                /* chdir() in child wouldn't have worked */
         ######                    return errno;
   		            }
   		        }
   		
  -           6            if (attr->cmdtype == APR_PROGRAM ||
  +          10            if (attr->cmdtype == APR_PROGRAM ||
   		            attr->cmdtype == APR_PROGRAM_ENV ||
   		            *progname == '/') {
   		            /* for both of these values of cmdtype, caller must pass
  @@ -302,7 +302,7 @@
   		             * caller can choose to pass full path for other
   		             * values of cmdtype
   		             */
  -           6                if (access(progname, R_OK|X_OK) == -1) {
  +          10                if (access(progname, R_OK|X_OK) == -1) {
   		                /* exec*() in child wouldn't have worked */
         ######                    return errno;
   		            }
  @@ -312,11 +312,11 @@
   		        }
   		    }
   		
  -          11        if ((new->pid = fork()) < 0) {
  +          15        if ((new->pid = fork()) < 0) {
         ######            return errno;
   		    }
  -          22        else if (new->pid == 0) {
  -          11            int status;
  +          30        else if (new->pid == 0) {
  +          15            int status;
   		        /* child process */
   		
   		        /*
  @@ -332,44 +332,44 @@
   		         * exec cleanup, then do the dup2() calls.
   		         */
   		
  -          11            if (attr->child_in) {
  +          15            if (attr->child_in) {
              4                apr_pool_cleanup_kill(apr_file_pool_get(attr->child_in),
   		                                  attr->child_in, apr_unix_file_cleanup);
   		        }
   		
  -          11            if (attr->child_out) {
  +          15            if (attr->child_out) {
              3                apr_pool_cleanup_kill(apr_file_pool_get(attr->child_out),
   		                                  attr->child_out, apr_unix_file_cleanup);
   		        }
   		
  -          11            if (attr->child_err) {
  +          15            if (attr->child_err) {
              2                apr_pool_cleanup_kill(apr_file_pool_get(attr->child_err),
   		                                  attr->child_err, apr_unix_file_cleanup);
   		        }
   		
  -          11            apr_pool_cleanup_for_exec();
  +          15            apr_pool_cleanup_for_exec();
   		
  -          11            if (attr->child_in) {
  +          15            if (attr->child_in) {
              4                apr_file_close(attr->parent_in);
              4                dup2(attr->child_in->filedes, STDIN_FILENO);
              4                apr_file_close(attr->child_in);
   		        }
   		
  -          11            if (attr->child_out) {
  +          15            if (attr->child_out) {
              3                apr_file_close(attr->parent_out);
              3                dup2(attr->child_out->filedes, STDOUT_FILENO);
              3                apr_file_close(attr->child_out);
   		        }
   		
  -          11            if (attr->child_err) {
  +          15            if (attr->child_err) {
              2                apr_file_close(attr->parent_err);
              2                dup2(attr->child_err->filedes, STDERR_FILENO);
              2                apr_file_close(attr->child_err);
   		        }
   		
  -          11            apr_signal(SIGCHLD, SIG_DFL); /* not sure if this is needed or not */
  +          15            apr_signal(SIGCHLD, SIG_DFL); /* not sure if this is needed or not */
   		
  -          11            if (attr->currdir != NULL) {
  +          15            if (attr->currdir != NULL) {
              2                if (chdir(attr->currdir) == -1) {
         ######                    if (attr->errfn) {
         ######                        attr->errfn(pool, errno, "change of working directory failed");
  @@ -378,14 +378,14 @@
   		            }
   		        }
   		
  -          11            if ((status = limit_proc(attr)) != APR_SUCCESS) {
  +          15            if ((status = limit_proc(attr)) != APR_SUCCESS) {
         ######                if (attr->errfn) {
         ######                    attr->errfn(pool, errno, "setting of resource limits failed");
   		            }
         ######                exit(-1);   /* We have big problems, the child should exit. */
   		        }
   		
  -          11            if (attr->cmdtype == APR_SHELLCMD) {
  +          15            if (attr->cmdtype == APR_SHELLCMD) {
         ######                int onearg_len = 0;
         ######                const char *newargs[4];
   		
  @@ -438,12 +438,12 @@
   		
         ######                execve(SHELL_PATH, (char * const *) newargs, (char * const *)env);
   		        }
  -          11            else if (attr->cmdtype == APR_PROGRAM) {
  -          11                if (attr->detached) {
  +          15            else if (attr->cmdtype == APR_PROGRAM) {
  +          15                if (attr->detached) {
         ######                    apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
   		            }
   		
  -          11                execve(progname, (char * const *)args, (char * const *)env);
  +          15                execve(progname, (char * const *)args, (char * const *)env);
   		        }
         ######            else if (attr->cmdtype == APR_PROGRAM_ENV) {
         ######                if (attr->detached) {
  @@ -473,19 +473,19 @@
   		    }
   		
   		    /* Parent process */
  -          11        if (attr->child_in) {
  +          15        if (attr->child_in) {
              4            apr_file_close(attr->child_in);
   		    }
   		
  -          11        if (attr->child_out) {
  +          15        if (attr->child_out) {
              3            apr_file_close(attr->child_out);
   		    }
   		
  -          11        if (attr->child_err) {
  +          15        if (attr->child_err) {
              2            apr_file_close(attr->child_err);
   		    }
   		
  -          11        return APR_SUCCESS;
  +          15        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc,
  @@ -501,35 +501,35 @@
   		APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc,
   		                                        int *exitcode, apr_exit_why_e *exitwhy,
   		                                        apr_wait_how_e waithow)
  -          18    {
  -          18        pid_t pstatus;
  -          18        int waitpid_options = WUNTRACED;
  -          18        int exit_int;
  -          18        int ignore;
  -          18        apr_exit_why_e ignorewhy;
  +          22    {
  +          22        pid_t pstatus;
  +          22        int waitpid_options = WUNTRACED;
  +          22        int exit_int;
  +          22        int ignore;
  +          22        apr_exit_why_e ignorewhy;
   		
  -          18        if (exitcode == NULL) {
  +          22        if (exitcode == NULL) {
              3            exitcode = &ignore;
   		    }
   		
  -          18        if (exitwhy == NULL) {
  +          22        if (exitwhy == NULL) {
              3            exitwhy = &ignorewhy;
   		    }
   		
  -          18        if (waithow != APR_WAIT) {
  +          22        if (waithow != APR_WAIT) {
         ######            waitpid_options |= WNOHANG;
   		    }
   		
  -          18        do {
  -          18            pstatus = waitpid(proc->pid, &exit_int, waitpid_options);
  -          18        } while (pstatus < 0 && errno == EINTR);
  -		
  -          18        if (pstatus > 0) {
  -          18            proc->pid = pstatus;
  -		
  -          18            if (WIFEXITED(exit_int)) {
  -          18                *exitwhy = APR_PROC_EXIT;
  -          18                *exitcode = WEXITSTATUS(exit_int);
  +          22        do {
  +          22            pstatus = waitpid(proc->pid, &exit_int, waitpid_options);
  +          22        } while (pstatus < 0 && errno == EINTR);
  +		
  +          22        if (pstatus > 0) {
  +          22            proc->pid = pstatus;
  +		
  +          22            if (WIFEXITED(exit_int)) {
  +          22                *exitwhy = APR_PROC_EXIT;
  +          22                *exitcode = WEXITSTATUS(exit_int);
   		        }
         ######            else if (WIFSIGNALED(exit_int)) {
         ######                *exitwhy = APR_PROC_SIGNAL;
  @@ -547,7 +547,7 @@
         ######                return APR_EGENERAL;
   		        }
   		
  -          18            return APR_CHILD_DONE;
  +          22            return APR_CHILD_DONE;
   		    }
         ######        else if (pstatus == 0) {
         ######            return APR_CHILD_NOTDONE;
  
  
  
  1.5       +90 -90    apr-site/docs/coverage/proc_mutex.c.gcov
  
  Index: proc_mutex.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/proc_mutex.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- proc_mutex.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ proc_mutex.c.gcov	15 Mar 2004 18:43:29 -0000	1.5
  @@ -19,8 +19,8 @@
   		#include "apr_arch_file_io.h" /* for apr_mkstemp() */
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  -      ######    {
  -      ######        return apr_pool_cleanup_run(mutex->pool, mutex, apr_proc_mutex_cleanup);
  +           7    {
  +           7        return apr_pool_cleanup_run(mutex->pool, mutex, apr_proc_mutex_cleanup);
   		}
   		
   		static apr_status_t proc_mutex_no_tryacquire(apr_proc_mutex_t *new_mutex)
  @@ -168,85 +168,85 @@
   		static struct sembuf proc_mutex_op_off;
   		
   		static void proc_mutex_sysv_setup(void)
  -           9    {
  -           9        proc_mutex_op_on.sem_num = 0;
  -           9        proc_mutex_op_on.sem_op = -1;
  -           9        proc_mutex_op_on.sem_flg = SEM_UNDO;
  -           9        proc_mutex_op_off.sem_num = 0;
  -           9        proc_mutex_op_off.sem_op = 1;
  -           9        proc_mutex_op_off.sem_flg = SEM_UNDO;
  +          13    {
  +          13        proc_mutex_op_on.sem_num = 0;
  +          13        proc_mutex_op_on.sem_op = -1;
  +          13        proc_mutex_op_on.sem_flg = SEM_UNDO;
  +          13        proc_mutex_op_off.sem_num = 0;
  +          13        proc_mutex_op_off.sem_op = 1;
  +          13        proc_mutex_op_off.sem_flg = SEM_UNDO;
   		}
   		
   		static apr_status_t proc_mutex_sysv_cleanup(void *mutex_)
  -           3    {
  -           3        apr_proc_mutex_t *mutex=mutex_;
  -           3        union semun ick;
  +          10    {
  +          10        apr_proc_mutex_t *mutex=mutex_;
  +          10        union semun ick;
   		    
  -           3        if (mutex->interproc->filedes != -1) {
  -           3            ick.val = 0;
  -           3            semctl(mutex->interproc->filedes, 0, IPC_RMID, ick);
  +          10        if (mutex->interproc->filedes != -1) {
  +          10            ick.val = 0;
  +          10            semctl(mutex->interproc->filedes, 0, IPC_RMID, ick);
   		    }
  -           3        return APR_SUCCESS;
  +          10        return APR_SUCCESS;
   		}    
   		
   		static apr_status_t proc_mutex_sysv_create(apr_proc_mutex_t *new_mutex,
   		                                           const char *fname)
  -           1    {
  -           1        union semun ick;
  -           1        apr_status_t rv;
  +           6    {
  +           6        union semun ick;
  +           6        apr_status_t rv;
   		    
  -           1        new_mutex->interproc = apr_palloc(new_mutex->pool, sizeof(*new_mutex->interproc));
  -           1        new_mutex->interproc->filedes = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
  +           6        new_mutex->interproc = apr_palloc(new_mutex->pool, sizeof(*new_mutex->interproc));
  +           6        new_mutex->interproc->filedes = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
   		
  -           1        if (new_mutex->interproc->filedes < 0) {
  +           6        if (new_mutex->interproc->filedes < 0) {
         ######            rv = errno;
         ######            proc_mutex_sysv_cleanup(new_mutex);
         ######            return rv;
   		    }
  -           1        ick.val = 1;
  -           1        if (semctl(new_mutex->interproc->filedes, 0, SETVAL, ick) < 0) {
  +           6        ick.val = 1;
  +           6        if (semctl(new_mutex->interproc->filedes, 0, SETVAL, ick) < 0) {
         ######            rv = errno;
         ######            proc_mutex_sysv_cleanup(new_mutex);
         ######            return rv;
   		    }
  -           1        new_mutex->curr_locked = 0;
  -           1        apr_pool_cleanup_register(new_mutex->pool,
  +           6        new_mutex->curr_locked = 0;
  +           6        apr_pool_cleanup_register(new_mutex->pool,
   		                              (void *)new_mutex, apr_proc_mutex_cleanup, 
   		                              apr_pool_cleanup_null);
  -           1        return APR_SUCCESS;
  +           6        return APR_SUCCESS;
   		}
   		
   		static apr_status_t proc_mutex_sysv_acquire(apr_proc_mutex_t *mutex)
  -        1200    {
  -        1200        int rc;
  +        2224    {
  +        2224        int rc;
   		
  -        1200        do {
  -        1200            rc = semop(mutex->interproc->filedes, &proc_mutex_op_on, 1);
  -        1200        } while (rc < 0 && errno == EINTR);
  -        1200        if (rc < 0) {
  +        2224        do {
  +        2224            rc = semop(mutex->interproc->filedes, &proc_mutex_op_on, 1);
  +        2224        } while (rc < 0 && errno == EINTR);
  +        2224        if (rc < 0) {
         ######            return errno;
   		    }
  -        1200        mutex->curr_locked = 1;
  -        1200        return APR_SUCCESS;
  +        2224        mutex->curr_locked = 1;
  +        2224        return APR_SUCCESS;
   		}
   		
   		static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)
  -        1200    {
  -        1200        int rc;
  +        2224    {
  +        2224        int rc;
   		
  -        1200        mutex->curr_locked = 0;
  -        1200        do {
  -        1200            rc = semop(mutex->interproc->filedes, &proc_mutex_op_off, 1);
  -        1200        } while (rc < 0 && errno == EINTR);
  -        1200        if (rc < 0) {
  +        2224        mutex->curr_locked = 0;
  +        2224        do {
  +        2224            rc = semop(mutex->interproc->filedes, &proc_mutex_op_off, 1);
  +        2224        } while (rc < 0 && errno == EINTR);
  +        2224        if (rc < 0) {
         ######            return errno;
   		    }
  -        1200        return APR_SUCCESS;
  +        2224        return APR_SUCCESS;
   		}
   		
   		static apr_status_t proc_mutex_sysv_child_init(apr_proc_mutex_t **mutex, apr_pool_t *cont, const char *fname)
  -           6    {
  -           6        return APR_SUCCESS;
  +          10    {
  +          10        return APR_SUCCESS;
   		}
   		
   		const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_sysv_methods =
  @@ -438,17 +438,17 @@
   		static apr_status_t proc_mutex_fcntl_release(apr_proc_mutex_t *);
   		
   		static void proc_mutex_fcntl_setup(void)
  -           9    {
  -           9        proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
  -           9        proc_mutex_lock_it.l_start = 0;           /* -"- */
  -           9        proc_mutex_lock_it.l_len = 0;             /* until end of file */
  -           9        proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */
  -           9        proc_mutex_lock_it.l_pid = 0;             /* pid not actually interesting */
  -           9        proc_mutex_unlock_it.l_whence = SEEK_SET; /* from current point */
  -           9        proc_mutex_unlock_it.l_start = 0;         /* -"- */
  -           9        proc_mutex_unlock_it.l_len = 0;           /* until end of file */
  -           9        proc_mutex_unlock_it.l_type = F_UNLCK;    /* set exclusive/write lock */
  -           9        proc_mutex_unlock_it.l_pid = 0;           /* pid not actually interesting */
  +          13    {
  +          13        proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
  +          13        proc_mutex_lock_it.l_start = 0;           /* -"- */
  +          13        proc_mutex_lock_it.l_len = 0;             /* until end of file */
  +          13        proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */
  +          13        proc_mutex_lock_it.l_pid = 0;             /* pid not actually interesting */
  +          13        proc_mutex_unlock_it.l_whence = SEEK_SET; /* from current point */
  +          13        proc_mutex_unlock_it.l_start = 0;         /* -"- */
  +          13        proc_mutex_unlock_it.l_len = 0;           /* until end of file */
  +          13        proc_mutex_unlock_it.l_type = F_UNLCK;    /* set exclusive/write lock */
  +          13        proc_mutex_unlock_it.l_pid = 0;           /* pid not actually interesting */
   		}
   		
   		static apr_status_t proc_mutex_fcntl_cleanup(void *mutex_)
  @@ -558,7 +558,7 @@
   		static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *);
   		
   		static void proc_mutex_flock_setup(void)
  -           9    {
  +          13    {
   		}
   		
   		static apr_status_t proc_mutex_flock_cleanup(void *mutex_)
  @@ -680,27 +680,27 @@
   		#endif /* flock implementation */
   		
   		void apr_proc_mutex_unix_setup_lock(void)
  -           9    {
  +          13    {
   		#if APR_HAS_POSIXSEM_SERIALIZE
   		    proc_mutex_posix_setup();
   		#endif
   		#if APR_HAS_SYSVSEM_SERIALIZE
  -           9        proc_mutex_sysv_setup();
  +          13        proc_mutex_sysv_setup();
   		#endif
   		#if APR_HAS_PROC_PTHREAD_SERIALIZE
   		    proc_mutex_proc_pthread_setup();
   		#endif
   		#if APR_HAS_FCNTL_SERIALIZE
  -           9        proc_mutex_fcntl_setup();
  +          13        proc_mutex_fcntl_setup();
   		#endif
   		#if APR_HAS_FLOCK_SERIALIZE
  -           9        proc_mutex_flock_setup();
  +          13        proc_mutex_flock_setup();
   		#endif
   		}
   		
   		static apr_status_t proc_mutex_choose_method(apr_proc_mutex_t *new_mutex, apr_lockmech_e mech)
  -           1    {
  -           1        switch (mech) {
  +           6    {
  +           6        switch (mech) {
   		    case APR_LOCK_FCNTL:
   		#if APR_HAS_FCNTL_SERIALIZE
         ######            new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
  @@ -735,12 +735,12 @@
   		#else
         ######            return APR_ENOTIMPL;
   		#endif
  -           1            break;
  +           6            break;
   		    case APR_LOCK_DEFAULT:
   		#if APR_USE_FLOCK_SERIALIZE
   		        new_mutex->inter_meth = &apr_proc_mutex_unix_flock_methods;
   		#elif APR_USE_SYSVSEM_SERIALIZE
  -           1            new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
  +           6            new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
   		#elif APR_USE_FCNTL_SERIALIZE
   		        new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
   		#elif APR_USE_PROC_PTHREAD_SERIALIZE
  @@ -750,11 +750,11 @@
   		#else
   		        return APR_ENOTIMPL;
   		#endif
  -           1            break;
  +           6            break;
   		    default:
         ######            return APR_ENOTIMPL;
   		    }
  -           1        return APR_SUCCESS;
  +           6        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(const char *) apr_proc_mutex_defname(void)
  @@ -771,55 +771,55 @@
   		}
   		   
   		static apr_status_t proc_mutex_create(apr_proc_mutex_t *new_mutex, apr_lockmech_e mech, const char *fname)
  -           1    {
  -           1        apr_status_t rv;
  +           6    {
  +           6        apr_status_t rv;
   		
  -           1        if ((rv = proc_mutex_choose_method(new_mutex, mech)) != APR_SUCCESS) {
  +           6        if ((rv = proc_mutex_choose_method(new_mutex, mech)) != APR_SUCCESS) {
         ######            return rv;
   		    }
   		
  -           1        new_mutex->meth = new_mutex->inter_meth;
  +           6        new_mutex->meth = new_mutex->inter_meth;
   		
  -           1        if ((rv = new_mutex->meth->create(new_mutex, fname)) != APR_SUCCESS) {
  +           6        if ((rv = new_mutex->meth->create(new_mutex, fname)) != APR_SUCCESS) {
         ######            return rv;
   		    }
   		
  -           1        return APR_SUCCESS;
  +           6        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
   		                                                const char *fname,
   		                                                apr_lockmech_e mech,
   		                                                apr_pool_t *pool)
  -           1    {
  -           1        apr_proc_mutex_t *new_mutex;
  -           1        apr_status_t rv;
  +           6    {
  +           6        apr_proc_mutex_t *new_mutex;
  +           6        apr_status_t rv;
   		
  -           1        new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool,
  +           6        new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool,
   		                                                sizeof(apr_proc_mutex_t));
   		
  -           1        new_mutex->pool  = pool;
  +           6        new_mutex->pool  = pool;
   		#if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE || APR_HAS_POSIXSEM_SERIALIZE
  -           1        new_mutex->interproc = NULL;
  +           6        new_mutex->interproc = NULL;
   		#endif
   		
  -           1        if ((rv = proc_mutex_create(new_mutex, mech, fname)) != APR_SUCCESS)
  +           6        if ((rv = proc_mutex_create(new_mutex, mech, fname)) != APR_SUCCESS)
         ######            return rv;
   		
  -           1        *mutex = new_mutex;
  -           1        return APR_SUCCESS;
  +           6        *mutex = new_mutex;
  +           6        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
   		                                                    const char *fname,
   		                                                    apr_pool_t *pool)
  -           6    {
  -           6        return (*mutex)->meth->child_init(mutex, pool, fname);
  +          10    {
  +          10        return (*mutex)->meth->child_init(mutex, pool, fname);
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  -        1200    {
  -        1200        return mutex->meth->acquire(mutex);
  +        2224    {
  +        2224        return mutex->meth->acquire(mutex);
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  @@ -828,13 +828,13 @@
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  -        1200    {
  -        1200        return mutex->meth->release(mutex);
  +        2224    {
  +        2224        return mutex->meth->release(mutex);
   		}
   		
   		APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex)
  -           3    {
  -           3        return ((apr_proc_mutex_t *)mutex)->meth->cleanup(mutex);
  +          10    {
  +          10        return ((apr_proc_mutex_t *)mutex)->meth->cleanup(mutex);
   		}
   		
   		APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
  
  
  
  1.5       +9 -9      apr-site/docs/coverage/signals.c.gcov
  
  Index: signals.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/signals.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- signals.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ signals.c.gcov	15 Mar 2004 18:43:29 -0000	1.5
  @@ -65,14 +65,14 @@
   		 * (the version that does not automatically restart system calls).
   		 */
   		APR_DECLARE(apr_sigfunc_t *) apr_signal(int signo, apr_sigfunc_t * func)
  -          11    {
  -          11        struct sigaction act, oact;
  +          15    {
  +          15        struct sigaction act, oact;
   		
  -          11        act.sa_handler = func;
  -          11        sigemptyset(&act.sa_mask);
  -          11        act.sa_flags = 0;
  +          15        act.sa_handler = func;
  +          15        sigemptyset(&act.sa_mask);
  +          15        act.sa_flags = 0;
   		#ifdef SA_INTERRUPT             /* SunOS */
  -          11        act.sa_flags |= SA_INTERRUPT;
  +          15        act.sa_flags |= SA_INTERRUPT;
   		#endif
   		#if defined(__osf__) && defined(__alpha)
   		    /* XXX jeff thinks this should be enabled whenever SA_NOCLDWAIT is defined */
  @@ -93,9 +93,9 @@
   		        act.sa_handler = avoid_zombies;
   		    }
   		#endif
  -          11        if (sigaction(signo, &act, &oact) < 0)
  +          15        if (sigaction(signo, &act, &oact) < 0)
         ######            return SIG_ERR;
  -          11        return oact.sa_handler;
  +          15        return oact.sa_handler;
   		}
   		
   		#endif /* HAVE_SIGACTION */
  @@ -105,7 +105,7 @@
   		#if defined(SYS_SIGLIST_DECLARED) || HAVE_DECL_SYS_SIGLIST
   		
   		void apr_signal_init(apr_pool_t *pglobal)
  -           9    {
  +          13    {
   		}
   		const char *apr_signal_description_get(int signum)
         ######    {
  
  
  
  1.5       +15 -15    apr-site/docs/coverage/start.c.gcov
  
  Index: start.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/start.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- start.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ start.c.gcov	15 Mar 2004 18:43:29 -0000	1.5
  @@ -38,27 +38,27 @@
   		static int initialized = 0;
   		
   		APR_DECLARE(apr_status_t) apr_initialize(void)
  -          15    {
  -          15        apr_pool_t *pool;
  -          15        apr_status_t status;
  +          19    {
  +          19        apr_pool_t *pool;
  +          19        apr_status_t status;
   		
  -          15        if (initialized++) {
  +          19        if (initialized++) {
              6            return APR_SUCCESS;
   		    }
   		
   		#if !defined(BEOS) && !defined(OS2)
  -           9        apr_proc_mutex_unix_setup_lock();
  -           9        apr_unix_setup_time();
  +          13        apr_proc_mutex_unix_setup_lock();
  +          13        apr_unix_setup_time();
   		#endif
   		
  -           9        if ((status = apr_pool_initialize()) != APR_SUCCESS)
  +          13        if ((status = apr_pool_initialize()) != APR_SUCCESS)
         ######            return status;
   		    
  -           9        if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
  +          13        if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
         ######            return APR_ENOPOOL;
   		    }
   		
  -           9        apr_pool_tag(pool, "apr_initialize");
  +          13        apr_pool_tag(pool, "apr_initialize");
   		
   		    /* apr_atomic_init() used to be called from here aswell.
   		     * Pools rely on mutexes though, which can be backed by
  @@ -67,18 +67,18 @@
   		     * apr_atomic_init() at the correct time.
   		     */
   		
  -           9        apr_signal_init(pool);
  +          13        apr_signal_init(pool);
   		
  -           9        return APR_SUCCESS;
  +          13        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE_NONSTD(void) apr_terminate(void)
  -          13    {
  -          13        initialized--;
  -          13        if (initialized) {
  +          17    {
  +          17        initialized--;
  +          17        if (initialized) {
              6            return;
   		    }
  -           7        apr_pool_terminate();
  +          11        apr_pool_terminate();
   		    
   		}
   		
  
  
  
  1.6       +27 -27    apr-site/docs/coverage/thread_mutex.c.gcov
  
  Index: thread_mutex.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/thread_mutex.c.gcov,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- thread_mutex.c.gcov	15 Mar 2004 03:38:39 -0000	1.5
  +++ thread_mutex.c.gcov	15 Mar 2004 18:43:29 -0000	1.6
  @@ -20,55 +20,55 @@
   		#if APR_HAS_THREADS
   		
   		static apr_status_t thread_mutex_cleanup(void *data)
  -          93    {
  -          93        apr_thread_mutex_t *mutex = data;
  -          93        apr_status_t rv;
  +         132    {
  +         132        apr_thread_mutex_t *mutex = data;
  +         132        apr_status_t rv;
   		
  -          93        rv = pthread_mutex_destroy(&mutex->mutex);
  +         132        rv = pthread_mutex_destroy(&mutex->mutex);
   		#ifdef PTHREAD_SETS_ERRNO
   		    if (rv) {
   		        rv = errno;
   		    }
   		#endif
  -          93        return rv;
  +         132        return rv;
   		} 
   		
   		APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
   		                                                  unsigned int flags,
   		                                                  apr_pool_t *pool)
  -          85    {
  -          85        apr_thread_mutex_t *new_mutex;
  -          85        apr_status_t rv;
  +         122    {
  +         122        apr_thread_mutex_t *new_mutex;
  +         122        apr_status_t rv;
   		
  -          85        new_mutex = apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
  +         122        new_mutex = apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
   		
  -          85        new_mutex->pool = pool;
  +         122        new_mutex->pool = pool;
   		
   		    /* Optimal default is APR_THREAD_MUTEX_UNNESTED, 
   		     * no additional checks required for either flag.
   		     */
  -          85        new_mutex->nested = flags & APR_THREAD_MUTEX_NESTED;
  +         122        new_mutex->nested = flags & APR_THREAD_MUTEX_NESTED;
   		
  -          85        if ((rv = pthread_mutex_init(&new_mutex->mutex, NULL))) {
  +         122        if ((rv = pthread_mutex_init(&new_mutex->mutex, NULL))) {
   		#ifdef PTHREAD_SETS_ERRNO
   		        rv = errno;
   		#endif
         ######            return rv;
   		    }
   		
  -          85        apr_pool_cleanup_register(new_mutex->pool,
  +         122        apr_pool_cleanup_register(new_mutex->pool,
   		                              new_mutex, thread_mutex_cleanup,
   		                              apr_pool_cleanup_null);
   		
  -          85        *mutex = new_mutex;
  -          85        return APR_SUCCESS;
  +         122        *mutex = new_mutex;
  +         122        return APR_SUCCESS;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
  -     4380685    {
  -     4380685        apr_status_t rv;
  +     4381733    {
  +     4381733        apr_status_t rv;
   		
  -     4380685        if (mutex->nested) {
  +     4381733        if (mutex->nested) {
   		        /*
   		         * Although threadsafe, this test is NOT reentrant.  
   		         * The thread's main and reentrant attempts will both mismatch 
  @@ -101,13 +101,13 @@
         ######            return rv;
   		    }
   		    else {
  -     4380685            rv = pthread_mutex_lock(&mutex->mutex);
  +     4381733            rv = pthread_mutex_lock(&mutex->mutex);
   		#ifdef PTHREAD_SETS_ERRNO
   		        if (rv) {
   		            rv = errno;
   		        }
   		#endif
  -     4380685            return rv;
  +     4381733            return rv;
   		    }
   		}
   		
  @@ -163,10 +163,10 @@
   		static apr_os_thread_t invalid_thread_id; /* all zeroes */
   		
   		APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
  -     4380685    {
  -     4380685        apr_status_t status;
  +     4381733    {
  +     4381733        apr_status_t status;
   		
  -     4380685        if (mutex->nested) {
  +     4381733        if (mutex->nested) {
   		        /*
   		         * The code below is threadsafe and reentrant.
   		         */
  @@ -190,19 +190,19 @@
   		        }
   		    }
   		
  -     4380685        status = pthread_mutex_unlock(&mutex->mutex);
  +     4381733        status = pthread_mutex_unlock(&mutex->mutex);
   		#ifdef PTHREAD_SETS_ERRNO
   		    if (status) {
   		        status = errno;
   		    }
   		#endif
   		
  -     4380685        return status;
  +     4381733        return status;
   		}
   		
   		APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
  -      ######    {
  -      ######        return apr_pool_cleanup_run(mutex->pool, mutex, thread_mutex_cleanup);
  +           7    {
  +           7        return apr_pool_cleanup_run(mutex->pool, mutex, thread_mutex_cleanup);
   		}
   		
         ######    APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
  
  
  
  1.5       +10 -10    apr-site/docs/coverage/time.c.gcov
  
  Index: time.c.gcov
  ===================================================================
  RCS file: /home/cvs/apr-site/docs/coverage/time.c.gcov,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- time.c.gcov	15 Mar 2004 03:38:39 -0000	1.4
  +++ time.c.gcov	15 Mar 2004 18:43:29 -0000	1.5
  @@ -70,10 +70,10 @@
   		
   		/* NB NB NB NB This returns GMT!!!!!!!!!! */
   		APR_DECLARE(apr_time_t) apr_time_now(void)
  -         537    {
  -         537        struct timeval tv;
  -         537        gettimeofday(&tv, NULL);
  -         537        return tv.tv_sec * APR_USEC_PER_SEC + tv.tv_usec;
  +         540    {
  +         540        struct timeval tv;
  +         540        gettimeofday(&tv, NULL);
  +         540        return tv.tv_sec * APR_USEC_PER_SEC + tv.tv_usec;
   		}
   		
   		static void explode_time(apr_time_exp_t *xt, apr_time_t t,
  @@ -235,7 +235,7 @@
   		}
   		
   		APR_DECLARE(void) apr_sleep(apr_interval_time_t t)
  -        1852    {
  +        1855    {
   		#ifdef OS2
   		    DosSleep(t/1000);
   		#elif defined(BEOS)
  @@ -243,10 +243,10 @@
   		#elif defined(NETWARE)
   		    delay(t/1000);
   		#else
  -        1852        struct timeval tv;
  -        1852        tv.tv_usec = t % APR_USEC_PER_SEC;
  -        1852        tv.tv_sec = t / APR_USEC_PER_SEC;
  -        1852        select(0, NULL, NULL, NULL, &tv);
  +        1855        struct timeval tv;
  +        1855        tv.tv_usec = t % APR_USEC_PER_SEC;
  +        1855        tv.tv_sec = t / APR_USEC_PER_SEC;
  +        1855        select(0, NULL, NULL, NULL, &tv);
   		#endif
   		}
   		
  @@ -280,7 +280,7 @@
   		}
   		#else
   		APR_DECLARE(void) apr_unix_setup_time(void)
  -           9    {
  +          13    {
   		#if !defined(HAVE_GMTOFF) && !defined(HAVE___OFFSET)
   		    /* Precompute the offset from GMT on systems where it's not
   		       in struct tm.
  
  
  

Mime
View raw message