up vote 30 down vote favorite
10

I study the Linux Kernel and found out that for x86_64 architecture the interrupt int 0x80 doesn't work as calling for system call.

The question is: in case of x86 architecture what is more preferable syscall or int 0x80 and why?

EDIT: I use the kernel 3.4

share|improve this question
    
Where are you looking in the kernel that you're seeing the use of int 0x80? Can you specify some files? – Mike Oct 9 '12 at 19:01
    
@Mike Actually I found a kind of tutorial into linux kernel where as an example it was used. It was 2.6 based. – Alex Oct 9 '12 at 19:03
    
Similar to stackoverflow.com/q/12776340/841108 question – Basile Starynkevitch Oct 9 '12 at 19:11
    
How is this "not a real question"? – Raymond Hettinger Jul 24 '13 at 5:15
1  
@RaymondHettinger Don't know. – Alex Jul 24 '13 at 6:15
up vote 41 down vote accepted
  • syscall is default way of entering kernel mode on x86-64. This instruction is not available in 32 bit modes of operation on Intel processors.
  • sysenter is an instruction most frequently used to invoke system calls in 32 bit modes of operation. It is similar to syscall, a bit more difficult to use though, but that is kernel's concern.
  • int 0x80 is a legacy way to invoke a system call and should be avoided.

Preferable way to invoke a system call is to use VDSO, a part of memory mapped in each process address space that allow to use system calls more efficiently (for example, by not entering kernel mode in some cases at all). VDSO also takes care of more difficult, in comparison to the legacy int 0x80 way, handling of syscall or sysenter instructions.

Also, see this and this.

share|improve this answer
3  
The recommendation to choose one over the other is for OS kernel developers. Their choice is then made part of the ABI, and if you are developing for a certain OS, you must honour that ABI. For example, Linux/i386 uses int 0x80 and passes arguments in registers, whereas MirBSD/i386 uses int 0x80 and passes arguments on the stack, with one frame pointer in between (which means no setup cost in userspace when using cdecl). [This answer is mostly for people who get sent here but are not OS kernel designers.] – mirabilos Dec 6 '13 at 21:09
1  
The question was about Linux and the answer describes possible means of invoking a syscall on Linux (both i386 and x86_64). You suggest that Linux/i386 uses only int 0x80 which is not true. The preferable way to make a syscall is to use VDSO. – Paweł Dziepak Dec 11 '13 at 0:27
up vote 16 down vote

My answer here covers your question.

In practice, recent kernels are implementing a VDSO, notably to dynamically optimize system calls (the kernel sets the VDSO to some code best for the current processor). So you should use the VDSO, and you'll better use, for existing syscalls, the interface provided by the libc.

Notice that, AFAIK, a significant part of the cost of simple syscalls is going from user-space to kernel and back. Hence, for some syscalls (probably gettimeofday, getpid ...) the VDSO might avoid even that (and technically might avoid doing a real syscall). For most syscalls (like open, read, send, mmap ....) the kernel cost of the syscall is large enough to make any improvement of the user-space to kernel space transition (e.g. using SYSENTER or SYSCALL machine instructions instead of INT) insignificant.

share|improve this answer
11  
Back in the 80386 days, the fastest way to enter the kernel was actually to execute an invalid instruction. – Adam Rosenfield Oct 9 '12 at 19:21
up vote 3 down vote

Beware of this before changing : system call numbers differ when doing 0x80 or syscall, e.g sys_write is 4 with 0x80 and 1 with syscall.

http://docs.cs.up.ac.za/programming/asm/derick_tut/syscalls.html for 32 bits or 0x80 http://blog.rchapman.org/post/36801038863/linux-system-call-table-for-x86-64 for syscall

share|improve this answer
up vote -3 down vote

int 0x80 is a better terminology to indicate its a system call to the kernel to tell it to do something.

The meaning and interpretation are interchangeble, 'make a syscall' or 'issue int 80h'.

It is no different to the days of DOS:

  • invoke int 21h to get DOS to do something depedning on the AX register and optionally ES:DX register pair,
  • int 13h is the BIOS hard disk handler.
  • int 10h is the EGA/VGA screen.
  • int 09h is the keyboard handler.

What is the common theme here is this, when a interrupt/syscall is invoked, the kernel checks the state of the registers to see what type of system call is required. By looking at for example, eax register, for example, and determine what to perform, internally context switches into kernel space, carry out the procedure and context switch back to user-space, with an option to return back the results of the call, i.e. was it successful or was it in failure.

share|improve this answer
4  
Actually, x86_64 instruction set has a syscall instruction. In this respect, int 0x80 is only used for a system call in a 32-bit Linux environment. – John Ledbetter Oct 9 '12 at 19:15
1  
Well, in fairness, OP should have made it clearer x86 architecture what is more preferable syscall or int 0x80 - it was ambiguous as the OP referred to x86-64 and from that context, was implying 32bit...which made my answer somewhat go astray or interrupted exception :P – t0mm13b Oct 9 '12 at 19:24

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.