![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_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 sys_call.s CVS log | Up to [Early Linux] / linux / kernel |
1.1 ! root 1: /* ! 2: * linux/kernel/system_call.s ! 3: * ! 4: * (C) 1991 Linus Torvalds ! 5: */ ! 6: ! 7: /* ! 8: * system_call.s contains the system-call low-level handling routines. ! 9: * This also contains the timer-interrupt handler, as some of the code is ! 10: * the same. The hd- and flopppy-interrupts are also here. ! 11: * ! 12: * NOTE: This code handles signal-recognition, which happens every time ! 13: * after a timer-interrupt and after each system call. Ordinary interrupts ! 14: * don't handle signal-recognition, as that would clutter them up totally ! 15: * unnecessarily. ! 16: * ! 17: * Stack layout in 'ret_from_system_call': ! 18: * ! 19: * 0(%esp) - %eax ! 20: * 4(%esp) - %ebx ! 21: * 8(%esp) - %ecx ! 22: * C(%esp) - %edx ! 23: * 10(%esp) - original %eax (-1 if not system call) ! 24: * 14(%esp) - %fs ! 25: * 18(%esp) - %es ! 26: * 1C(%esp) - %ds ! 27: * 20(%esp) - %eip ! 28: * 24(%esp) - %cs ! 29: * 28(%esp) - %eflags ! 30: * 2C(%esp) - %oldesp ! 31: * 30(%esp) - %oldss ! 32: */ ! 33: ! 34: SIG_CHLD = 17 ! 35: ! 36: EAX = 0x00 ! 37: EBX = 0x04 ! 38: ECX = 0x08 ! 39: EDX = 0x0C ! 40: ORIG_EAX = 0x10 ! 41: FS = 0x14 ! 42: ES = 0x18 ! 43: DS = 0x1C ! 44: EIP = 0x20 ! 45: CS = 0x24 ! 46: EFLAGS = 0x28 ! 47: OLDESP = 0x2C ! 48: OLDSS = 0x30 ! 49: ! 50: state = 0 # these are offsets into the task-struct. ! 51: counter = 4 ! 52: priority = 8 ! 53: signal = 12 ! 54: sigaction = 16 # MUST be 16 (=len of sigaction) ! 55: blocked = (33*16) ! 56: ! 57: # offsets within sigaction ! 58: sa_handler = 0 ! 59: sa_mask = 4 ! 60: sa_flags = 8 ! 61: sa_restorer = 12 ! 62: ! 63: nr_system_calls = 82 ! 64: ! 65: ENOSYS = 38 ! 66: ! 67: /* ! 68: * Ok, I get parallel printer interrupts while using the floppy for some ! 69: * strange reason. Urgel. Now I just ignore them. ! 70: */ ! 71: .globl _system_call,_sys_fork,_timer_interrupt,_sys_execve ! 72: .globl _hd_interrupt,_floppy_interrupt,_parallel_interrupt ! 73: .globl _device_not_available, _coprocessor_error ! 74: ! 75: .align 2 ! 76: bad_sys_call: ! 77: pushl $-ENOSYS ! 78: jmp ret_from_sys_call ! 79: .align 2 ! 80: reschedule: ! 81: pushl $ret_from_sys_call ! 82: jmp _schedule ! 83: .align 2 ! 84: _system_call: ! 85: push %ds ! 86: push %es ! 87: push %fs ! 88: pushl %eax # save the orig_eax ! 89: pushl %edx ! 90: pushl %ecx # push %ebx,%ecx,%edx as parameters ! 91: pushl %ebx # to the system call ! 92: movl $0x10,%edx # set up ds,es to kernel space ! 93: mov %dx,%ds ! 94: mov %dx,%es ! 95: movl $0x17,%edx # fs points to local data space ! 96: mov %dx,%fs ! 97: cmpl _NR_syscalls,%eax ! 98: jae bad_sys_call ! 99: call _sys_call_table(,%eax,4) ! 100: pushl %eax ! 101: 2: ! 102: movl _current,%eax ! 103: cmpl $0,state(%eax) # state ! 104: jne reschedule ! 105: cmpl $0,counter(%eax) # counter ! 106: je reschedule ! 107: ret_from_sys_call: ! 108: movl _current,%eax ! 109: cmpl _task,%eax # task[0] cannot have signals ! 110: je 3f ! 111: cmpw $0x0f,CS(%esp) # was old code segment supervisor ? ! 112: jne 3f ! 113: cmpw $0x17,OLDSS(%esp) # was stack segment = 0x17 ? ! 114: jne 3f ! 115: movl signal(%eax),%ebx ! 116: movl blocked(%eax),%ecx ! 117: notl %ecx ! 118: andl %ebx,%ecx ! 119: bsfl %ecx,%ecx ! 120: je 3f ! 121: btrl %ecx,%ebx ! 122: movl %ebx,signal(%eax) ! 123: incl %ecx ! 124: pushl %ecx ! 125: call _do_signal ! 126: popl %ecx ! 127: testl %eax, %eax ! 128: jne 2b # see if we need to switch tasks, or do more signals ! 129: 3: popl %eax ! 130: popl %ebx ! 131: popl %ecx ! 132: popl %edx ! 133: addl $4, %esp # skip orig_eax ! 134: pop %fs ! 135: pop %es ! 136: pop %ds ! 137: iret ! 138: ! 139: .align 2 ! 140: _coprocessor_error: ! 141: push %ds ! 142: push %es ! 143: push %fs ! 144: pushl $-1 # fill in -1 for orig_eax ! 145: pushl %edx ! 146: pushl %ecx ! 147: pushl %ebx ! 148: pushl %eax ! 149: movl $0x10,%eax ! 150: mov %ax,%ds ! 151: mov %ax,%es ! 152: movl $0x17,%eax ! 153: mov %ax,%fs ! 154: pushl $ret_from_sys_call ! 155: jmp _math_error ! 156: ! 157: .align 2 ! 158: _device_not_available: ! 159: push %ds ! 160: push %es ! 161: push %fs ! 162: pushl $-1 # fill in -1 for orig_eax ! 163: pushl %edx ! 164: pushl %ecx ! 165: pushl %ebx ! 166: pushl %eax ! 167: movl $0x10,%eax ! 168: mov %ax,%ds ! 169: mov %ax,%es ! 170: movl $0x17,%eax ! 171: mov %ax,%fs ! 172: pushl $ret_from_sys_call ! 173: clts # clear TS so that we can use math ! 174: movl %cr0,%eax ! 175: testl $0x4,%eax # EM (math emulation bit) ! 176: je _math_state_restore ! 177: pushl %ebp ! 178: pushl %esi ! 179: pushl %edi ! 180: pushl $0 # temporary storage for ORIG_EIP ! 181: call _math_emulate ! 182: addl $4,%esp ! 183: popl %edi ! 184: popl %esi ! 185: popl %ebp ! 186: ret ! 187: ! 188: .align 2 ! 189: _timer_interrupt: ! 190: push %ds # save ds,es and put kernel data space ! 191: push %es # into them. %fs is used by _system_call ! 192: push %fs ! 193: pushl $-1 # fill in -1 for orig_eax ! 194: pushl %edx # we save %eax,%ecx,%edx as gcc doesn't ! 195: pushl %ecx # save those across function calls. %ebx ! 196: pushl %ebx # is saved as we use that in ret_sys_call ! 197: pushl %eax ! 198: movl $0x10,%eax ! 199: mov %ax,%ds ! 200: mov %ax,%es ! 201: movl $0x17,%eax ! 202: mov %ax,%fs ! 203: incl _jiffies ! 204: movb $0x20,%al # EOI to interrupt controller #1 ! 205: outb %al,$0x20 ! 206: movl CS(%esp),%eax ! 207: andl $3,%eax # %eax is CPL (0 or 3, 0=supervisor) ! 208: pushl %eax ! 209: call _do_timer # 'do_timer(long CPL)' does everything from ! 210: addl $4,%esp # task switching to accounting ... ! 211: jmp ret_from_sys_call ! 212: ! 213: .align 2 ! 214: _sys_execve: ! 215: lea EIP(%esp),%eax ! 216: pushl %eax ! 217: call _do_execve ! 218: addl $4,%esp ! 219: ret ! 220: ! 221: .align 2 ! 222: _sys_fork: ! 223: call _find_empty_process ! 224: testl %eax,%eax ! 225: js 1f ! 226: push %gs ! 227: pushl %esi ! 228: pushl %edi ! 229: pushl %ebp ! 230: pushl %eax ! 231: call _copy_process ! 232: addl $20,%esp ! 233: 1: ret ! 234: ! 235: _hd_interrupt: ! 236: pushl %eax ! 237: pushl %ecx ! 238: pushl %edx ! 239: push %ds ! 240: push %es ! 241: push %fs ! 242: movl $0x10,%eax ! 243: mov %ax,%ds ! 244: mov %ax,%es ! 245: movl $0x17,%eax ! 246: mov %ax,%fs ! 247: movb $0x20,%al ! 248: outb %al,$0xA0 # EOI to interrupt controller #1 ! 249: jmp 1f # give port chance to breathe ! 250: 1: jmp 1f ! 251: 1: xorl %edx,%edx ! 252: movl %edx,_hd_timeout ! 253: xchgl _do_hd,%edx ! 254: testl %edx,%edx ! 255: jne 1f ! 256: movl $_unexpected_hd_interrupt,%edx ! 257: 1: outb %al,$0x20 ! 258: call *%edx # "interesting" way of handling intr. ! 259: pop %fs ! 260: pop %es ! 261: pop %ds ! 262: popl %edx ! 263: popl %ecx ! 264: popl %eax ! 265: iret ! 266: ! 267: _floppy_interrupt: ! 268: pushl %eax ! 269: pushl %ecx ! 270: pushl %edx ! 271: push %ds ! 272: push %es ! 273: push %fs ! 274: movl $0x10,%eax ! 275: mov %ax,%ds ! 276: mov %ax,%es ! 277: movl $0x17,%eax ! 278: mov %ax,%fs ! 279: movb $0x20,%al ! 280: outb %al,$0x20 # EOI to interrupt controller #1 ! 281: xorl %eax,%eax ! 282: xchgl _do_floppy,%eax ! 283: testl %eax,%eax ! 284: jne 1f ! 285: movl $_unexpected_floppy_interrupt,%eax ! 286: 1: call *%eax # "interesting" way of handling intr. ! 287: pop %fs ! 288: pop %es ! 289: pop %ds ! 290: popl %edx ! 291: popl %ecx ! 292: popl %eax ! 293: iret ! 294: ! 295: _parallel_interrupt: ! 296: pushl %eax ! 297: movb $0x20,%al ! 298: outb %al,$0x20 ! 299: popl %eax ! 300: iret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.