linux c之syscall示例原型和运行时入口_start

最新推荐文章于 2025-07-28 23:40:26 发布
原创 最新推荐文章于 2025-07-28 23:40:26 发布 · 1.9k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了系统调用的实现机制，包括不同参数数量的系统调用处理方式，并展示了如何通过汇编指令进行系统调用。此外，还介绍了C语言程序启动时的初始化过程，包括设置参数和环境变量。

参考:https://github.com/lpsantil/rt0

/* Copyright (c) 2015, Louis P. Santillan <lpsantil@gmail.com>
 * All rights reserved.
 * See LICENSE for licensing details.
 */

#ifndef __RT0_SYSCALL__
#define __RT0_SYSCALL__

#include <rt0/rt0.h>
#include <asm-generic/errno.h>

#ifdef __LP64__
   #include <rt0/sys64.h>
#else
   #include <rt0/sys32.h>
#endif

long syscall6( long n, long a0, long a1, long a2, long a3, long a4, long a5 );

#ifndef __RT0_WITH_FASTER_SYSCALL__

#define syscall5( m, b0, b1, b2, b3, b4 )                            \
   syscall6( ( m ), ( b0 ), ( b1 ), ( b2 ), ( b3 ), ( b4 ), 0 )
#define syscall4( m, b0, b1, b2, b3 )                                \
   syscall5( ( m ), ( b0 ), ( b1 ), ( b2 ), ( b3 ), 0 )
#define syscall3( m, b0, b1, b2 )                                    \
   syscall4( ( m ), ( b0 ), ( b1 ), ( b2 ), 0 )
#define syscall2( m, b0, b1 )                                        \
   syscall3( ( m ), ( b0 ), ( b1 ), 0 )
#define syscall1( m, b0 )                                            \
   syscall2( ( m ), ( b0 ), 0 )
#define syscall0( m )                                                \
   syscall1( ( m ), 0 )

#else

long syscall5( long n, long a0, long a1, long a2, long a3, long a4 );
long syscall4( long n, long a0, long a1, long a2, long a3 );
long syscall3( long n, long a0, long a1, long a2 );
long syscall2( long n, long a0, long a1 );
long syscall1( long n, long a0 );
long syscall0( long n );

#endif

#endif
syscall.c 

/* Copyright (c) 2015, Louis P. Santillan <lpsantil@gmail.com>
 * All rights reserved.
 * See LICENSE for licensing details.
 */
#include <rt0/rt0.h>

#ifdef __LP64__
   #include <rt0/sys64.h>
#else
   #include <rt0/sys32.h>
#endif

#define __SYSCALL_OUTPUT_REG__            "=a" ( ret )

#define __SYSCALL_CHK_ERROR__()                      \
   ret = ( 0 > ret ? errno = -ret, -1 : ret )

#ifdef __LP64__
   #define __SYSCALL_OPCODE__                "syscall"

   #define __SYSCALL_PREAMBLE__()                    \
      register long r10 __asm__( "r10" ) = a3,       \
                    r08	__asm__( "r8" )  = a4,       \
                    r09 __asm__( "r9" )  = a5

   #define __SYSCALL_INPUT_REGS__                    \
      "a" ( n ), "D" ( a0 ), "S" ( a1 ), "d" ( a2 ), \
      "r" ( r08 ), "r" ( r09 ), "r" ( r10 )

   #define __SYSCALL_CLOBBERS__ "rcx", "r11", "memory"

#else
   #define __SYSCALL_OPCODE__              "int $0x80"

   #define __SYSCALL_PREAMBLE__()                    \
      register long ebp __asm__( "ebp" )  = a5

   #define __SYSCALL_INPUT_REGS__                    \
      "a" ( n ), "b" ( a0 ), "c" ( a1 ), "d" ( a2 ), \
      "S" ( a3 ), "D" ( a4 ), "r" ( ebp )

   #define __SYSCALL_CLOBBERS__               "memory"

#endif

