Kllrnohj: I think KermMartian thought you meant
writing an interrupt handler, not
using/triggering them. Writing interrupt handlers is indeed tricky and not for a newcomer, but using them (like int 80h) is not.
Either way, I think it's ok to use interrupts like this, as David is doing it to learn x86, and it's pretty well documented too.
David: I don't use x86 regularly, but I have used it a bit in the past, and I have fairly extensive experience with system calls on Linux. Let me explain what the code does:
Code: section .data
hello: db 'Hello world!',10 ; 'Hello world!' plus a linefeed character
0x5: equ $-hello ; Length of the 'Hello world!' string
; (I'll explain soon)
This defines a string "Hello world!" plus newline without a zero byte. It also defines a symbol (0x5, which I assume should be el oh el) equal to the length of the string. This should be pretty straightforward since you seem familiar with Z80 asm.
Code: section .text
global _start
_start:
This switches to the ".text" section. "Text" basically means "executable code". This also defines and exports the symbol _start. All programs start at _start (even C programs).
Code: mov eax,4 ; The system call for write (sys_write)
mov ebx,1 ; File descriptor 1 - standard output
mov ecx,hello ; Put the offset of hello in ecx
mov edx,0x5 ; 0x5 is a constant, so we don't need to say
; mov edx,[0x5] to get it's actual value
int 80h ; Call the kernel
These lines call the "write" system call. Here is the C prototype for the write system call:
Code: ssize_t write(int fd, const void *buf, size_t count);
(More details here).
Linux passes arguments to system calls via registers. The first argument (fd) is in ebx, second (buf) is in ecx, and third (count) is in edx. eax holds the system call number, which is 4 on x86.
The "int 80h", as mentioned already, triggers interrupt 0x80 (80 hex/128 decimal) which tells the kernel to run the system call. These 5 instructions are equivalent to the following C code:
Code: char hello[] = "Hello world!\n"; // this string is defined in the data section and is zero-terminated
write(1, hello, strlen(hello)); // we don't use strlen() in the x86 code
The 1 is the file descriptor for standard output, which is already open for every regular process that you would run from the shell, and would point to the terminal (unless it's redirected to a pipe or a file).
When a syscall returns from the kernel, the eax register holds the result of the syscall (the return value). On success, the write syscall returns how many bytes it wrote (13 in this example). On error it returns a negative value. Take the negative of that negative value (to make it positive) and you'll have the error code as defined in /usr/include/errno.h (or more likely in /usr/include/asm-generic/errno-base.h or similar).
Code: mov eax,1 ; The system call for exit (sys_exit)
mov ebx,0 ; Exit with return code of 0 (no error)
int 80h
This calls exit(0); which exits the program. It's an error to let the program run off the end (same as in Z80) or to return (with the "ret" instruction). You must call exit() one way or another to terminate the program, or otherwise the program will very likely crash after it runs. Fortunately for C programmers, this is done automatically, even by returning from the main() function.
The C runtime does essentially this:
Code: _start:
call main
mov ebx,eax ; main's return value is in eax
mov eax,1
int 80h ; exit(status);
Hope this helps. 
