You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@apr.apache.org by rb...@apache.org on 2004/03/15 19:43:29 UTC
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
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.