mov eax,0Bh
mov ecx,args
mov edx,0
mov ebx,arg0
int 80h
    

mov     eax, 4          ;sys_write
mov     ebx, 1          ;stdout
mov     ecx, axwert     ;pointer to buffer to write
mov     edx, 7 ;buffer to write
int     80h
    

format elf executable

entry start
start:


mov eax,0Bh                      ;call extern prog (here 7-zip)
mov ecx,args
mov edx,0
mov ebx,arg0
int 80h

mov [alleregister],ah             ;store all registervalues in one huge variable
mov [alleregister+1],al
mov [alleregister+7],bh
mov [alleregister+8],bl
mov [alleregister+14],ch
mov [alleregister+15],cl
mov [alleregister+21],dh
mov [alleregister+22],dl
add [alleregister],48
add [alleregister+1],48
add [alleregister+7],48
add [alleregister+8],48
add [alleregister+14],48
add [alleregister+15],48
add [alleregister+21],48
add [alleregister+22],48

mov eax,08h            ; create file
mov ebx,f              ; ebx filename
mov ecx, 0x1a4
int 80h
mov ebx,eax              ; file descriptor nach ebx

mov eax,04h           ; write to file
mov ecx,alleregister
mov edx,ars
int 80h

mov eax,06h            ; close file
int 80h

mov eax,1
int 80h

;*********** here the variables ***********************

f db 'execlog.txt',0

arg0 db '/usr/bin/PeaZip/res/7z/7z',0
arg1 db 't',0
arg2 db '-ptest',0
arg3 db 'archiv-m.7z',0
args dd arg0,arg1,arg2,arg3,0

alleregister db "00-ax",13,10,"00-bx",13,10,"00-cx",13,10,"00-dx",13,10,13,10
ars =$-alleregister
    

; fasm demonstration of writing simple ELF executable

format ELF executable
entry start

segment readable executable

start:

  mov     eax,4
       mov     ebx,1
       mov     ecx,msg
     mov     edx,msg_size
        int     0x80

    mov     eax,1
       xor     ebx,ebx
     int     0x80

segment readable writeable

msg db 'Hello world!',0xA
msg_size = $-msg

    

start:
mov eax,2 ;fork
int 80h
test eax,eax
jne continue

mov eax,0Bh                     ;call extern prog (here 7-zip)
mov ecx,args
mov edx,0
mov ebx,arg0
int 80h

continue:
mov [alleregister],ah
; and so on...
    

the program doesn't turn back to the system-prompt after execution

/**
 * For debugging compile with
 * gcc -g -nostdlib vfork.S -o vfork
 *
 * or for releasing with
 *
 * gcc -s -nostdlib vfork.S -o vfork
 */

        .if 0
#include <asm/unistd.h>
#include <unistd.h>
#include <sys/wait.h>
        .endif

        .line __LINE__
        .intel_syntax noprefix
        .globl _start
        .text

_start:
        /* create new process */
        mov     rax, __NR_vfork
        syscall
        /* check if child or parent */
        test    rax, rax
        jnz     parent_process
        /* child process, start application */
        mov     rax, __NR_execve
        mov     rdi, OFFSET arg0
        mov     rsi, OFFSET argv
        xor     rdx, rdx
        syscall
        /**
         * execve returns only if any error occured,
         * so here we exit child process
        **/
        mov     rdi, rax
        mov     rax, __NR_exit
        syscall

        /* parent process */
parent_process: 
        /* wait for child process to complete */
        mov     rdi, rax
        mov     rsi, OFFSET exit_status
        mov     rdx, WUNTRACED
        xor     r10, r10 /* we ain't interrested in resources used */
        mov     rax, __NR_wait4
        syscall
        /* print "Thread completed" message */
        mov     rax, __NR_write
        mov     rdi, STDOUT_FILENO
        mov     rsi, OFFSET msg
        mov     rdx, OFFSET msg_size
        syscall
        mov     rax, __NR_write
        mov     rsi, OFFSET status_ok
        mov     rdx, OFFSET status_ok_size
        /* only the least 8 bits of the exit status */
        cmp     BYTE PTR [rip + exit_status + 1], 0
        jz      ok
        mov     rsi, OFFSET status_fail
        mov     rdx, OFFSET status_fail_size
