.include "defines.h" 
.data
hello:
    .ascii "hello world\n"

.text
    .globl _main
    
_main:
    
    movl $SYS_write, %eax
    movl $STDOUT,%ebx 
    movl $hello,%ecx
    movl $12,%edx
    int  $0x80

    movl $SYS_exit, %eax
    movl $3, %ebx
    int $0x80    
				

SYS_exit        = 1
SYS_fork        = 2
SYS_write       = 4
SYS_open        = 5
SYS_close       = 6
SYS_execve      = 11
SYS_lseek       = 19
SYS_dup2        = 63
SYS_mmap        = 90
SYS_munmap      = 91
SYS_socketcall      = 102
SYS_socketcall_socket   = 1
SYS_socketcall_bind = 2
SYS_socketcall_listen   = 4
SYS_socketcall_accept   = 5

SEEK_END        = 2
PROT_READ       = 1
MAP_SHARED      = 1

AF_INET         = 2
SOCK_STREAM     = 1
IPPROTO_TCP     = 6


STDOUT          = 1
				

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

#define STDOUT  1

int main()
{
    char *file="mmap.s";
    char *mappedptr;
    int fd,filelen;

    if ((fd=open(file, O_RDONLY)) < 0)
    {
        write(1, "error\n",6);
        exit(0);
    }
    if ((filelen=lseek(fd,0,SEEK_END)) == -1)
    {
        perror("seek error");
        exit(0);
    }
    printf("%d\n", filelen);
    mappedptr=mmap(NULL,filelen,PROT_READ,MAP_SHARED,fd,0);
    write(STDOUT, mappedptr, filelen);
    munmap(mappedptr, filelen);
    close(fd);
}
				

/* mmap.s */
.include "defines.h"

.data
fd:
        .long   0
fdlen:
        .long   0
mappedptr:
        .long   0

.text
.globl _start
_start:
        subl    $24,%esp

#       open(file, O_RDONLY);
        movl    $SYS_open,%eax
        movl    32(%esp),%ebx   # argv[1]을 가져온다. (%esp+8+24)
        xorl    %ecx,%ecx       # O_RDONLY로 설정한다.
        int     $0x80

        test    %eax,%eax       # 리턴값을 검사해서 <0 이면 종료한다.
        js      exit

        movl    %eax,fd         # open성공했다면 리턴값을 fd에 저장한다.

#       lseek(fd,0,SEEK_END);
        movl    %eax,%ebx       # fd를 첫번째 인자로
        xorl    %ecx,%ecx       # offset을 0으로
        movl    $SEEK_END,%edx
        movl    $SYS_lseek,%eax
        int     $0x80

        movl    %eax,fdlen      # 리턴값(파일길이)를 저장한다.

        xorl    %edx,%edx

#       mmap(NULL,fdlen,PROT_READ,MAP_SHARED,fd,0);
        movl    %edx,(%esp)
        movl    %eax,4(%esp)
        movl    $PROT_READ,8(%esp)
        movl    $MAP_SHARED,12(%esp)
        movl    fd,%eax
        movl    %eax,16(%esp)
        movl    %edx,20(%esp)

        movl    $SYS_mmap,%eax
        movl    %esp,%ebx
        int     $0x80

        movl    %eax,mappedptr  # save ptr

#       write(STDOUT, mappedptr, fdlen);
        movl    $STDOUT,%ebx
        movl    %eax,%ecx
        movl    fdlen,%edx
        movl    $SYS_write,%eax
        int     $0x80

#       munmap(mappedptr, fdlen);
        movl    mappedptr,%ebx
        movl    fdlen,%ecx
        movl    $SYS_munmap,%eax
        int     $0x80

#       close(fd);
        movl    fd,%ebx         # load file descriptor
        movl    $SYS_close,%eax
        int     $0x80
exit:
#       exit(0);
        movl    $SYS_exit,%eax
        xorl    %ebx,%ebx
        int     $0x80
        ret