liblinux

environment vector. No count is provided for that, so code must loop through the environment looking for the sentinel in order to find it. The auxiliary vector is really interesting. I don't usually see software making direct use of it. It contains interesting information such as CPU identifier and capabilities, page size, the location of the Linux vDSO, some random bytes, program file name, user and group IDs, among other things. https://github.com/torvalds/linux/blob/master/include/uapi/l... https://github.com/torvalds/linux/blob/master/arch/x86/inclu... https://github.com/torvalds/linux/blob/master/Documentation/... This is the data the Linux kernel passes to programs. After organizing these parameters, the program is free to do whatever it wants. The libc entry point will naturally start setting up libc. In particular, it seems to spend a lot of time setting up the init and fini insanity that's probably better off forgotten. https://blogs.oracle.com/solaris/post/init-and-fini-processi... It's not necessary. After this, you can just run your program directly. I used to develop a liblinux that illustrates all this with much simpler code: https://github.com/matheusmoreira/liblinux/blob/master/start... https://github.com/matheusmoreira/liblinux/blob/master/start... The entry point code passes the stack pointer to a C function which gathers all kernel parameters and starts the program with no further setup. I made several example programs, including one which outputs all these variables. https://github.com/matheusmoreira/liblinux/blob/master/examp... I stopped developing this because I discovered the Linux itself has a better solution that they use for their own tools: https://github.com/torvalds/linux/blob/master/tools/include/... The entry point code for all supported architectures is present as inline assembly code!

es in order to have a normal main function. The only missing feature is the auxiliary vector. You can just include it and start using Linux immediately. You can absolutely do this with Rust as well. Rust supports programming with no standard library. If I remember correctly, the inline assembly macros are still an unstable feature. It's likely to change in the future though.

blob/master/tools/include/... Do you think liblinux could have a future?

vily discouraged by libc maintainers and even users. Using calls like clone will actually screw up the global state maintained by glibc threads implementation. It gets to the point where they don't even offer wrappers for system calls they don't want to support. I don't like it... What's the point of an amazing system call that lets you choose exactly which resources you want to share with a child task if all it's ever used for is some POSIX threads implementation? Even the Linux manuals do this for some reason: the documentation I linked in my above post actually describe the glibc stuff as if it was part of the kernel and leaves the actual binary interfaces as an afterthought. Linux manuals also inexplicably host documentation for systemd instead of a generic description of how a Linux init system is supposed to interface with the kernel. It makes no sense to me! I even asked Greg Kroah-Hartman about it on Reddit: https://old.reddit.com/r/linux/comments/fx5e4v/im_greg_kroah... I actually think using the system call interface is better than using the C library. No thread local errno business, no global state anywhere, no buffering unless you do it explicitly, no C standard to keep in mind... It's just so simple it's amazing. It's also stable unlike other operating systems which ship user space libraries as the actual interface. On Linux there's no reason not to use it! > I feel like you should publish this and post it on Hacker News. I wrote a liblinux library, the README describes part of my journey learning about this system call stuff. Lots of LWN sources! https://github.com/matheusmoreira/liblinux/blob/master/READM... I've been thinking about expanding on it in order to describe everything I know about the Linux system call interface. You really think I should publish this? The reason I didn't post liblinux here is it's in a very incomplete state and actually less practical than the kernel nolibc.h file. I only discovered the header much later into development and figured there was no point anymore since the kernel had a much better solution not only available but in actual use. I ended up rewriting autoconf in pure makefiles instead...

e is the Linux interface. So it's actually possible to trash all of GNU and rewrite the entire Linux user space in Rust or Lisp or whatever. It doesn't have to be written in C. It doesn't even have to be POSIX compliant. Could be GUI-focused! All you need to make any x86_64 Linux system call is this code: long system_call(long number, long _1, long _2, long _3, long _4, long _5, long _6) { register long rax __asm__("rax") = number; register long rdi __asm__("rdi") = _1; register long rsi __asm__("rsi") = _2; register long rdx __asm__("rdx") = _3; register long r10 __asm__("r10") = _4; register long r8 __asm__("r8") = _5; register long r9 __asm__("r9") = _6; /* r8, r9 and r10 may be clobbered but can't be in the clobbers list because the compiler won't use clobbered registers as inputs. So they're placed in the outputs list instead. */ __asm__ volatile ("syscall" : "+r" (rax), "+r" (r8), "+r" (r9), "+r" (r10) : "r" (rdi), "r" (rsi), "r" (rdx) : "rcx", "r11", "cc", "memory"); return rax; } This is all you need to do anything. You can perform I/O. You can allocate memory. You can obtain your terminal's dimensions. You can perform ioctl's to your laptop's camera. You could make a new programming language today and all it really needs to be complete is this single function. What if instead of having this function the compiler could simply emit code that conform to this binary interface? The language could have a system_call keyword that generates Linux system call code! Once I realized this I tried to turn it into a library called liblinux... I stopped working on it when I found out the kernel already has an awesome single file header you can include that lets you build freestanding Linux executables for a ton of architectures. They use it on the kernel to build their own tools! https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin... It even includes process entry point code! Linux copies the argument and environment vectors to the stack before entering the executable. The process start up code obtains those pointers and passes them to the main function. It also ensures the exit system call is called. The process entry point is usually called _start because that's what linkers look for by default. In reality the ELF header has a pointer to the program's entry point, the actual symbol doesn't matter. You can tell the linker to set it to any other address or symbol. Also note that it's an entry point, not a function. There is no return address. Allowing that code to terminate results in a segmentation violation. Hence the need to ensure exit is called before that happens. The only feature that seems to be missing is support for the table of auxiliary values: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin... The auxiliary values are placed on the stack immediately after the environment vector. So all you need to do to find this pointer is loop through it until it goes out of bounds. I wrote this code and it works: https://github.com/matheusmoreira/liblinux/blob/master/start... struct auxiliary { Elf64_Off type; Elf64_Off value; }; static void *after(void *vector) { void **pointer = (void **) vector; while (*pointer++ != 0); return pointer; } int liblinux_start(void *stack_pointer) { long count; char **arguments; char **environment; struct auxiliary *values; count = *((long *) stack_pointer); arguments = ((char **) stack_pointer) + 1; environment = arguments + count + 1; values = after(environment); return start(count, arguments, environment, values); } You can just loop over the pointer to the structure until you find one with type equal to AT_NULL. Example here: https://github.com/matheusmoreira/liblinux/blob/master/examp...