#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 5);
    printf("結果是: %d\n", result);
    return 0;
}

#include <stdio.h>

int main() {
    FILE *file = fopen("test.txt", "r");
    if (file == NULL) {
        perror("無法打開文件");
        return 1;
    }
    char buffer[100];
    size_t bytes_read = fread(buffer, 1, sizeof(buffer), file);
    if (bytes_read > 0) {
        printf("讀取的內容: %s\n", buffer);
    }
    fclose(file);
    return 0;
}

.section .data
msg:
    .ascii "Hello World!\n"
len = . - msg

.section .text
.globl  main
main:

    # ssize_t write(int fd, const void *buf, size_t count)
    mov $1, %rdi            # fd
    mov $msg, %rsi          # buffer
    mov $len, %rdx          # count
    mov $1, %rax            # write(2)系統(tǒng)調用號，64位系統(tǒng)為1
    syscall

    # exit(status)
    mov $0, %rdi            # status
    mov $60, %rax           # exit(2)系統(tǒng)調用號，64位系統(tǒng)為60
    syscall

$ gcc -o helloworld helloworld.s 
$ ./helloworld
Hello world!
$ echo $?
0

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>

static ssize_t my_write(struct file *file, const char __user *buf,
                        size_t len, loff_t *offset)
{
    /* 在這里設置斷點 */

    /* 打印調用堆棧 */
    dump_stack();

    /* 寫入操作的具體實現(xiàn) */
    // ...

    return len;
}

static struct file_operations fops = {
    .write = my_write,
};

static int __init my_init(void)
{
    /* 注冊字符設備驅動程序 */
    // ...

    return 0;
}

static void __exit my_exit(void)
{
    /* 注銷字符設備驅動程序 */
    // ...
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid = getpid();
    
    // 觸發(fā)系統(tǒng)調用
    syscall(39, pid, NULL, NULL);
    
    return 0;
}

#include <linux/kernel.h>
#include <linux/module.h>

MODULE_LICENSE("GPL");

// 聲明一個簡單的系統(tǒng)調用函數(shù)
asmlinkage long my_syscall(void)
{
    printk(KERN_INFO "Hello from custom syscall!\n");
    return 0;
}

// 初始化系統(tǒng)調用表
static void init_syscall_table(void)
{
    // 獲取syscall table地址
    unsigned long *syscall_table = (unsigned long *)kallsyms_lookup_name("sys_call_table");

    // 替換對應系統(tǒng)調用函數(shù)指針
    write_cr0(read_cr0() & (~0x10000));  // 關閉寫保護

    syscall_table[__NR_my_syscall] = (unsigned long)my_syscall;  // 將自定義系統(tǒng)調用函數(shù)指針存儲在syscall table中

    write_cr0(read_cr0() | 0x10000);  // 開啟寫保護
}

static int __init my_module_init(void)
{
    init_syscall_table();
    
    printk(KERN_INFO "Custom syscall module loaded\n");
    
    return 0;
}

static void __exit my_module_exit(void)
{
    printk(KERN_INFO "Custom syscall module unloaded\n");
}

module_init(my_module_init);
module_exit(my_module_exit);

ENTRY(entry_SYSCALL_64)
        TRACE_IRQS_OFF
        subq    $FRAME_SIZE, %rsp          /* Reserve space for pt_regs */
        MOV_LDX(regs, %rsp)                /* Save user stack pointer */
        cmpl    $(nr_syscalls),%eax        /* syscall number valid? */
        jae     badsys                     

        /*
         * Load the syscall table pointer into r10 from a global variable.
         * We stash it in memory at boot time to workaround boot loader
         * address randomization.
         *
         *     movl  sys_call_table(,%rax,8),%r10
         *
         * can be replaced with this:
         *
         *     leal  sys_call_table(%rip),%r10
         *     movq  (%r10,%rax,8),%r10
         */

       .section ".data", "a"
        
sys_call_table:
		.quad   __x64_sys_call_table- sys_call_table

       .section ".text", "ax"

leaq    sys_call_table(%rip),%r10      /* Get the syscall table address into r10 */
movq    (%r10,%rax,8), %r10            /* Load the corresponding system call handler */

