*/
#include <stdio.h>
+#include <stddef.h>
#include <sys/param.h>
#include <sys/file.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
#include "./signal.h"
#include "os.h"
#include "arch.h"
#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;
-#if defined GENCGC
-#include "gencgc.h"
+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);
+}
+
+lispobj modify_ldt_lock; /* protect all calls to modify_ldt */
+
+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
+ };
+ int n;
+ get_spinlock(&modify_ldt_lock,thread);
+ n=modify_ldt(0,local_ldt_copy,sizeof local_ldt_copy);
+ /* get next free ldt entry */
+
+ 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_lock=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;
+ modify_ldt_lock=0;
+
+ 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__ __volatile__ ("movl %%fs:%c1,%0" : "=r" (me)
+ : "i" (offsetof (struct thread,this)));
+ return me;
+#else
+ return all_threads;
+#endif
+}
+struct thread *debug_get_fs() {
+ register u32 fs;
+ __asm__ __volatile__ ("movl %%fs,%0" : "=r" (fs) : );
+ return fs;
+}
+
+/* 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;
+ get_spinlock(&modify_ldt_lock,thread);
+ if (modify_ldt (1, &ldt_entry, sizeof (ldt_entry)) != 0) {
+ modify_ldt_lock=0;
+ /* modify_ldt call failed: something magical is not happening */
+ return 0;
+ }
+ modify_ldt_lock=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
os_context_register_t *
os_context_pc_addr(os_context_t *context)
{
- return &context->uc_mcontext.gregs[14];
+ return &context->uc_mcontext.gregs[14]; /* REG_EIP */
}
os_context_register_t *
os_context_sp_addr(os_context_t *context)
+{
+ return &context->uc_mcontext.gregs[17]; /* REG_UESP */
+}
+
+os_context_register_t *
+os_context_fp_addr(os_context_t *context)
{
- return &context->uc_mcontext.gregs[17];
+ return &context->uc_mcontext.gregs[6]; /* REG_EBP */
}
unsigned long
os_context_fp_control(os_context_t *context)
{
- /* probably the code snippet
- * #ifdef __linux__
- * SET_FPU_CONTROL_WORD(context->__fpregs_mem.cw);
- * #endif
- * is relevant to implementing this correctly */
-
- /* Note that currently this is not called, as there is an analogous
- * stub in lisp-land (x86-vm.lisp), also returning 0, with the old
- * lisp fp-control code. This is here more as a signpost of a possible
- * way of restoring functionality, and if it is the way to go would
- * need to be included for other architectures as well. */
- return 0;
+ return ((((context->uc_mcontext.fpregs->cw) & 0xffff) ^ 0x3f) |
+ (((context->uc_mcontext.fpregs->sw) & 0xffff) << 16));
}
sigset_t *
}
void
+os_restore_fp_control(os_context_t *context)
+{
+ asm ("fldcw %0" : : "m" (context->uc_mcontext.fpregs->cw));
+}
+
+void
os_flush_icache(os_vm_address_t address, os_vm_size_t length)
{
}