0.9.13.22:
[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 #endif
31
32 static int
33 ldt_index_selector (int index) {
34   return index << 3 | 7;
35 }
36
37 static int
38 find_free_ldt_index () {
39   struct ssd ssd;
40   int usage[65536/sizeof(int)];
41   int i;
42   FILE *fp;
43
44   memset(usage, 0, sizeof(usage));
45
46   fp = fopen("/proc/self/ldt", "r");
47
48   if (fp == NULL) {
49     lose("Couldn't open /proc/self/ldt");
50   }
51
52   while (fread(&ssd, sizeof(ssd), 1, fp) == 1) {
53     int index = ssd.sel >> 3;
54     if (index >= 65536) {
55       lose("segment selector index too large: %d", index);
56     }
57
58     usage[index / sizeof(int)] |= 1 << (index & (sizeof(int)-1));
59   }
60
61   fclose(fp);
62
63   /* Magic number 7 is the first LDT index that Solaris leaves free. */
64   for (i = 7; i < 65536; i++) {
65     if (~usage[i / sizeof(int)] & (1 << (i & (sizeof(int)-1)))) {
66       return i;
67     }
68   }
69
70   lose("Couldn't find a free LDT index");
71 }
72
73 static int
74 install_segment (unsigned long start, unsigned long size) {
75     int selector;
76
77     thread_mutex_lock(&modify_ldt_lock);
78
79     selector = ldt_index_selector(find_free_ldt_index());
80     struct ssd ssd = { selector,
81                        start,
82                        size,
83                        0xf2,
84                        0x4};
85     if (sysi86(SI86DSCR, &ssd) < 0) {
86         lose("Couldn't install segment for thread-local data");
87     }
88
89     thread_mutex_unlock(&modify_ldt_lock);
90
91     return selector;
92 }
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 }