System calls : difference between sys_exit(), SYS_exit and exit()

What is the difference between SYS_exit, sys_exit() and exit()?

What I understand :

• The linux kernel provides system calls, which are listed in man 2 syscalls.
• There are wrapper functions of those syscalls provided by glibc which have mostly similar names as the syscalls.

My question : In man 2 syscalls, there is no mention of SYS_exit and sys_exit(), for example. What are they?

Note : The syscall exit here is only an example. My question really is : What are SYS_xxx and sys_xxx()?

Answer

I’ll use exit() as in your example although this applies to all system calls.

The functions of the form sys_exit() are the actual entry points to the kernel routine that implements the function you think of as exit(). These symbols are not even available to user-mode programmers. That is, unless you are hacking the kernel, you cannot link to these functions because their symbols are not available outside the kernel. If I wrote libmsw.a which had a file scope function like

static int msw_func() {}

defined in it, you would have no success trying to link to it because it is not exported in the libmsw symbol table; that is:

cc your_program.c libmsw.a

would yield an error like:

ld: cannot resolve symbol msw_func

because it isn’t exported; the same applies for sys_exit() as contained in the kernel.

In order for a user program to get to kernel routines, the syscall(2) interface needs to be used to effect a switch from user-mode to kernel mode. When that mode-switch (somtimes called a trap) occurs a small integer is used to look up the proper kernel routine in a kernel table that maps integers to kernel functions. An entry in the table has the form

{SYS_exit, sys_exit},

Where SYS_exit is an preprocessor macro which is

#define SYS_exit (1)

and has been 1 since before you were born because there hasn’t been reason to change it. It also happens to be the first entry in the table of system calls which makes look up a simple array index.

As you note in your question, the proper way for a regular user-mode program to access sys_exit is through the thin wrapper in glibc (or similar core library). The only reason you’d ever need to mess with SYS_exit or sys_exit is if you were writing kernel code.