make menuconfig  # 配置內核選項（可根據需要進行配置）
make -j$(nproc)  # 編譯內核
sudo gdb vmlinux  # 啟動 gdb，并加載編譯好的內核文件

break entry_SYSCALL_64  # 在 entry_SYSCALL_64 函數(shù)處設置斷點

target remote :1234  # 連接到 QEMU 調試服務器（如果使用 QEMU 進行內核調試）
continue             # 繼續(xù)執(zhí)行，使程序運行到設置的斷點處

disassemble /m entry_SYSCALL_64  # 使用 disassemble 命令反匯編 entry_SYSCALL_64 函數(shù)

/* arch/x86/include/asm/ptrace.h */
struct pt_regs {
/*
 * C ABI says these regs are callee-preserved. They aren't saved on kernel entry
 * unless syscall needs a complete, fully filled "struct pt_regs".
 */
    unsigned long r15;
    unsigned long r14;
    unsigned long r13;
    unsigned long r12;
    unsigned long rbp;
    unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
    unsigned long r11;
    unsigned long r10;  /* 程序傳遞到內核的第 4 個參數(shù)。 */
    unsigned long r9;   /* 程序傳遞到內核的第 6 個參數(shù)。 */
    unsigned long r8;   /* 程序傳遞到內核的第 5 個參數(shù)。 */
    unsigned long ax;   /* 程序傳遞到內核的系統(tǒng)調用號。 */
    unsigned long cx;   /* 程序傳遞到內核的 syscall 的下一條指令地址。 */
    unsigned long dx;   /* 程序傳遞到內核的第 3 個參數(shù)。 */
    unsigned long si;   /* 程序傳遞到內核的第 2 個參數(shù)。 */
    unsigned long di;   /* 程序傳遞到內核的第 1 個參數(shù)。 */
/*
 * On syscall entry, this is syscall#. On CPU exception, this is error code.
 * On hw interrupt, it's IRQ number:
 */
    unsigned long orig_rax; /* 系統(tǒng)調用號。 */
/* Return frame for iretq 
 * 內核態(tài)返回用戶態(tài)需要恢復現(xiàn)場的數(shù)據。*/
    unsigned long ip;       /* 保存程序調用 syscall 的下一條指令地址。 */
    unsigned long cs;       /* 用戶態(tài)代碼起始段地址。 */
    unsigned long flags;    /* 用戶態(tài)的 CPU 標志。 */
    unsigned long sp;       /* 用戶態(tài)的棧頂?shù)刂罚却媸窍蛳略鲩L的）。 */
    unsigned long ss;       /* 用戶態(tài)的數(shù)據段地址。 */
/* top of stack page */
};

ENTRY(entry_SYSCALL_64)
    ...
    call    do_syscall_64           /* returns with IRQs disabled */
    ...
END(entry_SYSCALL_64)

/* arch/x86/entry/common.c */
#ifdef CONFIG_X86_64
__visible void do_syscall_64(unsigned long nr, struct pt_regs *regs) {
    struct thread_info *ti;
    ...
    /*
     * NB: Native and x32 syscalls are dispatched from the same
     * table.  The only functional difference is the x32 bit in
     * regs->orig_ax, which changes the behavior of some syscalls.
     */
    nr &= __SYSCALL_MASK;
    if (likely(nr < NR_syscalls)) {
        nr = array_index_nospec(nr, NR_syscalls);
        /* 通過系統(tǒng)調用跳轉表，調用系統(tǒng)調用號對應的函數(shù)。
         * 函數(shù)返回值保存在 regs->ax 里，最后將這個值，保存到 rax 寄存器傳遞到用戶空間。 */
        regs->ax = sys_call_table[nr](regs);
    }

    syscall_return_slowpath(regs);
}
#endif

#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>

// 定義系統(tǒng)調用號與函數(shù)名的映射數(shù)組
static const char *syscall_names[] = {
    [0] = "sys_read",
    [1] = "sys_write",
    [2] = "sys_open",
    // ...
};

int main() {
    int i;

    // 遍歷系統(tǒng)調用號并打印對應的函數(shù)名
    for (i = 0; i < sizeof(syscall_names) / sizeof(syscall_names[0]); i++) {
        printf("Syscall number %d: %s\n", i, syscall_names[i]);
    }

    return 0;
}

