1.0.8.11: Fix typo in comment.
[sbcl.git] / src / runtime / x86-sunos-os.c
1 #include <stdio.h>
2 #include <sys/param.h>
3 #include <sys/file.h>
4 #include "sbcl.h"
5 #include "./signal.h"
6 #include "os.h"
7 #include "arch.h"
8 #include "globals.h"
9 #include "interrupt.h"
10 #include "interr.h"
11 #include "lispregs.h"
12 #include <sys/socket.h>
13 #include <sys/utsname.h>
14
15 #include <sys/types.h>
16 #include <signal.h>
17 #include <sys/time.h>
18 #include <sys/stat.h>
19 #include <unistd.h>
20
21 #ifdef LISP_FEATURE_SB_THREAD
22 #include <sys/segment.h>
23 #include <sys/sysi86.h>
24 #endif
25
26 #include "validate.h"
27
28 #ifdef LISP_FEATURE_SB_THREAD
29 pthread_mutex_t modify_ldt_lock = PTHREAD_MUTEX_INITIALIZER;
30
31 static int
32 ldt_index_selector (int index) {
33   return index << 3 | 7;
34 }
35
36 static int
37 find_free_ldt_index () {
38   struct ssd ssd;
39   int usage[65536/sizeof(int)];
40   int i;
41   FILE *fp;
42
43   memset(usage, 0, sizeof(usage));
44
45   fp = fopen("/proc/self/ldt", "r");
46
47   if (fp == NULL) {
48     lose("Couldn't open /proc/self/ldt");
49   }
50
51   while (fread(&ssd, sizeof(ssd), 1, fp) == 1) {
52     int index = ssd.sel >> 3;
53     if (index >= 65536) {
54       lose("segment selector index too large: %d", index);
55     }
56
57     usage[index / sizeof(int)] |= 1 << (index & (sizeof(int)-1));
58   }
59
60   fclose(fp);
61
62   /* Magic number 7 is the first LDT index that Solaris leaves free. */
63   for (i = 7; i < 65536; i++) {
64     if (~usage[i / sizeof(int)] & (1 << (i & (sizeof(int)-1)))) {
65       return i;
66     }
67   }
68
69   lose("Couldn't find a free LDT index");
70 }
71
72 static int
73 install_segment (unsigned long start, unsigned long size) {
74     int selector;
75
76     thread_mutex_lock(&modify_ldt_lock);
77
78     selector = ldt_index_selector(find_free_ldt_index());
79     struct ssd ssd = { selector,
80                        start,
81                        size,
82                        0xf2,
83                        0x4};
84     if (sysi86(SI86DSCR, &ssd) < 0) {
85         lose("Couldn't install segment for thread-local data");
86     }
87
88     thread_mutex_unlock(&modify_ldt_lock);
89
90     return selector;
91 }
92 #endif
93
94 int arch_os_thread_init(struct thread *thread) {
95   stack_t sigstack;
96
97 #ifdef LISP_FEATURE_SB_THREAD
98   int sel = install_segment((unsigned long) thread, dynamic_values_bytes);
99
100   FSHOW_SIGNAL((stderr, "/ TLS: Allocated LDT %x\n", sel));
101   __asm__ __volatile__ ("mov %0, %%fs" : : "r"(sel));
102
103   thread->tls_cookie = sel;
104   pthread_setspecific(specials,thread);
105 #endif
106
107 #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
108     /* Signal handlers are run on the control stack, so if it is exhausted
109      * we had better use an alternate stack for whatever signal tells us
110      * we've exhausted it */
111     sigstack.ss_sp=((void *) thread)+dynamic_values_bytes;
112     sigstack.ss_flags=0;
113     sigstack.ss_size = 32*SIGSTKSZ;
114     sigaltstack(&sigstack,0);
115 #endif
116      return 1;                   /* success */
117 }
118
119 int arch_os_thread_cleanup(struct thread *thread) {
120 #if defined(LISP_FEATURE_SB_THREAD)
121     int n = thread->tls_cookie;
122     struct ssd delete = { n, 0, 0, 0, 0};
123
124     /* Set the %%fs register back to 0 and free the the ldt
125      * by setting it to NULL.
126      */
127     FSHOW_SIGNAL((stderr, "/ TLS: Freeing LDT %x\n", n));
128
129     __asm__ __volatile__ ("mov %0, %%fs" : : "r"(0));
130
131     thread_mutex_lock(&modify_ldt_lock);
132     if (sysi86(SI86DSCR, &delete) < 0) {
133       lose("Couldn't remove segment\n");
134     }
135     thread_mutex_unlock(&modify_ldt_lock);
136 #endif
137     return 1;                   /* success */
138 }
139
140 os_context_register_t   *
141 os_context_register_addr(os_context_t *context, int offset)
142 {
143     /* Solaris x86 holds %esp value in UESP */
144     switch(offset) {
145     case reg_EAX: return &context->uc_mcontext.gregs[11];
146     case reg_ECX: return &context->uc_mcontext.gregs[10];
147     case reg_EDX: return &context->uc_mcontext.gregs[9];
148     case reg_EBX: return &context->uc_mcontext.gregs[8];
149     case reg_ESP: return &context->uc_mcontext.gregs[17]; /* REG_UESP */
150     case reg_EBP: return &context->uc_mcontext.gregs[6];
151     case reg_ESI: return &context->uc_mcontext.gregs[5];
152     case reg_EDI: return &context->uc_mcontext.gregs[4];
153     default: return 0;
154     }
155     return &context->uc_mcontext.gregs[offset];
156 }
157
158 os_context_register_t *
159 os_context_pc_addr(os_context_t *context)
160 {
161     return &(context->uc_mcontext.gregs[14]); /* REG_EIP */
162 }
163
164 os_context_register_t *
165 os_context_sp_addr(os_context_t *context)
166 {
167     return &(context->uc_mcontext.gregs[17]); /* REG_UESP */
168 }
169
170 sigset_t *
171 os_context_sigmask_addr(os_context_t *context)
172 {
173     return &(context->uc_sigmask);
174 }
175
176 void os_flush_icache(os_vm_address_t address, os_vm_size_t length)
177 {
178 }
179
180 unsigned long
181 os_context_fp_control(os_context_t *context)
182 {
183     int *state = context->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state;
184     /* The STATE array is in the format used by the x86 instruction FNSAVE,
185      * so the FPU control word is in the first 16 bits */
186     int cw = (state[0] & 0xffff);
187     int sw = context->uc_mcontext.fpregs.fp_reg_set.fpchip_state.status;
188     return (cw ^ 0x3f) | (sw << 16);
189 }