X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fx86-linux-os.c;h=460cc9ce5ed8d6e9ecc7d23c12fa6973668302fa;hb=097211d0597e5185c678d5933fb1102b649e3a94;hp=30a44daaa5ba423570097e721ab3688d05f29842;hpb=9f10bc102adce15a820027777a03e49a7b7623da;p=sbcl.git

diff --git a/src/runtime/x86-linux-os.c b/src/runtime/x86-linux-os.c
index 30a44da..460cc9c 100644
--- a/src/runtime/x86-linux-os.c
+++ b/src/runtime/x86-linux-os.c
@@ -15,8 +15,12 @@
  */
 
 #include <stdio.h>
+#include <stddef.h>
 #include <sys/param.h>
 #include <sys/file.h>
+#include <sys/types.h>
+#include <unistd.h>
+
 #include "./signal.h"
 #include "os.h"
 #include "arch.h"
@@ -34,10 +38,105 @@
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <asm/ldt.h>
+#include <linux/unistd.h>
+#include <sys/mman.h>
+#include "thread.h"		/* dynamic_values_bytes */
+
+_syscall3(int, modify_ldt, int, func, void *, ptr, unsigned long, bytecount );
 
 #include "validate.h"
 size_t os_vm_page_size;
 
+u32 local_ldt_copy[LDT_ENTRIES*LDT_ENTRY_SIZE/sizeof(u32)];
+
+/* XXX this could be conditionally compiled based on some
+ * "debug-friendly" flag.  But it doesn't really make stuff slower,
+ * just the runtime gets fractionally larger */
+
+void debug_get_ldt()
+{ 
+    int n=__modify_ldt (0, local_ldt_copy, sizeof local_ldt_copy);
+    printf("%d bytes in ldt: print/x local_ldt_copy\n", n);
+}
+
+int arch_os_thread_init(struct thread *thread) {
+    stack_t sigstack;
+#ifdef LISP_FEATURE_SB_THREAD
+    /* this must be called from a function that has an exclusive lock
+     * on all_threads
+     */
+    struct modify_ldt_ldt_s ldt_entry = {
+	1, 0, 0, /* index, address, length filled in later */
+	1, MODIFY_LDT_CONTENTS_DATA, 0, 0, 0, 1
+    }; 
+    /* get next free ldt entry */
+    int n=__modify_ldt(0,local_ldt_copy,sizeof local_ldt_copy);
+    if(n) {
+	u32 *p;
+	for(n=0,p=local_ldt_copy;*p;p+=LDT_ENTRY_SIZE/sizeof(u32))
+	    n++;
+    }
+    ldt_entry.entry_number=n;
+    ldt_entry.base_addr=(unsigned long) thread;
+    ldt_entry.limit=dynamic_values_bytes;
+    ldt_entry.limit_in_pages=0;
+    if (__modify_ldt (1, &ldt_entry, sizeof (ldt_entry)) != 0) 
+	/* modify_ldt call failed: something magical is not happening */
+	return -1;
+    __asm__ __volatile__ ("movw %w0, %%fs" : : "q" 
+			  ((n << 3) /* selector number */
+			   + (1 << 2) /* TI set = LDT */
+			   + 3)); /* privilege level */
+    thread->tls_cookie=n;
+    if(n<0) return 0;
+#endif
+#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
+    /* Signal handlers are run on the control stack, so if it is exhausted
+     * we had better use an alternate stack for whatever signal tells us
+     * we've exhausted it */
+    sigstack.ss_sp=((void *) thread)+dynamic_values_bytes;
+    sigstack.ss_flags=0;
+    sigstack.ss_size = 32*SIGSTKSZ;
+    sigaltstack(&sigstack,0);
+#endif
+    return 1;
+}
+
+/* if you can't do something like this (maybe because you're using a 
+ * register for thread base that is only available in Lisp code)
+ * you'll just have to find_thread_by_pid(getpid())
+ */
+struct thread *arch_os_get_current_thread() {
+#ifdef LISP_FEATURE_SB_THREAD
+    register struct thread *me=0;
+    if(all_threads)
+	__asm__ ("movl %%fs:%c1,%0" : "=r" (me)
+		 : "i" (offsetof (struct thread,this)));
+    return me;
+#else
+    return all_threads;
+#endif
+}
+
+/* free any arch/os-specific resources used by thread, which is now
+ * defunct.  Not called on live threads
+ */
+
+int arch_os_thread_cleanup(struct thread *thread) {
+    struct modify_ldt_ldt_s ldt_entry = {
+	0, 0, 0, 
+	0, MODIFY_LDT_CONTENTS_DATA, 0, 0, 0, 0
+    }; 
+
+    ldt_entry.entry_number=thread->tls_cookie;
+    if (__modify_ldt (1, &ldt_entry, sizeof (ldt_entry)) != 0) 
+	/* modify_ldt call failed: something magical is not happening */
+	return 0;
+    return 1;
+}
+
+
 
 /* KLUDGE: As of kernel 2.2.14 on Red Hat 6.2, there's code in the
  * <sys/ucontext.h> file to define symbolic names for offsets into