This project was put together to teach myself NASM 64bit assembly language on linux.
+This project was put together to teach myself NASM x86 assembly language on linux.
We can accomplish this all in assembly by loading EAX with the function number (operation code OPCODE) we want to execute and filling the remaining registers with the arguments we want to pass to the system call. A software interrupt is requested with the INT instruction and the kernel takes over and calls the function from the library with our arguments. Simple.
-For example requesting an interrupt when EAX=1 will call sys_exit and requesting an interrupt when EAX=4 will call sys_write instead. EBX, ECX & EDX will be passed as arguments if the function requires them. Click here to view an example of a Linux System Call Table and its corresponding OPCODES.
+For example requesting an interrupt when EAX=1 will call sys_exit and requesting an interrupt when EAX=4 will call sys_write instead. EBX, ECX & EDX will be passed as arguments if the function requires them. Click here to view an example of a Linux System Call Table and its corresponding OPCODES.
The arguments passed are as follows:
After successfully learning now to execute a system call in Lesson 1 we now need to learn about one of the most important system calls in the kernel, sys_exit.
+After successfully learning how to execute a system call in Lesson 1 we now need to learn about one of the most important system calls in the kernel, sys_exit.
Notice how after our 'Hello, world!' program ran we got a Segmentation fault? Well, computer programs can be thought of as a long strip of instructions that are loaded into memory and divided up into sections (or segments). This general pool of memory is shared between all programs and can be used to store variables, instructions, other programs or anything really. Each segment is given an address so that information stored in that section can be found later.
@@ -764,7 +878,7 @@
+
;------------------------------------------
; int slen(String message)
; String length calculation function
@@ -816,7 +930,11 @@ Linefeeds
push eax ; push eax onto the stack to preserve it while we use the eax register in this function
mov eax, 0Ah ; move 0Ah into eax - 0Ah is the ascii character for a linefeed
+ ; as eax is 4 bytes wide, it now contains 0000000Ah
push eax ; push the linefeed onto the stack so we can get the address
+ ; given that we have a little-endian architecture, eax register bytes are stored in reverse order,
+ ; this corresponds to stack memory contents of 0Ah, 0h, 0h, 0h,
+ ; giving us a linefeed followed by a NULL terminating byte
mov eax, esp ; move the address of the current stack pointer into eax for sprint
call sprint ; call our sprint function
pop eax ; remove our linefeed character from the stack
@@ -927,7 +1045,7 @@ Passing arguments
~$ nasm -f elf helloworld-args.asm
- ~$ ld -m elf_i386 helloworld-lf.o -o helloworld-args
+ ~$ ld -m elf_i386 helloworld-args.o -o helloworld-args
~$ ./helloworld-args "This is one argument" "This is another" 101
./helloworld-args
This is one argument
@@ -973,9 +1091,9 @@ Writing our program
The arguments passed are as follows:
- - EDX will be loaded with the maximum length (in bytes) of the our space in memory.
+ - EDX will be loaded with the maximum length (in bytes) of the space in memory.
- ECX will be loaded with the address of our variable created in the .bss section.
- - EBX will be loaded with the file we want to write to – in this case STDIN.
+ - EBX will be loaded with the file we want to read from – in this case STDIN.
As always the datatype and meaning of the arguments passed can be found in the function's definition.
@@ -1009,7 +1127,7 @@ Writing our program
mov edx, 255 ; number of bytes to read
mov ecx, sinput ; reserved space to store our input (known as a buffer)
- mov ebx, 0 ; write to the STDIN file
+ mov ebx, 0 ; read from the STDIN file
mov eax, 3 ; invoke SYS_READ (kernel opcode 3)
int 80h
@@ -1529,15 +1647,15 @@ Calculator (atoi)
Writing our program
- Our program begins by using the POP instruction to get the number of passed arguments off the stack. This value is stored in ECX (originally known as the counter register). It will then loop through these arguments popping each one off the stack and performing our addition logic. As we know, arguments passed via the command line are received by our program as strings. Before we can add the arguments together we will need to convert them to integers otherwise our result will not be correct. We do this by calling our Ascii to Integer function (atoi). This function will convert the ascii value into an integer and place the result in EAX. We can then add this value to EDX (originally known as the data register) where we will store the result of our additions. If the value passed to atoi is not an ascii representation of an integer our function will return zero instead. When all arguments have been converted and added together we will print out the result and call our quit function.
+ Our program begins by using the POP instruction to get the number of passed arguments off the stack. This value is stored in ECX (originally known as the counter register). It will then POP the next value off the stack containing the program name and remove it from the number of arguments stored in ECX. It will then loop through the rest of the arguments popping each one off the stack and performing our addition logic. As we know, arguments passed via the command line are received by our program as strings. Before we can add the arguments together we will need to convert them to integers otherwise our result will not be correct. We do this by calling our Ascii to Integer function (atoi). This function will convert the ascii value into an integer and place the result in EAX. We can then add this value to EDX (originally known as the data register) where we will store the result of our additions. If the value passed to atoi is not an ascii representation of an integer our function will return zero instead. When all arguments have been converted and added together we will print out the result and call our quit function.
How does the atoi function work
- Converting an ascii string into an integer value is not a trivial task. We know how to convert an integer to an ascii string so the process should essentially work in reverse. Firstly we take the address of the string and move it into ESI (originally known as the source register). We will then move along the string byte by byte (think of each byte as being a single digit or decimal placeholder). For each digit we will check if it's value is between 48-57 (ascii values for the digits 0-9). We will also check if the value is a linefeed or null terminating byte meaning we have reached the end of the string.
+ Converting an ascii string into an integer value is not a trivial task. We know how to convert an integer to an ascii string so the process should essentially work in reverse. Firstly we take the address of the string and move it into ESI (originally known as the source register). We will then move along the string byte by byte (think of each byte as being a single digit or decimal placeholder). For each digit we will check if it's value is between 48-57 (ascii values for the digits 0-9).
- Once we have performed all these checks and determined that the byte can be converted to an integer will perform the following logic. We will subtract 48 from the value – converting the ascii value to it's decimal equivalent. We will then add this value to EAX (the general purpose register that will store our result). We will then multiple EAX by 10 as each byte represents a decimal placeholder and continue the loop.
+ Once we have performed this check and determined that the byte can be converted to an integer we will perform the following logic. We will subtract 48 from the value – converting the ascii value to it's decimal equivalent. We will then add this value to EAX (the general purpose register that will store our result). We will then multiple EAX by 10 as each byte represents a decimal placeholder and continue the loop.
- When all bytes have been converted we need to do one last thing before we return the result. The last digit of any number represents a single unit (not a multiple of 10) so we have multiplied our result one too many times. We simple divide it by 10 once to correct this and then return.
+ When all bytes have been converted we need to do one last thing before we return the result. The last digit of any number represents a single unit (not a multiple of 10) so we have multiplied our result one too many times. We simple divide it by 10 once to correct this and then return. If no integer arguments were pass however, we skip this divide instruction.
What is the BL register
@@ -1555,45 +1673,45 @@ What is the BL register
functions.asm
- ;------------------------------------------
- ; int atoi(Integer number)
- ; Ascii to integer function (atoi)
- atoi:
- push ebx ; preserve ebx on the stack to be restored after function runs
- push ecx ; preserve ecx on the stack to be restored after function runs
- push edx ; preserve edx on the stack to be restored after function runs
- push esi ; preserve esi on the stack to be restored after function runs
- mov esi, eax ; move pointer in eax into esi (our number to convert)
- mov eax, 0 ; initialise eax with decimal value 0
- mov ecx, 0 ; initialise ecx with decimal value 0
-
- .multiplyLoop:
- xor ebx, ebx ; resets both lower and uppper bytes of ebx to be 0
- mov bl, [esi+ecx] ; move a single byte into ebx register's lower half
- cmp bl, 48 ; compare ebx register's lower half value against ascii value 48 (char value 0)
- jl .finished ; jump if less than to label finished
- cmp bl, 57 ; compare ebx register's lower half value against ascii value 57 (char value 9)
- jg .finished ; jump if greater than to label finished
- cmp bl, 10 ; compare ebx register's lower half value against ascii value 10 (linefeed character)
- je .finished ; jump if equal to label finished
- cmp bl, 0 ; compare ebx register's lower half value against decimal value 0 (end of string)
- jz .finished ; jump if zero to label finished
-
- sub bl, 48 ; convert ebx register's lower half to decimal representation of ascii value
- add eax, ebx ; add ebx to our interger value in eax
- mov ebx, 10 ; move decimal value 10 into ebx
- mul ebx ; multiply eax by ebx to get place value
- inc ecx ; increment ecx (our counter register)
- jmp .multiplyLoop ; continue multiply loop
-
- .finished:
- mov ebx, 10 ; move decimal value 10 into ebx
- div ebx ; divide eax by value in ebx (in this case 10)
- pop esi ; restore esi from the value we pushed onto the stack at the start
- pop edx ; restore edx from the value we pushed onto the stack at the start
- pop ecx ; restore ecx from the value we pushed onto the stack at the start
- pop ebx ; restore ebx from the value we pushed onto the stack at the start
- ret
+ ;------------------------------------------
+ ; int atoi(Integer number)
+ ; Ascii to integer function (atoi)
+ atoi:
+ push ebx ; preserve ebx on the stack to be restored after function runs
+ push ecx ; preserve ecx on the stack to be restored after function runs
+ push edx ; preserve edx on the stack to be restored after function runs
+ push esi ; preserve esi on the stack to be restored after function runs
+ mov esi, eax ; move pointer in eax into esi (our number to convert)
+ mov eax, 0 ; initialise eax with decimal value 0
+ mov ecx, 0 ; initialise ecx with decimal value 0
+
+ .multiplyLoop:
+ xor ebx, ebx ; resets both lower and uppper bytes of ebx to be 0
+ mov bl, [esi+ecx] ; move a single byte into ebx register's lower half
+ cmp bl, 48 ; compare ebx register's lower half value against ascii value 48 (char value 0)
+ jl .finished ; jump if less than to label finished
+ cmp bl, 57 ; compare ebx register's lower half value against ascii value 57 (char value 9)
+ jg .finished ; jump if greater than to label finished
+
+ sub bl, 48 ; convert ebx register's lower half to decimal representation of ascii value
+ add eax, ebx ; add ebx to our integer value in eax
+ mov ebx, 10 ; move decimal value 10 into ebx
+ mul ebx ; multiply eax by ebx to get place value
+ inc ecx ; increment ecx (our counter register)
+ jmp .multiplyLoop ; continue multiply loop
+
+ .finished:
+ cmp ecx, 0 ; compare ecx register's value against decimal 0 (our counter register)
+ je .restore ; jump if equal to 0 (no integer arguments were passed to atoi)
+ mov ebx, 10 ; move decimal value 10 into ebx
+ div ebx ; divide eax by value in ebx (in this case 10)
+
+ .restore:
+ pop esi ; restore esi from the value we pushed onto the stack at the start
+ pop edx ; restore edx from the value we pushed onto the stack at the start
+ pop ecx ; restore ecx from the value we pushed onto the stack at the start
+ pop ebx ; restore ebx from the value we pushed onto the stack at the start
+ ret
@@ -1613,6 +1731,8 @@ What is the BL register
_start:
pop ecx ; first value on the stack is the number of arguments
+ pop edx ; second value on the stack is the program name (discarded when we initialise edx)
+ sub ecx, 1 ; decrease ecx by 1 (number of arguments without program name)
mov edx, 0 ; initialise our data register to store additions
nextArg:
@@ -1657,6 +1777,11 @@ Namespace
Local labels are prepended with a "." at the beginning of their name for example ".finished". You may have noticed them appearing as our code base in functions.asm grew. A local label is given the namespace of the first global label above it. You can jump to a local label by using the JMP instruction and the compiler will calculate which local label you are referencing by determining in what scope (based on the above global labels) the instruction was called.
+
+ Note:
+ The file functions.asm was modified adding namespaces in all the subroutines. This is particularly important in the "slen" subroutine which contains a "finished" global label.
+
+
namespace.asm
@@ -1769,7 +1894,7 @@ Writing our program
nextNumber:
inc ecx ; increment our counter variable
- .checkFizz
+ .checkFizz:
mov edx, 0 ; clear the edx register - this will hold our remainder after division
mov eax, ecx ; move the value of our counter into eax for division
mov ebx, 3 ; move our number to divide by into ebx (in this case the value is 3)
@@ -2016,7 +2141,7 @@ Lesson 21
Telling the time
- Generating a unix timestamp in NASM is easy with the SYS_TIME function of the linux kernel. Simply pass OPCODE 13 to the kernel with no arguments and you are returned the Unix Epoch in the EAX register.
+ Generating a unix timestamp in NASM is easy with the SYS_TIME function of the linux kernel. Simply pass OPCODE 13 to the kernel with no arguments and you are returned the Unix Epoch in the EAX register.
That is the number of seconds that have elapsed since January 1st 1970 UTC.
@@ -2060,32 +2185,1498 @@ Telling the time
-
-
+
-
+
+
+
+ Lesson 22
+ File Handling - Create
+
-
+ Firstly, some background
-
+ File Handling in Linux is achieved through a small number of system calls related to creating, updating and deleting files. These functions require a file descriptor which is a unique, non-negative integer that identifies the file on the system.
-
-
-
+ Writing our program
-
+
+ create.asm
+
+ ; Create
+ ; Compile with: nasm -f elf create.asm
+ ; Link with (64 bit systems require elf_i386 option): ld -m elf_i386 create.o -o create
+ ; Run with: ./create
-
-