Undo namespace pollution by prefixing the globals pthread_guard_default and

pthread_page_size.

Fix a bunch line wrapping.

Pointed out by: deischen

4 files changed, 29 insertions, 26 deletions

diff --git a/lib/libpthread/thread/thr_attr_setguardsize.c b/lib/libpthread/thread/thr_attr_setguardsize.c
index 8dc7938..ad3e8bb 100644
--- a/lib/libpthread/thread/thr_attr_setguardsize.c
+++ b/lib/libpthread/thread/thr_attr_setguardsize.c
@@ -47,11 +47,11 @@ _pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 	else {
 		/*
 		 * Round guardsize up to the nearest multiple of
-		 * pthread_page_size.
+		 * _pthread_page_size.
 		 */
-		if (guardsize % pthread_page_size != 0)
-			guardsize = ((guardsize / pthread_page_size) + 1) *
-			    pthread_page_size;
+		if (guardsize % _pthread_page_size != 0)
+			guardsize = ((guardsize / _pthread_page_size) + 1) *
+			    _pthread_page_size;
 
 		/* Save the stack size. */
 		(*attr)->guardsize_attr = guardsize;
diff --git a/lib/libpthread/thread/thr_init.c b/lib/libpthread/thread/thr_init.c
index 96fa3f7..2790748 100644
--- a/lib/libpthread/thread/thr_init.c
+++ b/lib/libpthread/thread/thr_init.c
@@ -146,8 +146,8 @@ static void *libgcc_references[] = {
 	&_pthread_mutex_unlock
 };
 
-int pthread_guard_default;
-int pthread_page_size;
+int _pthread_guard_default;
+int _pthread_page_size;
 
 /*
  * Threaded process initialization
@@ -165,11 +165,11 @@ _thread_init(void)
 	struct clockinfo clockinfo;
 	struct sigaction act;
 
-	pthread_page_size = getpagesize();
-	pthread_guard_default = getpagesize();
+	_pthread_page_size = getpagesize();
+	_pthread_guard_default = getpagesize();
 	sched_stack_size = getpagesize();
     	
-	pthread_attr_default.guardsize_attr = pthread_guard_default;
+	pthread_attr_default.guardsize_attr = _pthread_guard_default;
 
 
 	/* Check if this function has already been called: */
@@ -291,8 +291,8 @@ _thread_init(void)
 		 * thread stack that is just beyond.
 		 */
 		if (mmap(_usrstack - PTHREAD_STACK_INITIAL -
-		    pthread_guard_default, pthread_guard_default, 0, MAP_ANON,
-		    -1, 0) == MAP_FAILED)
+		    _pthread_guard_default, _pthread_guard_default, 0,
+		    MAP_ANON, -1, 0) == MAP_FAILED)
 			PANIC("Cannot allocate red zone for initial thread");
 
 		/* Set the main thread stack pointer. */
diff --git a/lib/libpthread/thread/thr_private.h b/lib/libpthread/thread/thr_private.h
index 333c02e..04023fb 100644
--- a/lib/libpthread/thread/thr_private.h
+++ b/lib/libpthread/thread/thr_private.h
@@ -423,9 +423,9 @@ enum pthread_susp {
  * explicitly mapped red zones.
  * This is declared and initialized in uthread_init.c.
  */
-extern int pthread_guard_default;
+extern int _pthread_guard_default;
 
-extern int pthread_page_size;
+extern int _pthread_page_size;
 
 /*
  * Maximum size of initial thread's stack.  This perhaps deserves to be larger
diff --git a/lib/libpthread/thread/thr_stack.c b/lib/libpthread/thread/thr_stack.c
index 1913b09..80c9d53 100644
--- a/lib/libpthread/thread/thr_stack.c
+++ b/lib/libpthread/thread/thr_stack.c
@@ -122,13 +122,15 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize)
 	size_t		stack_size;
 
 	/*
-	 * Round up stack size to nearest multiple of pthread_page_size, so that mmap()
-	 * will work.  If the stack size is not an even multiple, we end up
-	 * initializing things such that there is unused space above the
-	 * beginning of the stack, so the stack sits snugly against its guard.
+	 * Round up stack size to nearest multiple of _pthread_page_size,
+	 * so that mmap() * will work.  If the stack size is not an even
+	 * multiple, we end up initializing things such that there is unused
+	 * space above the beginning of the stack, so the stack sits snugly
+	 * against its guard.
 	 */
-	if (stacksize % pthread_page_size != 0)
-		stack_size = ((stacksize / pthread_page_size) + 1) * pthread_page_size;
+	if (stacksize % _pthread_page_size != 0)
+		stack_size = ((stacksize / _pthread_page_size) + 1) *
+		    _pthread_page_size;
 	else
 		stack_size = stacksize;
 
@@ -137,7 +139,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize)
 	 * from the default-size stack cache:
 	 */
 	if (stack_size == PTHREAD_STACK_DEFAULT &&
-	    guardsize == pthread_guard_default) {
+	    guardsize == _pthread_guard_default) {
 		/*
 		 * Use the garbage collector mutex for synchronization of the
 		 * spare stack list.
@@ -187,7 +189,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize)
 
 		if (last_stack == NULL)
 			last_stack = _usrstack - PTHREAD_STACK_INITIAL -
-			    pthread_guard_default;
+			    _pthread_guard_default;
 
 		/* Allocate a new stack. */
 		stack = last_stack - stack_size;
@@ -217,17 +219,18 @@ _thread_stack_free(void *stack, size_t stacksize, size_t guardsize)
 	struct stack	*spare_stack;
 
 	spare_stack = (stack + stacksize - sizeof(struct stack));
-	/* Round stacksize up to nearest multiple of pthread_page_size. */
-	if (stacksize % pthread_page_size != 0) {
-		spare_stack->stacksize = ((stacksize / pthread_page_size) + 1) *
-		    pthread_page_size;
+	/* Round stacksize up to nearest multiple of _pthread_page_size. */
+	if (stacksize % _pthread_page_size != 0) {
+		spare_stack->stacksize =
+		    ((stacksize / _pthread_page_size) + 1) *
+		    _pthread_page_size;
 	} else
 		spare_stack->stacksize = stacksize;
 	spare_stack->guardsize = guardsize;
 	spare_stack->stackaddr = stack;
 
 	if (spare_stack->stacksize == PTHREAD_STACK_DEFAULT &&
-	    spare_stack->guardsize == pthread_guard_default) {
+	    spare_stack->guardsize == _pthread_guard_default) {
 		/* Default stack/guard size. */
 		LIST_INSERT_HEAD(&_dstackq, spare_stack, qe);
 	} else {