syscall's number -> syscall -> entry_SYSCALL_64 -> do_syscall_64 -> sys_call_table -> __x64_sys_write

/* include/generated/asm-offsets.h */
#define __NR_syscall_max 547 /* sizeof(syscalls_64) - 1 */

/* arch/x86/entry/syscall_64.c */
#define __SYSCALL_64(nr, sym, qual) [nr] = sym,

/* arch/x86/entry/syscall_64.c */
asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
    /*
     * Smells like a compiler bug -- it doesn't work
     * when the & below is removed.
     */
    [0 ... __NR_syscall_max] = &sys_ni_syscall,
#include <asm/syscalls_64.h>
};

# arch/x86/entry/syscalls/Makefile
syscall64 := $(srctree)/$(src)/syscall_64.tbl
systbl := $(srctree)/$(src)/syscalltbl.sh
quiet_cmd_systbl = SYSTBL  $@
      cmd_systbl = $(CONFIG_SHELL) '$(systbl)' $< $@

# arch/x86/entry/syscalls/syscalltbl.sh
...
syscall_macro() {
    abi="$1"
    nr="$2"
    entry="$3"

    # Entry can be either just a function name or "function/qualifier"
    real_entry="${entry%%/*}"
    if [ "$entry" = "$real_entry" ]; then
        qualifier=
    else
        qualifier=${entry#*/}
    fi

    echo "__SYSCALL_${abi}($nr, $real_entry, $qualifier)"
}
...

/* arch/x86/include/generated/asm/syscalls_64.h */
...
#ifdef CONFIG_X86
__SYSCALL_64(0, __x64_sys_read, )
#else /* CONFIG_UML */
__SYSCALL_64(0, sys_read, )
#endif
#ifdef CONFIG_X86
__SYSCALL_64(1, __x64_sys_write, )
#else /* CONFIG_UML */
__SYSCALL_64(1, sys_write, )
#endif
...

asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
    /*
     * Smells like a compiler bug -- it doesn't work
     * when the & below is removed.
     */
    [0 ... __NR_syscall_max] = &sys_ni_syscall,
    [0] = __x64_sys_read,
    [1] = __x64_sys_write,
    ...

__do_sys_write() (/root/linux-5.0.1/fs/read_write.c:610)
__se_sys_write() (/root/linux-5.0.1/fs/read_write.c:607)
__x64_sys_write(const struct pt_regs * regs) (/root/linux-5.0.1/fs/read_write.c:607)
...

/* fs/read_write.c */
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
        size_t, count) {
    return ksys_write(fd, buf, count);
}

/* include/linux/syscalls.h */
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)

#define SYSCALL_DEFINEx(x, sname, ...)                \
    SYSCALL_METADATA(sname, x, __VA_ARGS__)           \
    __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

/* arch/x86/include/asm/syscall_wrapper.h */
#define __SYSCALL_DEFINEx(x, name, ...)                                \
    asmlinkage long __x64_sys##name(const struct pt_regs *regs);       \
    ALLOW_ERROR_INJECTION(__x64_sys##name, ERRNO);                     \
    static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));        \
    static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \
    asmlinkage long __x64_sys##name(const struct pt_regs *regs)        \
    {                                                                  \
        return __se_sys##name(SC_X86_64_REGS_TO_ARGS(x,__VA_ARGS__));  \
    }                                                                  \
    __IA32_SYS_STUBx(x, name, __VA_ARGS__)                             \
    static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))         \
    {                                                                  \
        long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__));     \
        __MAP(x,__SC_TEST,__VA_ARGS__);                                \
        __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));              \
        return ret;                                                    \
    }                                                                  \
    static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))

// linux-3.10/fs/read_write.c

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
	struct fd f = fdget(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		loff_t pos = file_pos_read(f.file);
		ret = vfs_read(f.file, buf, count, &pos);
		file_pos_write(f.file, pos);
		fdput(f);
	}
	return ret;
}

// include/linux/syscalls.h

#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)

// include/linux/syscalls.h

