This section deals with implementation of Linux® emulation layer in FreeBSD operating system. It first describes the machine dependent part talking about how and where interaction between userland and kernel is implemented. It talks about syscalls, signals, ptrace, traps, stack fixup. This part discusses i386 but it is written generally so other architectures should not differ very much. The next part is the machine independent part of the Linuxulator. This section only covers i386 and ELF handling. A.OUT is obsolete and untested.
Syscall handling is mostly written in linux_sysvec.c, which covers most of the routines pointed out in the sysentvec structure. When a Linux process running on FreeBSD issues a syscall, the general syscall routine calls linux prepsyscall routine for the Linux ABI.
Linux passes arguments to syscalls via registers (that is why
it is limited to 6 parameters on i386) while FreeBSD uses the stack.
The Linux prepsyscall routine must copy parameters from registers
to the stack. The order of the registers is:
%ebx
, %ecx
,
%edx
, %esi
,
%edi
, %ebp
. The catch is that
this is true for only most of the syscalls.
Some (most notably clone
) uses a different
order but it is luckily easy to fix by inserting a dummy parameter
in the linux_clone
prototype.
Every syscall implemented in the Linuxulator must have its prototype with various flags in syscalls.master. The form of the file is:
... AUE_FORK STD { int linux_fork(void); } ... AUE_CLOSE NOPROTO { int close(int fd); } ...
The first column represents the syscall number. The second
column is for auditing support. The third column represents the
syscall type. It is either STD,
OBSOL, NOPROTO and
UNIMPL. STD is a standard
syscall with full prototype and implementation.
OBSOL is obsolete and defines just the prototype.
NOPROTO means that the syscall is implemented
elsewhere so do not prepend ABI prefix, etc.
UNIMPL means that the syscall will be
substituted with the nosys
syscall
(a syscall just printing out a message about the syscall not being
implemented and returning ENOSYS).
From syscalls.master a script generates three files: linux_syscall.h, linux_proto.h and linux_sysent.c. The linux_syscall.h contains definitions of syscall names and their numerical value, e.g.:
... #define LINUX_SYS_linux_fork 2 ... #define LINUX_SYS_close 6 ...
The linux_proto.h contains structure definitions of arguments to every syscall, e.g.:
struct linux_fork_args { register_t dummy; };
And finally, linux_sysent.c contains structure describing the system entry table, used to actually dispatch a syscall, e.g.:
{ 0, (sy_call_t *)linux_fork, AUE_FORK, NULL, 0, 0 }, /* 2 = linux_fork */ { AS(close_args), (sy_call_t *)close, AUE_CLOSE, NULL, 0, 0 }, /* 6 = close */
As you can see linux_fork
is implemented
in Linuxulator itself so the definition is of STD
type and has no argument, which is exhibited by the dummy argument
structure. On the other hand close
is just an
alias for real FreeBSD close(2) so it has no linux arguments
structure associated and in the system entry table it is not prefixed
with linux as it calls the real close(2) in the kernel.
The Linux emulation layer is not complete, as some syscalls are not implemented properly and some are not implemented at all. The emulation layer employs a facility to mark unimplemented syscalls with the DUMMY macro. These dummy definitions reside in linux_dummy.c in a form of DUMMY(syscall);, which is then translated to various syscall auxiliary files and the implementation consists of printing a message saying that this syscall is not implemented. The UNIMPL prototype is not used because we want to be able to identify the name of the syscall that was called in order to know what syscalls are more important to implement.
Signal handling is done generally in the FreeBSD kernel for all
binary compatibilities with a call to a compat-dependent layer.
Linux compatibility layer defines
linux_sendsig
routine for this purpose.
This routine first checks whether the signal has been installed
with a SA_SIGINFO in which case it calls
linux_rt_sendsig
routine instead. Furthermore,
it allocates (or reuses an already existing) signal handle context,
then it builds a list of arguments for the signal handler. It
translates the signal number based on the signal translation table,
assigns a handler, translates sigset. Then it saves context for the
sigreturn
routine (various registers, translated
trap number and signal mask). Finally, it copies out the signal
context to the userspace and prepares context for the actual
signal handler to run.
This routine is similar to linux_sendsig
just the signal context preparation is different. It adds
siginfo, ucontext, and some
POSIX® parts. It might be worth considering whether those two
functions could not be merged with a benefit of less code duplication
and possibly even faster execution.
This syscall is used for return from the signal handler. It does some security checks and restores the original process context. It also unmasks the signal in process signal mask.
Many UNIX® derivates implement the ptrace(2) syscall in order to allow various tracking and debugging features. This facility enables the tracing process to obtain various information about the traced process, like register dumps, any memory from the process address space, etc. and also to trace the process like in stepping an instruction or between system entries (syscalls and traps). ptrace(2) also lets you set various information in the traced process (registers etc.). ptrace(2) is a UNIX-wide standard implemented in most UNIXes around the world.
Linux emulation in FreeBSD implements the ptrace(2) facility in linux_ptrace.c. The routines for converting registers between Linux and FreeBSD and the actual ptrace(2) syscall emulation syscall. The syscall is a long switch block that implements its counterpart in FreeBSD for every ptrace(2) command. The ptrace(2) commands are mostly equal between Linux and FreeBSD so usually just a small modification is needed. For example, PT_GETREGS in Linux operates on direct data while FreeBSD uses a pointer to the data so after performing a (native) ptrace(2) syscall, a copyout must be done to preserve Linux semantics.
The ptrace(2) implementation in Linuxulator has some known weaknesses. There have been panics seen when using strace (which is a ptrace(2) consumer) in the Linuxulator environment. Also PT_SYSCALL is not implemented.
Whenever a Linux process running in the emulation layer traps the trap itself is handled transparently with the only exception of the trap translation. Linux and FreeBSD differs in opinion on what a trap is so this is dealt with here. The code is actually very short:
static int translate_traps(int signal, int trap_code) { if (signal != SIGBUS) return signal; switch (trap_code) { case T_PROTFLT: case T_TSSFLT: case T_DOUBLEFLT: case T_PAGEFLT: return SIGSEGV; default: return signal; } }
The RTLD run-time link-editor expects so called AUX tags on stack
during an execve
so a fixup must be done to ensure
this. Of course, every RTLD system is different so the emulation layer
must provide its own stack fixup routine to do this. So does
Linuxulator. The elf_linux_fixup
simply copies
out AUX tags to the stack and adjusts the stack of the user space
process to point right after those tags. So RTLD works in a
smart way.
The Linux emulation layer on i386 also supports Linux A.OUT binaries. Pretty much everything described in the previous sections must be implemented for A.OUT support (beside traps translation and signals sending). The support for A.OUT binaries is no longer maintained, especially the 2.6 emulation does not work with it but this does not cause any problem, as the linux-base in ports probably do not support A.OUT binaries at all. This support will probably be removed in future. Most of the stuff necessary for loading Linux A.OUT binaries is in imgact_linux.c file.