How do you run assembly code without an OS intervention?

Gat Pelsinger · January 21

I just kind of started learning x86 assembly, and there are stuff like interrupts and syscalls which need an OS to interpret, but what if I do not have an OS? Like look for C, all its function depend on the OS for carrying out certain function, but in assembly, I am literally writing barebones binary code that directly communicates with the CPU, but then there are still calls for the OS. If I wanted to make a program that runs without an OS, how would I replace my interrupts and syscalls?

dcgreen2k · January 21

The kind of programming you're talking about is called baremetal programming, since there's no OS providing resources, builtin functions, etc. for your code to use. There's a fair bit of setup you need to do before you can get even simple code running.

I'll note that I don't have much experience in this area, but you will have to define interrupt handlers + an interrupt descriptor table and implement functions for each syscall yourself. For the syscalls, you would write code that directly interfaces with hardware. (Example below)

Here are some useful links:

https://wiki.osdev.org/Interrupts

https://wiki.osdev.org/Interrupts_tutorial

https://filippo.io/linux-syscall-table/

Most of the tutorials on the OSDev Wiki require using both assembly and C. You will also need to create a simple kernel to get your code running, if you decide to go this route. Here's the tutorial for that: https://wiki.osdev.org/Bare_Bones

-----------

(Example)

Back when I was learning this kind of thing, I remember writing an implementation of puts() for my basic kernel's C library. All it did was print a string to the screen while in VGA text mode. To do this, you write characters directly into memory at address 0xB8000 which is the VGA text buffer. This is the lowest level of code needed to write characters to the screen, but after this you have a nice C function to use wherever you'd like.

Eigenvektor · January 21

1 hour ago, Gat Pelsinger said:

for C, all its function depend on the OS for carrying out certain function, but in assembly, I am literally writing barebones binary code that directly communicates with the CPU, but then there are still calls for the OS. If I wanted to make a program that runs without an OS, how would I replace my interrupts and syscalls?

The reason you "rely on the OS" is because you're using libraries for convenience. You could write everything stdlib/stdio/time/string etc. do by hand. It would simply be wasted effort to reinvent the wheel (most of the time).

C gets compiled into machine code, so it does exactly the same thing. The compiled binary directly runs on the CPU, directly modifies registers etc. It wouldn't be possible to use C to write a kernel otherwise (the Linux kernel for example is predominantly written in C). There is very little you can do in assembler you cannot also do in C (with some exceptions).

The other reason you can't do certain things is the operating system's/CPU's security model (ring 0 etc). You won't be able to circumvent that even when writing in assembler, unless you're writing your own kernel in which case you can get your code to run on ring 0.