0.pre8.28

[sbcl.git] / src / runtime / x86-linux-os.c

diff --git a/src/runtime/x86-linux-os.c b/src/runtime/x86-linux-os.c
index 30a44da..aa1a0ad 100644 (file)
--- 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, %%gs" : : "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 %%gs:%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