This source file includes following definitions.
- disable_hlt
- enable_hlt
- hard_idle
- sys_idle
- sys_idle
- cpu_idle
- kb_wait
- hard_reset_now
- show_regs
- exit_thread
- flush_thread
- release_thread
- copy_thread
- dump_fpu
- dump_thread
- sys_fork
- sys_clone
- sys_execve
1
2
3
4
5
6
7
8
9
10
11 #define __KERNEL_SYSCALLS__
12 #include <stdarg.h>
13
14 #include <linux/errno.h>
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/mm.h>
18 #include <linux/stddef.h>
19 #include <linux/unistd.h>
20 #include <linux/ptrace.h>
21 #include <linux/malloc.h>
22 #include <linux/ldt.h>
23 #include <linux/user.h>
24 #include <linux/a.out.h>
25 #include <linux/interrupt.h>
26 #include <linux/config.h>
27 #include <linux/unistd.h>
28
29 #include <asm/segment.h>
30 #include <asm/pgtable.h>
31 #include <asm/system.h>
32 #include <asm/io.h>
33 #include <linux/smp.h>
34
35
36 asmlinkage void ret_from_sys_call(void) __asm__("ret_from_sys_call");
37
38 #ifdef CONFIG_APM
39 extern int apm_do_idle(void);
40 extern void apm_do_busy(void);
41 #endif
42
43 static int hlt_counter=0;
44
45 #define HARD_IDLE_TIMEOUT (HZ / 3)
46
47 void disable_hlt(void)
48 {
49 hlt_counter++;
50 }
51
52 void enable_hlt(void)
53 {
54 hlt_counter--;
55 }
56
57 #ifndef __SMP__
58
59 static void hard_idle(void)
60 {
61 while (!need_resched) {
62 if (hlt_works_ok && !hlt_counter) {
63 #ifdef CONFIG_APM
64
65
66
67
68
69 start_bh_atomic();
70 if (!apm_do_idle() && !need_resched)
71 __asm__("hlt");
72 end_bh_atomic();
73 #else
74 __asm__("hlt");
75 #endif
76 }
77 if (need_resched)
78 break;
79 schedule();
80 }
81 #ifdef CONFIG_APM
82 apm_do_busy();
83 #endif
84 }
85
86
87
88
89
90 asmlinkage int sys_idle(void)
91 {
92 unsigned long start_idle = 0;
93
94 if (current->pid != 0)
95 return -EPERM;
96
97 current->counter = -100;
98 for (;;)
99 {
100
101
102
103
104
105 if (!start_idle)
106 start_idle = jiffies;
107 if (jiffies - start_idle > HARD_IDLE_TIMEOUT)
108 {
109 hard_idle();
110 }
111 else
112 {
113 if (hlt_works_ok && !hlt_counter && !need_resched)
114 __asm__("hlt");
115 }
116 if (need_resched)
117 start_idle = 0;
118 schedule();
119 }
120 }
121
122 #else
123
124
125
126
127
128
129 asmlinkage int sys_idle(void)
130 {
131 if(current->pid != 0)
132 return -EPERM;
133 #ifdef __SMP_PROF__
134 smp_spins_sys_idle[smp_processor_id()]+=
135 smp_spins_syscall_cur[smp_processor_id()];
136 #endif
137 current->counter= -100;
138 schedule();
139 return 0;
140 }
141
142
143
144
145
146 int cpu_idle(void *unused)
147 {
148 while(1)
149 {
150 if(cpu_data[smp_processor_id()].hlt_works_ok && !hlt_counter && !need_resched)
151 __asm("hlt");
152 if(0==(0x7fffffff & smp_process_available))
153 continue;
154 while(0x80000000 & smp_process_available);
155 cli();
156 while(set_bit(31,&smp_process_available))
157 while(test_bit(31,&smp_process_available))
158 {
159
160
161
162 if(clear_bit(smp_processor_id(), &smp_invalidate_needed))
163 local_flush_tlb();
164 }
165 if (0==(0x7fffffff & smp_process_available)){
166 clear_bit(31,&smp_process_available);
167 sti();
168 continue;
169 }
170 smp_process_available--;
171 clear_bit(31,&smp_process_available);
172 sti();
173 idle();
174 }
175 }
176
177 #endif
178
179
180
181
182
183
184 static long no_idt[2] = {0, 0};
185
186 static inline void kb_wait(void)
187 {
188 int i;
189
190 for (i=0; i<0x10000; i++)
191 if ((inb_p(0x64) & 0x02) == 0)
192 break;
193 }
194
195 void hard_reset_now(void)
196 {
197 int i, j;
198
199 sti();
200
201 pg0[0] = 7;
202 *((unsigned short *)0x472) = 0x1234;
203 for (;;) {
204 for (i=0; i<100; i++) {
205 kb_wait();
206 for(j = 0; j < 100000 ; j++)
207 ;
208 outb(0xfe,0x64);
209 }
210 __asm__ __volatile__("\tlidt %0": "=m" (no_idt));
211 }
212 }
213
214 void show_regs(struct pt_regs * regs)
215 {
216 printk("\n");
217 printk("EIP: %04x:[<%08lx>]",0xffff & regs->cs,regs->eip);
218 if (regs->cs & 3)
219 printk(" ESP: %04x:%08lx",0xffff & regs->ss,regs->esp);
220 printk(" EFLAGS: %08lx\n",regs->eflags);
221 printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
222 regs->eax,regs->ebx,regs->ecx,regs->edx);
223 printk("ESI: %08lx EDI: %08lx EBP: %08lx",
224 regs->esi, regs->edi, regs->ebp);
225 printk(" DS: %04x ES: %04x FS: %04x GS: %04x\n",
226 0xffff & regs->ds,0xffff & regs->es,
227 0xffff & regs->fs,0xffff & regs->gs);
228 }
229
230
231
232
233
234 void exit_thread(void)
235 {
236
237 if (last_task_used_math == current)
238 last_task_used_math = NULL;
239
240 __asm__ __volatile__("mov %w0,%%fs ; mov %w0,%%gs ; lldt %w0"
241 :
242 : "r" (0));
243 current->tss.ldt = 0;
244 if (current->ldt) {
245 void * ldt = current->ldt;
246 current->ldt = NULL;
247 vfree(ldt);
248 }
249 }
250
251 void flush_thread(void)
252 {
253 int i;
254
255 if (current->ldt) {
256 free_page((unsigned long) current->ldt);
257 current->ldt = NULL;
258 for (i=1 ; i<NR_TASKS ; i++) {
259 if (task[i] == current) {
260 set_ldt_desc(gdt+(i<<1)+
261 FIRST_LDT_ENTRY,&default_ldt, 1);
262 load_ldt(i);
263 }
264 }
265 }
266
267 for (i=0 ; i<8 ; i++)
268 current->debugreg[i] = 0;
269
270
271
272
273 #ifdef __SMP__
274 if (current->flags & PF_USEDFPU) {
275 stts();
276 }
277 #else
278 if (last_task_used_math == current) {
279 last_task_used_math = NULL;
280 stts();
281 }
282 #endif
283 current->used_math = 0;
284 current->flags &= ~PF_USEDFPU;
285 }
286
287 void release_thread(struct task_struct *dead_task)
288 {
289 }
290
291 void copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
292 struct task_struct * p, struct pt_regs * regs)
293 {
294 int i;
295 struct pt_regs * childregs;
296
297 p->tss.es = KERNEL_DS;
298 p->tss.cs = KERNEL_CS;
299 p->tss.ss = KERNEL_DS;
300 p->tss.ds = KERNEL_DS;
301 p->tss.fs = USER_DS;
302 p->tss.gs = KERNEL_DS;
303 p->tss.ss0 = KERNEL_DS;
304 p->tss.esp0 = p->kernel_stack_page + PAGE_SIZE;
305 p->tss.tr = _TSS(nr);
306 childregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
307 p->tss.esp = (unsigned long) childregs;
308 p->tss.eip = (unsigned long) ret_from_sys_call;
309 *childregs = *regs;
310 childregs->eax = 0;
311 childregs->esp = esp;
312 p->tss.back_link = 0;
313 p->tss.eflags = regs->eflags & 0xffffcfff;
314 p->tss.ldt = _LDT(nr);
315 if (p->ldt) {
316 p->ldt = (struct desc_struct*) vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE);
317 if (p->ldt != NULL)
318 memcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
319 }
320 set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
321 if (p->ldt)
322 set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,p->ldt, 512);
323 else
324 set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&default_ldt, 1);
325 p->tss.bitmap = offsetof(struct thread_struct,io_bitmap);
326 for (i = 0; i < IO_BITMAP_SIZE+1 ; i++)
327 p->tss.io_bitmap[i] = ~0;
328 if (last_task_used_math == current)
329 __asm__("clts ; fnsave %0 ; frstor %0":"=m" (p->tss.i387));
330 }
331
332
333
334
335 int dump_fpu (struct user_i387_struct* fpu)
336 {
337 int fpvalid;
338
339
340
341 if (hard_math) {
342 if ((fpvalid = current->used_math) != 0) {
343 if (last_task_used_math == current)
344 __asm__("clts ; fnsave %0": :"m" (*fpu));
345 else
346 memcpy(fpu,¤t->tss.i387.hard,sizeof(*fpu));
347 }
348 } else {
349
350
351 fpvalid = 0;
352 }
353
354 return fpvalid;
355 }
356
357
358
359
360 void dump_thread(struct pt_regs * regs, struct user * dump)
361 {
362 int i;
363
364
365 dump->magic = CMAGIC;
366 dump->start_code = 0;
367 dump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
368 dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
369 dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
370 dump->u_dsize -= dump->u_tsize;
371 dump->u_ssize = 0;
372 for (i = 0; i < 8; i++)
373 dump->u_debugreg[i] = current->debugreg[i];
374
375 if (dump->start_stack < TASK_SIZE)
376 dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
377
378 dump->regs = *regs;
379
380 dump->u_fpvalid = dump_fpu (&dump->i387);
381 }
382
383 asmlinkage int sys_fork(struct pt_regs regs)
384 {
385 return do_fork(SIGCHLD, regs.esp, ®s);
386 }
387
388 asmlinkage int sys_clone(struct pt_regs regs)
389 {
390 unsigned long clone_flags;
391 unsigned long newsp;
392
393 clone_flags = regs.ebx;
394 newsp = regs.ecx;
395 if (!newsp)
396 newsp = regs.esp;
397 return do_fork(clone_flags, newsp, ®s);
398 }
399
400
401
402
403 asmlinkage int sys_execve(struct pt_regs regs)
404 {
405 int error;
406 char * filename;
407
408 error = getname((char *) regs.ebx, &filename);
409 if (error)
410 return error;
411 error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, ®s);
412 putname(filename);
413 return error;
414 }