#define SYSCALL_DEFINEx(x, sname, ...)				\
	SYSCALL_METADATA(sname, x, __VA_ARGS__)			\
	__SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

 SYSCALL_METADATA(_read, 3, unsigned int, fd, char __user *, buf, size_t, count)
    __SYSCALL_DEFINEx(3, _read, unsigned int, fd, char __user *, buf, size_t, count)
    {
    	struct fd f = fdget_pos(fd);
    	ssize_t ret = -EBADF;
    	/* ... */

#define __PROTECT(...) asmlinkage_protect(__VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...)					\
	asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));	\
	static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__));	\
	asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))	\
	{								\
		long ret = SYSC##name(__MAP(x,__SC_CAST,__VA_ARGS__));	\
		__MAP(x,__SC_TEST,__VA_ARGS__);				\
		__PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));	\
		return ret;						\
	}								\
	SYSCALL_ALIAS(sys##name, SyS##name);				\
	static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__))

    asmlinkage long sys_read(unsigned int fd, char __user * buf, size_t count)
    	__attribute__((alias(__stringify(SyS_read))));

    static inline long SYSC_read(unsigned int fd, char __user * buf, size_t count);
    asmlinkage long SyS_read(long int fd, long int buf, long int count);

    asmlinkage long SyS_read(long int fd, long int buf, long int count)
    {
    	long ret = SYSC_read((unsigned int) fd, (char __user *) buf, (size_t) count);
    	asmlinkage_protect(3, ret, fd, buf, count);
    	return ret;
    }

    static inline long SYSC_read(unsigned int fd, char __user * buf, size_t count)
    {
    	struct fd f = fdget_pos(fd);
    	ssize_t ret = -EBADF;
    	/* ... */

[root@localhost ~]# uname -r
3.10.0-693.el7.x86_64
[root@localhost ~]# cat /proc/kallsyms | grep '\<sys_read\>'
ffffffff812019e0 T sys_read
[root@localhost ~]# cat /proc/kallsyms | grep '\<SYSC_read\>'
[root@localhost ~]# cat /proc/kallsyms | grep '\<SyS_read\>'
ffffffff812019e0 T SyS_read

// file: include/linux/linkage.h
#ifndef SYSCALL_ALIAS
#define SYSCALL_ALIAS(alias, name) asm(         \
    ".globl " VMLINUX_SYMBOL_STR(alias) "\n\t"  \
    ".set   " VMLINUX_SYMBOL_STR(alias) ","     \
          VMLINUX_SYMBOL_STR(name))
#endif

// file: include/linux/export.h
/*
 * Export symbols from the kernel to modules.  Forked from module.h
 * to reduce the amount of pointless cruft we feed to gcc when only
 * exporting a simple symbol or two.
 *
 * Try not to add #includes here.  It slows compilation and makes kernel
 * hackers place grumpy comments in header files.
 */
/* Indirect, so macros are expanded before pasting. */
#define VMLINUX_SYMBOL(x) __VMLINUX_SYMBOL(x)
#define VMLINUX_SYMBOL_STR(x) __VMLINUX_SYMBOL_STR(x)

#define __VMLINUX_SYMBOL(x) x
#define __VMLINUX_SYMBOL_STR(x) #x

// include/uapi/asm-generic/unistd.h

#define __NR_read 63
__SYSCALL(__NR_read, sys_read)

// arch/x86/syscalls/syscall_64.tbl

#
# 64-bit system call numbers and entry vectors
#
# The format is:
# <number> <abi> <name> <entry point>
#
# The abi is "common", "64" or "x32" for this file.
#
0	common	read			sys_read
1	common	write			sys_write
2	common	open			sys_open
3	common	close			sys_close
4	common	stat			sys_newstat
......

// arch/x86/syscalls/syscalltbl.sh

#!/bin/sh

in="$1"
out="$2"

grep '^[0-9]' "$in" | sort -n | (
    while read nr abi name entry compat; do
	abi=`echo "$abi" | tr '[a-z]' '[A-Z]'`
	if [ -n "$compat" ]; then
	    echo "__SYSCALL_${abi}($nr, $entry, $compat)"
	elif [ -n "$entry" ]; then
	    echo "__SYSCALL_${abi}($nr, $entry, $entry)"
	fi
    done
) > "$out"

__SYSCALL_COMMON(0, sys_read)

