Talking to the operating system: svc and files

Three layers of input and output

Every byte a program prints passes through three layers:

1. Library functions such as printf, scanf, and puts. They format numbers as text, and they collect output in a buffer (a block of memory used as a waiting area) so they can hand it on in large pieces.
2. System calls such as write and read. They move raw bytes and know nothing about %d or %f.
3. The devices: screen, keyboard, disk. Only the kernel works with these.

Unix treats every device, and every file on the disk, as a file: something you can read bytes from or write bytes to. A program names an open file by a small number, its file descriptor. Every program starts with three already open: 0 is standard input (usually the keyboard), 1 is standard output (usually the screen), and 2 is standard error (also the screen, but kept separate so error messages do not end up inside output that was sent to a file).

How svc works

An ordinary program such as yours runs at EL0, exception level 0, the processor's least trusted mode, where instructions that control devices are not allowed. The kernel runs at EL1. The instruction svc 0 (supervisor call) is the one door between them: it switches the processor to EL1 and jumps into the kernel, which reads your request from the registers, does the work, and comes back to the instruction after the svcSupervisor call (a system call): svc #0 runs the call whose number is in x8..

The request is spelled out in registers:

• x8result address or system call number (x8): where to write a large returned struct, or the call svc makes; a called routine may overwrite it. holds the service number, which picks the system call.
• x0argument and return register (x0-x7): carries the first eight arguments and the return value. to x5argument and return register (x0-x7): carries the first eight arguments and the return value. hold its arguments, in order.
• After svc 0, x0argument and return register (x0-x7): carries the first eight arguments and the return value. holds the result. A negative result means the call failed.

A system call changes no register except x0argument and return register (x0-x7): carries the first eight arguments and the return value., unlike a blBranch with link; writes return address to X30. to a library function. These are the calls this lesson uses:

Writing without printf

The first program prints one line with write. write needs the message's length in bytes, and the assembler can count it. In note_len = . - note, the dot stands for the current address, just past the message's last byte, and taking away the message's first address leaves its length.

The message uses .ascii rather than .string. .string adds a zero byte at the end, which printf needs to find the end of a string but write does not: counted into the length, the zero byte would be sent to the screen as an invisible extra character.

The program then prints the count the kernel returned, this time with printf. Run it: the first line is this line never went through printf and the second is write reported 36 bytes.

Opening a file

openat opens a file and returns a new file descriptor for it, usually 3 for the first file a program opens. It takes four arguments:

• x0argument and return register (x0-x7): carries the first eight arguments and the return value.: the directory a relative path starts from. The special value AT_FDCWD, which is -100, means the current directory.
• x1argument and return register (x0-x7): carries the first eight arguments and the return value.: the address of the file name, ending in a zero byte (write it with .string, since the kernel looks for that zero).
• x2argument and return register (x0-x7): carries the first eight arguments and the return value.: the flags, one bit for each choice, joined with |.
• x3argument and return register (x0-x7): carries the first eight arguments and the return value.: the permission mode, which counts only when the call creates the file.

The flags and the mode are written in octal, base 8, which the assembler recognizes by a leading 0: 0644 is octal, and 644 would be decimal. One octal digit stands for exactly three bits, which suits values built from single bits and groups of three:

The mode's three octal digits give the permissions of the file's owner, of the owner's group, and of everyone else. Each digit adds up read (4), write (2), and execute (1), so 0644 lets the owner read and write, and everyone else only read.

Writing a file and reading it back

The next program uses all four calls. It creates notes.txt, writes three lines to it, and closes it. Then it opens the file again to read it and copies it to the screen 32 bytes at a time: read fills a buffer in the frame and returns how many bytes it put there, and write sends exactly that many to file descriptor 1. A read can return fewer bytes than asked for, which is normal; only 0 means the end of the file.

Every call that can fail is checked. If openat returns a negative number, or write stores fewer bytes than it was given, the program writes an error line to standard error and returns 1 from main, the exit status that tells the shell something went wrong. The descriptor stays in x19callee-saved register (x19-x28): a routine must restore it before it returns. so that it is still there if you add a printf later; main saves x19callee-saved register (x19-x28): a routine must restore it before it returns. first, because every subroutine must leave x19callee-saved register (x19-x28): a routine must restore it before it returns. as it found it.

It prints the three lines it wrote, buy bread, call grandma, and water the plants, and exits with status 0.

Reading until the input ends

Standard input works the same way through file descriptor 0. The last program reads it 8 bytes at a time, adds up what each read returns, and stops when read returns 0. The lesson feeds it three lines, 28 bytes when the newline at the end of each line is counted.

A keyboard never runs out by itself, so after those 28 bytes the program waits, and the console says it is waiting for input. Press Ctrl+D in the console's input box. That marks the end of the input, read returns 0, and the program prints 28 bytes. In a Linux terminal, ./count < notes.txt feeds it a file instead, and the end of the file does the same job.

Check yourself

1. Which register picks the system call, and which holds its result?
2. What does read return at the end of the input, and what does a negative result mean?
3. Why does a message for write suit .ascii better than .string?
4. What permissions does the mode 0640 give?
5. After svc 0, which registers may have changed?

Practice

• Count the lines: read standard input with the read system call instead of scanf.
• High score keeper: keep a record in a file with openat, read, write and close.
• Echo the sum: read input the library way, with scanf.
• Advanced quiz: ARMv8 assembly: asks about exception levels.
• Basic quiz: input and output: file descriptors, the register that picks a system call, and why printf and write can print out of order.
• Fill in the blank: input and output (core): service numbers, descriptors, and the length write sends.
• Predict: input and output (challenge): what printf, scanf, read and write return.