long syscall6( long n, long a0, long a1, long a2, long a3, long a4, long a5 )
{
   long ret;
   __SYSCALL_PREAMBLE__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

#ifdef __RT0_WITH_FASTER_SYSCALL__

#ifdef __LP64__
   #define __SYSCALL_PREAMBLE5__()                    \
      register long r10 __asm__( "r10" ) = a3,        \
                    r08	__asm__( "r8" )  = a4
   #define __SYSCALL_PREAMBLE4__()                    \
      register long r10 __asm__( "r10" ) = a3
   #define __SYSCALL_PREAMBLE3__()
   #define __SYSCALL_PREAMBLE2__()
   #define __SYSCALL_PREAMBLE1__()
   #define __SYSCALL_PREAMBLE0__()

   #define __SYSCALL_INPUT_REGS5__                    \
      "a" ( n ), "D" ( a0 ), "S" ( a1 ), "d" ( a2 ),  \
      "r" ( r08 ), "r" ( r10 )
   #define __SYSCALL_INPUT_REGS4__                    \
      "a" ( n ), "D" ( a0 ), "S" ( a1 ), "d" ( a2 ),  \
      "r" ( r10 )
   #define __SYSCALL_INPUT_REGS3__                    \
      "a" ( n ), "D" ( a0 ), "S" ( a1 ), "d" ( a2 )
   #define __SYSCALL_INPUT_REGS2__                    \
      "a" ( n ), "D" ( a0 ), "S" ( a1 )
   #define __SYSCALL_INPUT_REGS1__                    \
      "a" ( n ), "D" ( a0 )
   #define __SYSCALL_INPUT_REGS0__                    \
      "a" ( n )

#else
   #define __SYSCALL_PREAMBLE5__()
   #define __SYSCALL_PREAMBLE4__()
   #define __SYSCALL_PREAMBLE3__()
   #define __SYSCALL_PREAMBLE2__()
   #define __SYSCALL_PREAMBLE1__()
   #define __SYSCALL_PREAMBLE0__()

   #define __SYSCALL_INPUT_REGS5__                    \
      "a" ( n ), "b" ( a0 ), "c" ( a1 ), "d" ( a2 ),  \
      "S" ( a3 ), "D" ( a4 )
   #define __SYSCALL_INPUT_REGS4__                    \
      "a" ( n ), "b" ( a0 ), "c" ( a1 ), "d" ( a2 ),  \
      "S" ( a3 )
   #define __SYSCALL_INPUT_REGS3__                    \
      "a" ( n ), "b" ( a0 ), "c" ( a1 ), "d" ( a2 )
   #define __SYSCALL_INPUT_REGS2__                    \
      "a" ( n ), "b" ( a0 ), "c" ( a1 )
   #define __SYSCALL_INPUT_REGS1__                    \
      "a" ( n ), "b" ( a0 )
   #define __SYSCALL_INPUT_REGS0__                    \
      "a" ( n )

#endif

long syscall5( long n, long a0, long a1, long a2, long a3, long a4 )
{
   long ret;
   __SYSCALL_PREAMBLE5__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS5__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

long syscall4( long n, long a0, long a1, long a2, long a3 )
{
   long ret;
   __SYSCALL_PREAMBLE4__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS4__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

long syscall3( long n, long a0, long a1, long a2 )
{
   long ret;
   __SYSCALL_PREAMBLE3__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS3__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

long syscall2( long n, long a0, long a1 )
{
   long ret;
   __SYSCALL_PREAMBLE2__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS2__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

long syscall1( long n, long a0 )
{
   long ret;
   __SYSCALL_PREAMBLE1__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS1__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

long syscall0( long n )
{
   long ret;
   __SYSCALL_PREAMBLE0__();

   __asm__ volatile( __SYSCALL_OPCODE__
                     : __SYSCALL_OUTPUT_REG__
                     : __SYSCALL_INPUT_REGS0__
                     : __SYSCALL_CLOBBERS__ );

   __SYSCALL_CHK_ERROR__();

   return( ret );
}

#endif
c语言运行时start函数入口。 

/* Copyright (c) 2015, Louis P. Santillan <lpsantil@gmail.com>
 * All rights reserved.
 * See LICENSE for licensing details.
 */

#include <rt0/rt0.h>

#ifdef __LP64__
   #define __STARTUP_PREAMBLE__() register long rax __asm__( "rax" )

   /* Setup the base */
   /* argc = RDI = [ RSP ] */
   /* argv = RSI = [ RSP+8 ] */
   /* envp = RDX = [ argv+8*argc+8 ] */
   /* align the stack */
   #define __STARTUP_ASM__                                           \
                     "pop	%rbp\n\t"                            \
                     "mov	%rsp,	%rbp\n\t"                    \
                     "mov	(0)(%rbp),	%rdi\n\t"            \
                     "lea	(8)(%rbp),	%rsi\n\t"            \
                     "lea	(8)(%rsi,%rdi,8),	%rdx\n\t"    \
                     "and	$-16,	%rsp\n\t"

   #define __STARTUP_GETRETVAL__ "=a"( rax )

   #define __STARTUP_RETVAL__ rax
#else
   #define __STARTUP_PREAMBLE__() register long eax __asm__( "eax" )

   /* Setup the base */
   /* Fix GCC's 'helpful" 16-byte alignment */
   /* argc = ECX = [ ESP ] */
   /* argv = EDX = [ ESP+8 ] */
   /* envp = EAX = [ argv+8*argc+8 ] */
   /* align the stack */
   /* push args onto re-aligned stack */
   #define __STARTUP_ASM__                                           \
                     "mov	%esp,	%ebp\n\t"                    \
                     "add	$0x1c,	%ebp\n\t"                    \
                     "mov	(0)(%ebp),	%ecx\n\t"            \
                     "lea	(4)(%ebp),	%edx\n\t"            \
                     "lea	(4)(%edx,%ecx,4),	%eax\n\t"    \
                     "and	$-16,	%esp\n\t"                    \
                     "push	%eax\n\t"                            \
                     "push	%edx\n\t"                            \
                     "push	%ecx\n\t"

   #define __STARTUP_GETRETVAL__ "=a"( eax )

   #define __STARTUP_RETVAL__ eax
#endif

/* pointer to array of char* strings that define the current environment variables */
char **__environ;
int errno;

void _start( void ) __attribute__((noreturn));

void _start( void )
{
   __STARTUP_PREAMBLE__();

   __asm__ volatile( __STARTUP_ASM__
                     "call	main" );

   _exit( __STARTUP_RETVAL__ );

   for(;;);
}





Syscall系统调用Linux内核跟踪
shengyin714959的博客
05-24 600
也就是说，所有系统调用都从用户空间中汇聚到0x80中断点，同时保存具体的系统调用号。当0x80中断处理程序运行时，将根据系统调用号对不同的系统调用分别处理，即调用不同的内核函数进行处理。实际上，真正调用的是系统函数syscall(SYS_read)，即sys_read()函数。fget_light() ：根据 fd 指定的索引，从当前进程描述符中取出相应的 file 对象（见图3）。##name是系统调用号，##指的是两次宏展开．即用实际的系统调用名字代替”name”,然后再把__NR。
28、Linux 文件与目录管理全解析
最新发布
h0i1j2k3l的博客
07-31 24
本文全面解析了Linux系统中文件与目录管理的相关操作，涵盖了工作目录切换、目录创建与删除、目录内容读取、链接管理等多个核心主题。文章详细介绍了各个系统调用如mkdir、rmdir、opendir、readdir、closedir、link、symlink和unlink的使用方法及其错误处理机制，并通过代码示例展示了实际应用场景。此外，还总结了操作流程，并提供了注意事项与最佳实践，帮助开发者高效、安全地进行Linux系统编程和管理。
Linux syscall
xiaozhi
11-23 361
Linux syscall
syscall函数用法
zhaominyong的专栏
07-22 1068
syscall 是 Linux 中直接触发内核系统调用的底层接口，通过指定系统调用号和参数实现用户态到内核态的切换‌。
Linux syscall 系统调用原理
LU_ZHAO的博客
02-15 725
syscall概念 内核提供用户空间程序与内核空间进行交互的一套标准接口，这些接口让用户态程序能受限访问硬件设备，比如申请系统资源，操作设备读写，创建新进程等。用户空间发生请求，内核空间负责执行，这些接口便是用户空间和内核空间共同识别的桥梁，这里提到两个字“受限”，是由于为了保证内核稳定性，而不能让用户空间程序随意更改系统，必须是内核对外开放的且满足权限的程序才能调用相应接口。 在用户空间和内核空...
linux syscall
Am_111的专栏
05-24 3835
linux syscall
Linux - 系统调用（syscall）
qazw9600的专栏
11-25 2294
syscall 原理
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #define _GNU_SOURCE #include <dlfcn.h> #include <sys/stat.h> #include <fcntl.h> #include <syscall.h> typedef void* (*hook_alloc)(size_t size); typedef void* (*hook_free)(void* ptr); typedef void (*hook_start)(); typedef void (*hook_exit)(int exit_code); typedef int (*hook_main)(int argc, char *argv[]); static char logname[1024] = "./hook.log"; static int fd = 0; void *malloc(size_t size){ static hook_alloc pmalloc = NULL; if(pmalloc == NULL){ pmalloc = (hook_alloc)dlsym(RTLD_NEXT, "malloc"); } static char buffer[128] = {0}; void *caller_addr = __builtin_return_address(0); void *ptr = pmalloc(size); sprintf(buffer, "%p: malloc:%p,%ld\n", caller_addr, ptr, size); write(1, buffer, 128); return ptr; } void free(void *ptr){ static hook_free pfree = NULL; if(pfree == NULL){ pfree = (hook_free)dlsym(RTLD_NEXT, "free"); } static char buffer[128] = {0}; void *caller_addr = __builtin_return_address(0); sprintf(buffer, "%p: free:%p\n", caller_addr, ptr); write(1, buffer, 128); pfree(ptr); } void _start(){ static hook_start pstart = NULL; const char msg[] = "\n!!! _START FUNCTION HIJACKED VIA LD_PRELOAD !!!\n"; syscall(SYS_write, STDOUT_FILENO, msg, sizeof(msg)-1); if(pstart == NULL){ pstart = (hook_start)dlsym(RTLD_NEXT, "_start"); if(pstart == NULL){ fprintf(stderr, "Failed to get original _start function\n"); _exit(1); } } fd = open(logname, O_RDWR | O_CREAT | O_APPEND, 0644); if(fd < 0){ fprintf(stderr, "Failed to open log file %s\n", logname); _exit(1); } printf("program start : open log file: %s\n", logname); pstart(); } static hook_exit pexit = NULL; __attribute__((noreturn)) void _exit(int exit_code){ if(pexit == NULL){ pexit = (hook_exit)dlsym(RTLD_NEXT, "_exit"); } printf("program exit : close log file: %s\n", logname); close(fd); pexit(exit_code); __builtin_unreachable(); // return; } // __attribute__((constructor)) void init() { // pexit = dlsym(RTLD_NEXT, "_exit"); // } // __attribute__((visibility("default"))) void _start(){} int main(int argc, char *argv[]){ static hook_main pmain = NULL; if(pmain == NULL){ pmain = (hook_main)dlsym(RTLD_NEXT, "main"); } fd = open(logname, O_RDWR | O_CREAT | O_APPEND, 0644); if(fd < 0){ fprintf(stderr, "Failed to open log file %s\n", logname); _exit(1); } printf("program start : open log file: %s\n", logname); return pmain(argc, argv); } 劫持main函数失败
07-03
不过，我们可以劫持调用main函数的函数，例如__libc_start_main（它是C运行时库的一部分，负责初始化并调用main函数）。因此，我们可以尝试劫持__libc_start_main函数。步骤：1.创建一个共享库，其中定义一个与__...
getdents64系统调用及示例
悟空看八戒烤熟了没的专栏c)4Upqt4SeVk
07-28 783
getdents64是 Linux 系统中用于读取目录内容的底层系统调用。可以把这个函数想象成一个"目录内容扫描仪"——它能够高效地扫描目录中的所有文件和子目录，就像超市的扫描枪快速读取商品条码一样。与高级的目录操作函数（如readdir）不同，getdents64是最底层的接口，直接与内核交互，提供了最大的灵活性和性能。它返回的是原始的目录项数据，包含文件名、inode 号、文件类型等信息。
Linux中的线程
zsffzb的博客
11-04 1931
1.线程的基本概念 2.线程和进程的区别 *线程的同步 线程的调度 线程的通信编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程_阳光日志-优快云博客_多线程和多进程编程线程是什么？要理解这个概念，须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制
Linux进程同步机制-Futex
nellson的专栏
03-20 1万+
引子在编译2.6内核的时候，你会在编译选项中看到[*] Enable futex support这一项，上网查，有的资料会告诉你"不选这个内核不一定能正确的运行使用glibc的程序"，那futex是什么？和glibc又有什么关系呢？1. 什么是FutexFutex 是Fast Userspace muTexes的缩写，由Hubertus Franke, Matthew Kirkwood, Ingo
Linux系统调用：使用syscall
Just For Fun
04-21 2899
引言 博主的另一篇博文介绍了如何使用 int 0x80 指令进行Linux系统调用，这一篇博文介绍一下如何使用另一种方式： syscall 指令进行Linux系统调用，然后会简要说明二者的不同。 Linux系统调用：使用 syscall 通过 syscall 指令进行Linux系统调用与通过 int 0x80 指令进行Linux系统调用在使用上差别不大，系统调用号依然通过 eax 传...
Linux上用syscall()方法调用系统接口
yinminsumeng的博客
04-21 1714
通常，常用的系统调用都有C语言的运行时封装，可以直接调用对应的C函数即可。例如：open、write等都是封装的系统调用。在Linux平台，可以使用syscall()函数调用系统提供的函数。使用系统调用编号调用对应的系统接口。有些系统调用没有提供C函数，只能通过syscall调用。例如：gettid，获取线程id。如果自己开发新增了一些系统接口，也可以使用syscall来调用。（fopen、fwrite是C标准库函数，这些是可移植的。下面例子演示用syscall的方式调用对应的系统调用。
linux下syscall函数，SYS_gettid，SYS_tgkill
lx_shudong的专栏
05-15 3935
原文：http://blog.chinaunix.net/uid-28458801-id-4630215.html NAME               syscall - 间接系统调用 SYNOPSIS               #define _GNU_SOURCE                #include        #include           
什麼是 "asmlinkage"？
zwdheo的专栏
03-31 483
有網友來信問到，kernel 裡的 system call 實作函數中（C 函數），為什麼每一個函數原型宣告的前面都有一個 "asmlinkage" 的字串？例如：asmlinkage long sys_nice(int increment)"asmlinkage" 是在 i386 system call 實作中相當重要的一個 gcc 標籤（tag）。當 system
linux 系统调用
热门推荐
b02042236的专栏
01-13 1万+
<br />5.1.5  如何使用系统调用<br />如图5.2所示，用户应用可以通过两种方式使用系统调用。第一种方式是通过C库函数，包括系统调用在C库中的封装函数和其他普通函数。 图5.2  使用系统调用的两种方式<br />第二种方式是使用_syscall宏。2.6.18版本之前的内核，在include/asm-i386/unistd.h文件中定义有7个_syscall宏，分别是：_syscall0(type,name)  _syscall1(type,name,type1,arg1)  _syscal
C++之Linux syscall实例总结(二百四十六)
Android系统攻城狮
10-26 796
本篇目的：理解Linux的syscall作用和用法。Linux的系统调用（System Call，简称syscall）是用户态程序与内核态之间进行交互的重要接口。通过系统调用，用户程序可以请求操作系统内核提供的特权功能，例如文件操作、进程管理、网络通信等。Linux系统中的系统调用通常采用软中断的方式实现。当用户程序需要使用系统调用时，它会通过指令将处理器从用户态切换到内核态，并触发软中断异常。操作系统内核会根据中断号（系统调用号）来确定需要执行的系统调用函数，进行相应的处理，然后返回结果给用户程序。
linux添加一个系统调用（syscall）
小小城御园的博客
02-12 4941
添加系统调用函数头文件 在include/linux/syscalls.h文件中的#endif前添加自己的系统调用函数声明，内容如下： asmlinkage long sys_test(void); 添加系统调用实现源码 随便找一个文件，我们在这个文件中添加系统调用的源码SYSCALL_DEFINE0(test) ，内容如下： SYSCALL_DEFINE0(test) { ...
linux系统调用SYSCALL_DEFINE
csdn
03-20 1434
内核代码中系统调用都是：SYSCALL_DEFINEx 宏，x表示参数个数。 这个宏参考博客：http://blog.csdn.net/hxmhyp/article/details/22699669 # 和 ## 使用参考博客： http://www.linuxidc.com/Linux/2014-06/102925.htm 经典的例子： ...
linux kernel SYSCALL_DEFINE3和SYSCALL_DEFINE6的区别
06-06
SYSCALL_DEFINE3和SYSCALL_DEFINE6都是Linux内核中用来定义系统调用的宏。它们的区别在于参数个数不同。 SYSCALL_DEFINE3用于定义有三个参数的系统调用，而SYSCALL_DEFINE6用于定义有六个参数的系统调用。 具体来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值