// arch/x86/syscalls/Makefile

syscall64 := $(srctree)/$(src)/syscall_64.tbl

systbl := $(srctree)/$(src)/syscalltbl.sh

$(out)/syscalls_64.h: $(syscall64) $(systbl)
	$(call if_changed,systbl)

section .data
    filename db 'test.txt', 0   ; 要讀取的文件名，以0結尾表示字符串結束
    buffer times 128 db 0       ; 用于存儲讀取內容的緩沖區(qū)，大小為128字節(jié)

section .bss
    fd resq 1                  ; 用于保存文件描述符，resq表示預留8字節(jié)空間（64位系統(tǒng)）
    bytes_read resq 1          ; 用于保存實際讀取的字節(jié)數(shù)

section .text
    global _start

_start:
    ; 打開文件，使用O_RDONLY標志表示只讀模式
    mov rax, 2                ; 將系統(tǒng)調用號2（open系統(tǒng)調用號）存入%rax寄存器
    mov rdi, filename         ; 將文件名的地址存入%rdi寄存器，作為open系統(tǒng)調用的第一個參數(shù)
    mov rsi, 0                ; 將打開文件的標志O_RDONLY（值為0）存入%rsi寄存器，作為第二個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)從用戶態(tài)到內核態(tài)的切換，執(zhí)行open系統(tǒng)調用

    mov [fd], rax             ; 將open系統(tǒng)調用返回的文件描述符保存到fd變量中

    ; 讀取文件內容到緩沖區(qū)
    mov rax, 0                ; 將系統(tǒng)調用號0（read系統(tǒng)調用號）存入%rax寄存器
    mov rdi, [fd]             ; 將文件描述符從fd變量中取出，存入%rdi寄存器，作為read系統(tǒng)調用的第一個參數(shù)
    mov rsi, buffer           ; 將緩沖區(qū)的地址存入%rsi寄存器，作為read系統(tǒng)調用的第二個參數(shù)
    mov rdx, 128              ; 將讀取的最大字節(jié)數(shù)128存入%rdx寄存器，作為read系統(tǒng)調用的第三個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)read系統(tǒng)調用，從文件中讀取內容到緩沖區(qū)

    mov [bytes_read], rax     ; 將read系統(tǒng)調用返回的實際讀取的字節(jié)數(shù)保存到bytes_read變量中

    ; 關閉文件
    mov rax, 3                ; 將系統(tǒng)調用號3（close系統(tǒng)調用號）存入%rax寄存器
    mov rdi, [fd]             ; 將文件描述符從fd變量中取出，存入%rdi寄存器，作為close系統(tǒng)調用的第一個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)close系統(tǒng)調用，關閉文件

    ; 退出程序
    mov rax, 60               ; 將系統(tǒng)調用號60（exit系統(tǒng)調用號）存入%rax寄存器
    xor rdi, rdi              ; 將退出狀態(tài)碼0存入%rdi寄存器，作為exit系統(tǒng)調用的第一個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)exit系統(tǒng)調用，程序結束

section .text
    global _start

_start:                       ; 創(chuàng)建子進程
    mov rax, 57               ; 將系統(tǒng)調用號57（clone系統(tǒng)調用號，用于創(chuàng)建進程，在Linux中clone可用于創(chuàng)建進程、線程等，這里用于創(chuàng)建進程）存入%rax寄存器
    xor rdi, rdi              ; 將%rdi寄存器清零，作為clone系統(tǒng)調用的第一個參數(shù)（這里參數(shù)為0，表示使用默認的克隆標志）
    xor rsi, rsi              ; 將%rsi寄存器清零，作為clone系統(tǒng)調用的第二個參數(shù)（通常用于傳遞棧指針，這里為0表示使用默認棧）
    xor rdx, rdx              ; 將%rdx寄存器清零，作為clone系統(tǒng)調用的第三個參數(shù)（通常用于傳遞父進程的標志，這里為0表示默認）
    xor r10, r10              ; 將%r10寄存器清零，作為clone系統(tǒng)調用的第四個參數(shù)（通常用于傳遞子進程的標志，這里為0表示默認）
    xor r8, r8                ; 將%r8寄存器清零，作為clone系統(tǒng)調用的第五個參數(shù)（通常用于傳遞新的線程組ID，這里為0表示默認）
    xor r9, r9                ; 將%r9寄存器清零，作為clone系統(tǒng)調用的第六個參數(shù)（通常用于傳遞新的父進程ID，這里為0表示默認）
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)clone系統(tǒng)調用，創(chuàng)建子進程

    cmp rax, 0                ; 比較clone系統(tǒng)調用的返回值（%rax寄存器）與0
    jz child                  ; 如果返回值為0，說明是子進程，跳轉到child標簽處執(zhí)行

    ; 父進程執(zhí)行的代碼
    mov rax, 60               ; 將系統(tǒng)調用號60（exit系統(tǒng)調用號）存入%rax寄存器
    xor rdi, rdi              ; 將退出狀態(tài)碼0存入%rdi寄存器，作為exit系統(tǒng)調用的第一個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)exit系統(tǒng)調用，父進程結束

