Improved handling of stack size and addresses attribute for threads ([BOX32] too)

1 files changed, 52 insertions, 21 deletions

diff --git a/src/libtools/threads32.c b/src/libtools/threads32.c
index cab37ee2..2378b3a6 100755
--- a/src/libtools/threads32.c
+++ b/src/libtools/threads32.c
@@ -94,9 +94,9 @@ KHASH_MAP_INIT_INT(cancelthread, __pthread_unwind_buf_t*)
 #endif
 
 void CleanStackSize(box64context_t* context);
-void FreeStackSize(kh_threadstack_t* map, uintptr_t attr);
-void AddStackSize(kh_threadstack_t* map, uintptr_t attr, void* stack, size_t stacksize);
-int GetStackSize(x64emu_t* emu, uintptr_t attr, void** stack, size_t* stacksize);
+void FreeStackSize(uintptr_t attr);
+void AddStackSize(uintptr_t attr, void* stack, size_t stacksize);
+int GetStackSize(uintptr_t attr, void** stack, size_t* stacksize);
 
 void my32_longjmp(x64emu_t* emu, /*struct __jmp_buf_tag __env[1]*/void *p, int32_t __val);
 
@@ -153,8 +153,8 @@ static void* pthread_routine(void* p)
 
 EXPORT int my32_pthread_attr_destroy(x64emu_t* emu, void* attr)
 {
-	if(emu->context->stacksizes)
-		FreeStackSize(emu->context->stacksizes, (uintptr_t)attr);
+	if(my_context->stacksizes)
+		FreeStackSize((uintptr_t)attr);
 	int ret = pthread_attr_destroy(get_attr(attr));
 	del_attr(attr);
 	return ret;
@@ -164,16 +164,13 @@ EXPORT int my32_pthread_attr_getstack(x64emu_t* emu, void* attr, void** stackadd
 {
 	int ret = pthread_attr_getstack(get_attr(attr), stackaddr, stacksize);
 	if (ret==0)
-		GetStackSize(emu, (uintptr_t)attr, stackaddr, stacksize);
+		GetStackSize((uintptr_t)attr, stackaddr, stacksize);
 	return ret;
 }
 
 EXPORT int my32_pthread_attr_setstack(x64emu_t* emu, void* attr, void* stackaddr, size_t stacksize)
 {
-	if(!emu->context->stacksizes) {
-		emu->context->stacksizes = kh_init(threadstack);
-	}
-	AddStackSize(emu->context->stacksizes, (uintptr_t)attr, stackaddr, stacksize);
+	AddStackSize((uintptr_t)attr, stackaddr, stacksize);
 	//Don't call actual setstack...
 	//return pthread_attr_setstack(attr, stackaddr, stacksize);
 	return pthread_attr_setstacksize(get_attr(attr), stacksize);
@@ -185,7 +182,7 @@ EXPORT int my32_pthread_create(x64emu_t *emu, void* t, void* attr, void* start_r
 	void* attr_stack;
 	size_t attr_stacksize;
 	int own;
-	void* stack;
+	void* stack = NULL;
 
 	if(attr) {
 		size_t stsize;
@@ -194,14 +191,19 @@ EXPORT int my32_pthread_create(x64emu_t *emu, void* t, void* attr, void* start_r
 		if(stacksize<512*1024)	// emu and all needs some stack space, don't go too low
 			pthread_attr_setstacksize(get_attr(attr), 512*1024);
 	}
-	if(GetStackSize(emu, (uintptr_t)attr, &attr_stack, &attr_stacksize))
+	if(GetStackSize((uintptr_t)attr, &attr_stack, &attr_stacksize))
 	{
 		stack = attr_stack;
 		stacksize = attr_stacksize;
 		own = 0;
-	} else {
+		if((uintptr_t)stack>=0x100000000LL) {
+			printf_log(LOG_INFO, "Address of Stack for thread too high (%p), allocationg a new one\n", stack);
+			stack = NULL;
+		}
+	}
+	if(!stack) {
 		//stack = malloc(stacksize);
-		stack = mmap64(NULL, stacksize, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN|MAP_32BIT, -1, 0);
+		stack = mmap64(NULL, stacksize, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_32BIT, -1, 0);
 		own = 1;
 	}
 
@@ -224,7 +226,6 @@ EXPORT int my32_pthread_create(x64emu_t *emu, void* t, void* attr, void* start_r
 	#ifdef DYNAREC
 	if(box64_dynarec) {
 		// pre-creation of the JIT code for the entry point of the thread
-		dynablock_t *current = NULL;
 		DBGetBlock(emu, (uintptr_t)start_routine, 1, 1);
 	}
 	#endif
@@ -237,7 +238,8 @@ EXPORT int my32_pthread_detach(x64emu_t* emu, pthread_t p)
 {
 	if(pthread_equal(p ,pthread_self())) {
 		emuthread_t *et = (emuthread_t*)thread_get_et();
-		et->join = 0;
+		if(et)
+			et->join = 0;
 	}
 	return pthread_detach(p);
 }
@@ -646,7 +648,26 @@ EXPORT int my32_pthread_attr_init(x64emu_t* emu, void* attr)
 
 EXPORT int my32_pthread_getattr_np(x64emu_t* emu, uintptr_t th, void* attr)
 {
-	return pthread_getattr_np(th, get_attr(attr));
+	(void)emu;
+	int ret = pthread_getattr_np(th, get_attr(attr));
+	if(!ret && th==pthread_self()) {
+		if(!emu->context->stacksizes) {
+			emu->context->stacksizes = kh_init(threadstack);
+		}
+		void* stack = emu->init_stack;
+		size_t sz = emu->size_stack;
+//printf_log(LOG_INFO, "pthread_getattr_np called for self, stack=%p, sz=%lx\n", stack, sz);
+		if (!sz) {
+			// get default stack size
+			pthread_attr_t attr;
+			pthread_getattr_default_np(&attr);
+			pthread_attr_getstacksize(&attr, &sz);
+			pthread_attr_destroy(&attr);
+			// should stack be adjusted?
+		}
+		AddStackSize((uintptr_t)attr, stack, sz);
+	}
+	return ret;
 }
 
 EXPORT int my32_pthread_attr_getdetachstate(x64emu_t* emu, void* attr, void* p)
@@ -723,11 +744,21 @@ EXPORT int my32_pthread_attr_setstackaddr(x64emu_t* emu, void* attr, void* p)
 {
 	size_t size = 2*1024*1024;
 	void* pp;
-	pthread_attr_getstack(get_attr(attr), &pp, &size);
-	return pthread_attr_setstack(get_attr(attr), p, size);
+	GetStackSize((uintptr_t)attr, &pp, &size);
+	AddStackSize((uintptr_t)attr, p, size);
+
+	return 0;
 }
 EXPORT int my32_pthread_attr_setstacksize(x64emu_t* emu, void* attr, size_t p)
 {
+	if(p<0xc000 || (p&4095)) {
+		errno = EINVAL;
+		return -1;
+	}
+	size_t size;
+	void* pp = NULL;
+	GetStackSize((uintptr_t)attr, &pp, &size);
+	AddStackSize((uintptr_t)attr, pp, p);
 	// PTHREAD_STACK_MIN on x86 might be lower than the current platform...
 	if(p>=0xc000 && p<PTHREAD_STACK_MIN && !(p&4095))
 		p = PTHREAD_STACK_MIN;
@@ -835,7 +866,7 @@ EXPORT int my32_pthread_kill_old(x64emu_t* emu, void* thread, int sig)
 
 pthread_mutex_t* createNewMutex()
 {
-	pthread_mutex_t* ret = (pthread_mutex_t*)box_calloc(1, sizeof(pthread_mutex_t));
+	pthread_mutex_t* ret = (pthread_mutex_t*)box32_calloc(1, sizeof(pthread_mutex_t));
 	return ret;
 }
 // init = 0: just get the mutex
@@ -892,7 +923,7 @@ EXPORT int my32_pthread_mutex_destroy(pthread_mutex_t *m)
 	}
 	pthread_mutex_t *n = from_ptrv(fake->real_mutex);
 	int ret = pthread_mutex_destroy(n);
-	box_free(n);
+	box32_free(n);
 	fake->__kind = fake->i386__kind = -1;
 	return ret;
 }