ok:   
        syscall
        /* exit */
        xor     rdi, rdi
        mov     rax, __NR_exit
        syscalll

msg:
        .ascii  "Thread completed! Exit status: "
msg_size = . - msg

status_ok:
        .ascii  "Succeeded\n"
status_ok_size = . - status_ok
        
status_fail:
        .ascii  "Failed\n"
status_fail_size = . - status_fail        

arg0:
        .asciz  "/usr/bin/sleep"
//        .asciz  "/bin/true"
//        .asciz  "/bin/false"
arg1:
        .asciz  "1"
argv:
        .quad   arg0, arg1, 0         

        .data
exit_status:    
        .long   -1    

;;;
;;; Preprocessing:
;;; cpp -C -m32 vfork32.asm | awk 'BEGIN {while(getline && $1 !~ /FASMCODE/);} {print}' > vfork32_prep.asm
;;; Compiling:
;;; fasm vfork32_prep.asm
;;;

#include <asm/unistd.h>
#include <unistd.h>
#include <sys/wait.h>

;;; after the next line only fasm syntax is permitted
FASMCODE

format ELF executable
entry $

        ;; create new process
        mov     eax, __NR_vfork
        int     0x80
        ;; check if child or parent
        test    eax, eax
        jnz     parent_process
        ;; child process
        ;; start sleep application
        mov     eax, __NR_execve
        mov     ebx, arg0
        mov     ecx, argv
        xor     edx, edx
        int     0x80
        ;; execve returns only if any error occured,
        ;; so here we exit child process
        mov     ebx, eax
        mov     eax, __NR_exit
        int     0x80

        ;; parent process
parent_process:
        ;; wait for child process to complete
        mov     ebx, eax
        mov     ecx, exit_status
        mov     edx, WUNTRACED
        xor     esi, esi
        mov     eax, __NR_wait4
        int     0x80
        ;; print "Thread completed" message
        mov     eax, __NR_write
        mov     ebx, STDOUT_FILENO
        mov     ecx, msg
        mov     edx, msg_size
        int     0x80
        mov     eax, __NR_write
        mov     ecx, status_ok
        mov     edx, status_ok_size
        ;; only the least 8 bits of the exit status
        cmp     byte [exit_status + 1], 0
        jz      ok
        mov     ecx, status_fail
        mov     edx, status_fail_size
ok:
        int     0x80
        ;; exit
        xor     ebx, ebx
        mov     eax, __NR_exit
        int     0x80

msg:
        db      "Thread completed! Exit status: "
msg_size = $ - msg

status_ok:
        db      "Succeeded", 0xa
status_ok_size = $ - status_ok

status_fail:
        db      "Failed", 0xa
status_fail_size = $ - status_fail

arg0:
        db      "/usr/bin/sleep", 0
;;         db      "/bin/true", 0
;;         db      "/bin/false", 0
arg1:
        db      "1", 0
argv:
        dd      arg0, arg1, 0

        segment readable writeable
        
exit_status:
        dd      -1    

;;;
;;; Preprocessing:
;;; cpp -C -m32 vfork32.asm | awk '/^[ \t]*;+[ \t]*FASMCODE/,EMPTY' > vfork32_prep.asm
;;; or
;;; cpp -C -m32 vfork32.asm | sed -n '/^[ \t]*;\+[ \t]*FASMCODE/,/$^/!b; p' > vfork32_prep.asm
;;;
;;; Compiling:
;;; fasm vfork32_prep.asm
;;;

#include <asm/unistd.h>
#include <unistd.h>
#include <sys/wait.h>

;;; after the next line only fasm code is permitted
;;; FASMCODE

;;; *** above fasm code here ***