child:
    ; 子進程執(zhí)行的代碼
    mov rax, 1                ; 將系統(tǒng)調用號1（write系統(tǒng)調用號）存入%rax寄存器
    mov rdi, 1                ; 將文件描述符1（標準輸出）存入%rdi寄存器，作為write系統(tǒng)調用的第一個參數(shù)
    mov rsi, msg              ; 將要輸出的消息的地址存入%rsi寄存器，作為write系統(tǒng)調用的第二個參數(shù)
    mov rdx, msg_len          ; 將消息的長度存入%rdx寄存器，作為write系統(tǒng)調用的第三個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)write系統(tǒng)調用，子進程向標準輸出打印消息

    mov rax, 60               ; 將系統(tǒng)調用號60（exit系統(tǒng)調用號）存入%rax寄存器
    xor rdi, rdi              ; 將退出狀態(tài)碼0存入%rdi寄存器，作為exit系統(tǒng)調用的第一個參數(shù)
    syscall                   ; 執(zhí)行系統(tǒng)調用，觸發(fā)exit系統(tǒng)調用，子進程結束

section .data
    msg db 'This is a child process!', 0xa, 0  ; 子進程要輸出的消息，0xa表示換行符，0表示字符串結束
    msg_len equ $ - msg                         ; 計算消息的長度

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define BUFFER_SIZE 128

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;

    // 打開文件，使用O_RDONLY標志表示只讀模式
    fd = open("test.txt", O_RDONLY);
    if (fd == -1) {
        perror("無法打開文件");
        return 1;
    }

    // 讀取文件內容到緩沖區(qū)
    bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("讀取文件失敗");
        close(fd);
        return 1;
    }

    // 輸出讀取到的內容
    write(1, buffer, bytes_read);

    // 關閉文件
    close(fd);

    return 0;
}

; 錯誤示例
mov rax, 0    ; read系統(tǒng)調用號
mov rdi, filename ; 錯誤地將文件名存入%rdi寄存器，應該存入文件描述符
mov rsi, buffer
mov rdx, 128
syscall

; 錯誤示例
mov rax, 5    ; 錯誤的系統(tǒng)調用號，open系統(tǒng)調用號應為2
mov rdi, filename
mov rsi, 0
syscall

; 正確示例，使用宏定義表示系統(tǒng)調用號
%define SYS_OPEN 2
mov rax, SYS_OPEN
mov rdi, filename
mov rsi, 0
syscall

// 低效的文件讀取方式，頻繁進行系統(tǒng)調用
#include <stdio.h>

int main() {
    FILE *file = fopen("large_file.txt", "r");
    if (file == NULL) {
        perror("無法打開文件");
        return 1;
    }
    char buffer[10];
    while (fread(buffer, 1, 10, file) > 0) {
        // 處理讀取到的數(shù)據
    }
    fclose(file);
    return 0;
}

// 優(yōu)化后的文件讀取方式，批量讀取數(shù)據
#include <stdio.h>

int main() {
    FILE *file = fopen("large_file.txt", "r");
    if (file == NULL) {
        perror("無法打開文件");
        return 1;
    }
    char buffer[1024];
    while (fread(buffer, 1, 1024, file) > 0) {
        // 處理讀取到的數(shù)據
    }
    fclose(file);
    return 0;
}