![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to system_call.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / kernel|
Return to system_call.s CVS log | Up to [Early Linux] / linux / kernel |
1.1 root 1: /*
2: * system_call.s contains the system-call low-level handling routines.
3: * This also contains the timer-interrupt handler, as some of the code is
4: * the same. The hd-interrupt is also here.
5: *
6: * NOTE: This code handles signal-recognition, which happens every time
7: * after a timer-interrupt and after each system call. Ordinary interrupts
8: * don't handle signal-recognition, as that would clutter them up totally
9: * unnecessarily.
10: *
11: * Stack layout in 'ret_from_system_call':
12: *
13: * 0(%esp) - %eax
14: * 4(%esp) - %ebx
15: * 8(%esp) - %ecx
16: * C(%esp) - %edx
17: * 10(%esp) - %fs
18: * 14(%esp) - %es
19: * 18(%esp) - %ds
20: * 1C(%esp) - %eip
21: * 20(%esp) - %cs
22: * 24(%esp) - %eflags
23: * 28(%esp) - %oldesp
24: * 2C(%esp) - %oldss
25: */
26:
27: SIG_CHLD = 17
28: EAX = 0x00
29: EBX = 0x04
30: ECX = 0x08
31: EDX = 0x0C
32: FS = 0x10
33: ES = 0x14
34: DS = 0x18
35: EIP = 0x1C
36: CS = 0x20
37: EFLAGS = 0x24
38: OLDESP = 0x28
39: OLDSS = 0x2C
40:
41: state = 0 # these are offsets into the task-struct.
42: counter = 4
43: priority = 8
44: signal = 12
45: restorer = 16 # address of info-restorer
46: sig_fn = 20 # table of 32 signal addresses
47:
48: nr_system_calls = 67
49:
50: .globl _system_call,_sys_fork,_timer_interrupt,_hd_interrupt,_sys_execve
51:
52: .align 2
53: bad_sys_call:
54: movl $-1,%eax
55: iret
56: .align 2
57: reschedule:
58: pushl $ret_from_sys_call
59: jmp _schedule
60: .align 2
61: _system_call:
62: cmpl $nr_system_calls-1,%eax
63: ja bad_sys_call
64: push %ds
65: push %es
66: push %fs
67: pushl %edx
68: pushl %ecx # push %ebx,%ecx,%edx as parameters
69: pushl %ebx # to the system call
70: movl $0x10,%edx # set up ds,es to kernel space
71: mov %dx,%ds
72: mov %dx,%es
73: movl $0x17,%edx # fs points to local data space
74: mov %dx,%fs
75: call _sys_call_table(,%eax,4)
76: pushl %eax
77: movl _current,%eax
78: cmpl $0,state(%eax) # state
79: jne reschedule
80: cmpl $0,counter(%eax) # counter
81: je reschedule
82: ret_from_sys_call:
83: movl _current,%eax # task[0] cannot have signals
84: cmpl _task,%eax
85: je 3f
86: movl CS(%esp),%ebx # was old code segment supervisor
87: testl $3,%ebx # mode? If so - don't check signals
88: je 3f
89: cmpw $0x17,OLDSS(%esp) # was stack segment = 0x17 ?
90: jne 3f
91: 2: movl signal(%eax),%ebx # signals (bitmap, 32 signals)
92: bsfl %ebx,%ecx # %ecx is signal nr, return if none
93: je 3f
94: btrl %ecx,%ebx # clear it
95: movl %ebx,signal(%eax)
96: movl sig_fn(%eax,%ecx,4),%ebx # %ebx is signal handler address
97: cmpl $1,%ebx
98: jb default_signal # 0 is default signal handler - exit
99: je 2b # 1 is ignore - find next signal
100: movl $0,sig_fn(%eax,%ecx,4) # reset signal handler address
101: incl %ecx
102: xchgl %ebx,EIP(%esp) # put new return address on stack
103: subl $28,OLDESP(%esp)
104: movl OLDESP(%esp),%edx # push old return address on stack
105: pushl %eax # but first check that it's ok.
106: pushl %ecx
107: pushl $28
108: pushl %edx
109: call _verify_area
110: popl %edx
111: addl $4,%esp
112: popl %ecx
113: popl %eax
114: movl restorer(%eax),%eax
115: movl %eax,%fs:(%edx) # flag/reg restorer
116: movl %ecx,%fs:4(%edx) # signal nr
117: movl EAX(%esp),%eax
118: movl %eax,%fs:8(%edx) # old eax
119: movl ECX(%esp),%eax
120: movl %eax,%fs:12(%edx) # old ecx
121: movl EDX(%esp),%eax
122: movl %eax,%fs:16(%edx) # old edx
123: movl EFLAGS(%esp),%eax
124: movl %eax,%fs:20(%edx) # old eflags
125: movl %ebx,%fs:24(%edx) # old return addr
126: 3: popl %eax
127: popl %ebx
128: popl %ecx
129: popl %edx
130: pop %fs
131: pop %es
132: pop %ds
133: iret
134:
135: default_signal:
136: incl %ecx
137: cmpl $SIG_CHLD,%ecx
138: je 2b
139: pushl %ecx
140: call _do_exit # remember to set bit 7 when dumping core
141: addl $4,%esp
142: jmp 3b
143:
144: .align 2
145: _timer_interrupt:
146: push %ds # save ds,es and put kernel data space
147: push %es # into them. %fs is used by _system_call
148: push %fs
149: pushl %edx # we save %eax,%ecx,%edx as gcc doesn't
150: pushl %ecx # save those across function calls. %ebx
151: pushl %ebx # is saved as we use that in ret_sys_call
152: pushl %eax
153: movl $0x10,%eax
154: mov %ax,%ds
155: mov %ax,%es
156: movl $0x17,%eax
157: mov %ax,%fs
158: incl _jiffies
159: movb $0x20,%al # EOI to interrupt controller #1
160: outb %al,$0x20
161: movl CS(%esp),%eax
162: andl $3,%eax # %eax is CPL (0 or 3, 0=supervisor)
163: pushl %eax
164: call _do_timer # 'do_timer(long CPL)' does everything from
165: addl $4,%esp # task switching to accounting ...
166: jmp ret_from_sys_call
167:
168: .align 2
169: _sys_execve:
170: lea EIP(%esp),%eax
171: pushl %eax
172: call _do_execve
173: addl $4,%esp
174: ret
175:
176: .align 2
177: _sys_fork:
178: call _find_empty_process
179: testl %eax,%eax
180: js 1f
181: push %gs
182: pushl %esi
183: pushl %edi
184: pushl %ebp
185: pushl %eax
186: call _copy_process
187: addl $20,%esp
188: 1: ret
189:
190: _hd_interrupt:
191: pushl %eax
192: pushl %ecx
193: pushl %edx
194: push %ds
195: push %es
196: push %fs
197: movl $0x10,%eax
198: mov %ax,%ds
199: mov %ax,%es
200: movl $0x17,%eax
201: mov %ax,%fs
202: movb $0x20,%al
203: outb %al,$0x20 # EOI to interrupt controller #1
204: jmp 1f # give port chance to breathe
205: 1: jmp 1f
206: 1: outb %al,$0xA0 # same to controller #2
207: movl _do_hd,%eax
208: testl %eax,%eax
209: jne 1f
210: movl $_unexpected_hd_interrupt,%eax
211: 1: call *%eax # "interesting" way of handling intr.
212: pop %fs
213: pop %es
214: pop %ds
215: popl %edx
216: popl %ecx
217: popl %eax
218: iret
219:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.