系统调用的实现

已于 2022-07-25 10:15:00 修改
阅读量161 收藏
点赞数
分类专栏： Linux驱动 文章标签： 系统启动
于 2022-05-22 16:01:28 首次发布
本文链接：https://blog.csdn.net/m0_37844072/article/details/124911652
版权
  • 系统调用的搜索方法

系统调用xxx都是从sys_xxx作为函数入口的
但是系统中是无法搜到sys_xxx函数的，因为是通过宏定义生成的sys_xxx
{
    那想要查看实现：（1）搜SYSCALL_DEFINE (2)搜对应的参数
    比如--int socket (int __domain, int __type, int __protocol)系统调用 ---对应3个参数-->
    应该搜SYSCALL_DEFINE3(socket,
}

  • 系统调用的搜索例子

比如socket(int __domain, int __type, int __protocol);函数---->

SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)----->
层层展开就是调用的sys_socket(int __domain, int __type, int __protocol);

  • 系统调用sys_send--->应该去搜SYSCALL_DEFINEx(send, .....

  • 2.通过gcc -E来编译展开宏定义

  •   1.展开SYSCALL_DEFINE3
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
    {
    通过#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
    }
SYSCALL_DEFINEx(3, _open, const char __user *, filename, int, flags, umode_t, mode)
    
  •     2.展开SYSCALL_DEFINEx
#define SYSCALL_DEFINEx(x, sname, ...)                \
    SYSCALL_METADATA(sname, x, __VA_ARGS__)            \
    __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)    
    }

SYSCALL_METADATA(_open, 3, const char __user *, filename, int, flags, umode_t, mode) 
__SYSCALL_DEFINEx(3, _open, const char __user *, filename, int, flags, umode_t, mode)
  • 3.展开 SYSCALL_METADATA

       static const char *types__open[] =
            { __MAP(3, __SC_STR_TDECL, const char __user *, filename, int, flags,
                    umode_t, mode) };
        static const char *args__open[] =
            { __MAP(3, __SC_STR_ADECL, const char __user *, filename, int, flags,
                    umode_t, mode) };
                    

   SYSCALL_TRACE_ENTER_EVENT(_open);
        SYSCALL_TRACE_EXIT_EVENT(_open);

        static struct syscall_metadata __used __syscall_meta__open = {
            .name = "sys" "_open",
            .syscall_nr = -1,.nb_args = 3,
            .types = 3 ? types__open : NULL,
            .args = 3 ? args__open : NULL,
            .enter_event = &event_enter__open,
            .exit_event = &event_exit__open,
            .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields), 
        };
        static struct syscall_metadata __used
            __attribute__ ((section("__syscalls_metadata"))) * __p_syscall_meta__open =
            &__syscall_meta__open;
        asmlinkage long
        sys_open(__MAP
                 (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
                  mode)) __attribute__ ((alias(__stringify(SyS_open))));
  • 4.展开__SYSCALL_DEFINEx
		static inline long
		SYSC_open(__MAP
				  (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
				   mode));
		asmlinkage long
		SyS_open(__MAP
				 (3, __SC_LONG, const char __user *, filename, int, flags, umode_t,
				  mode));
		asmlinkage long
		SyS_open(__MAP
				 (3, __SC_LONG, const char __user *, filename, int, flags, umode_t,
				  mode))
		{
				long ret =
					SYSC_open(__MAP
							  (3, __SC_CAST, const char __user *, filename, int, flags,
							   umode_t, mode));
				__MAP(3, __SC_TEST, const char __user *, filename, int, flags, umode_t,
					  mode);
				__PROTECT(3, ret,
						  __MAP(3, __SC_ARGS, const char __user *, filename, int, flags,
								umode_t, mode));
				return ret;
		}

		static inline long
		SYSC_open(__MAP
				  (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
				   mode))
		{
				if (force_o_largefile())
						flags |= O_LARGEFILE;
				return do_sys_open(AT_FDCWD, filename, flags, mode);
		}

	}
  • 5.展开SYSCALL_TRACE_ENTER_EVENT
static struct syscall_metadata __syscall_meta__open;

static struct ftrace_event_call __used event_enter__open = {
        .class = &event_class_syscall_enter,
        {.name = "sys_enter" "_open",},
        .event.funcs = &enter_syscall_print_funcs,
        .data = (void *)&__syscall_meta__open,
        .flags = TRACE_EVENT_FL_CAP_ANY,
};

static struct ftrace_event_call __used
    __attribute__ ((section("_ftrace_events")))
    * __event_enter__open = &event_enter__open;;
  • 6.展开 SYSCALL_TRACE_EXIT_EVENT
{
static struct syscall_metadata __syscall_meta__open;

static struct ftrace_event_call __used event_exit__open = {
        .class = &event_class_syscall_exit,
        {.name = "sys_exit" "_open",},
        .event.funcs = &exit_syscall_print_funcs,
        .data = (void *)&__syscall_meta__open,
        .flags = TRACE_EVENT_FL_CAP_ANY,
};

static struct ftrace_event_call __used
    __attribute__ ((section("_ftrace_events")))
    * __event_exit__open = &event_exit__open;;

static struct syscall_metadata __used __syscall_meta__open = {
        .name = "sys" "_open",
        .syscall_nr = -1,
        .nb_args = 3,
        .types = 3 ? types__open : NULL,
        .args = 3 ? args__open : NULL,
        .enter_event = &event_enter__open,
        .exit_event = &event_exit__open,
        .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields),
};

static struct syscall_metadata __used
    __attribute__ ((section("__syscalls_metadata")))
    * __p_syscall_meta__open = &__syscall_meta__open;

asmlinkage long
sys_open(__MAP
         (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
          mode)) __attribute__ ((alias(__stringify(SyS_open))));

static inline long
SYSC_open(__MAP
          (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
           mode));

asmlinkage long
SyS_open(__MAP
         (3, __SC_LONG, const char __user *, filename, int, flags, umode_t,
          mode));

asmlinkage long
SyS_open(__MAP
         (3, __SC_LONG, const char __user *, filename, int, flags, umode_t,
          mode))
{
        long ret =
            SYSC_open(__MAP
                      (3, __SC_CAST, const char __user *, filename, int, flags,
                       umode_t, mode));
        __MAP(3, __SC_TEST, const char __user *, filename, int, flags, umode_t,
              mode);
        __PROTECT(3, ret,
                  __MAP(3, __SC_ARGS, const char __user *, filename, int, flags,
                        umode_t, mode));
        return ret;
}

static inline long
SYSC_open(__MAP
          (3, __SC_DECL, const char __user *, filename, int, flags, umode_t,
           mode))
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;
        return do_sys_open(AT_FDCWD, filename, flags, mode);
}
}

  • 3. 展开所有的东西

6.将上面的东西全部展开
{
    static const char *types__open[] = {
        "const char __user *",
        "int",
        "umode_t"
};

static const char *args__open[] = {
        "filename",
        "flags",
        "mode"
};

static struct syscall_metadata __syscall_meta__open;
static struct ftrace_event_call __used event_enter__open = {
        .class = &event_class_syscall_enter,
        {.name = "sys_enter" "_open",},
        .event.funcs = &enter_syscall_print_funcs,
        .data = (void *)&__syscall_meta__open,
        .flags = TRACE_EVENT_FL_CAP_ANY,
};

static struct ftrace_event_call __used
    __attribute__ ((section("_ftrace_events")))
    * __event_enter__open = &event_enter__open;;


static struct syscall_metadata __syscall_meta__open;
static struct ftrace_event_call __used event_exit__open = {
        .class = &event_class_syscall_exit,
        {.name = "sys_exit" "_open",},
        .event.funcs = &exit_syscall_print_funcs,
        .data = (void *)&__syscall_meta__open,
        .flags = TRACE_EVENT_FL_CAP_ANY,
};

static struct ftrace_event_call __used
    __attribute__ ((section("_ftrace_events")))
    * __event_exit__open = &event_exit__open;;



static struct syscall_metadata __used __syscall_meta__open = {
        .name = "sys" "_open",
        .syscall_nr = -1,
        .nb_args = 3,
        .types = 3 ? types__open : NULL,
        .args = 3 ? args__open : NULL,
        .enter_event = &event_enter__open,
        .exit_event = &event_exit__open,
        .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields),
};

static struct syscall_metadata __used
    __attribute__ ((section("__syscalls_metadata")))
    * __p_syscall_meta__open = &__syscall_meta__open;


asmlinkage long
sys_open(const char __user * filename, int flags, umode_t mode)
__attribute__ ((alias(__stringify(SyS_open))));

static inline long
SYSC_open(const char __user * filename, int flags, umode_t mode);

asmlinkage long
SyS_open(
        __typeof (
                __builtin_choose_expr (
                        (
                                __same_type((const char __user *)0, 0LL) ||
                                 __same_type((const char __user *)0, 0ULL)
                        ), 0LL, 0L
                )
        ) filename,
        __typeof (
                __builtin_choose_expr (
                        (
                                 __same_type((int)0, 0LL) ||
                                 __same_type((int)0, 0ULL)
                        ), 0LL, 0L
                )
        ) flags,
        __typeof (
                __builtin_choose_expr (
                        (
                                __same_type((umode_t) 0, 0LL) ||
                                __same_type((umode_t) 0, 0ULL)
                        ), 0LL, 0L
                )
        ) mode
);

asmlinkage long
SyS_open(
        __typeof (
                __builtin_choose_expr (
                        (
                                __same_type((const char __user *)0, 0LL) ||
                                 __same_type((const char __user *)0, 0ULL)
                        ), 0LL, 0L
                )
        ) filename,
        __typeof (
                __builtin_choose_expr (
                        (
                                __same_type((int)0, 0LL) ||
                                 __same_type((int)0, 0ULL)), 0LL, 0L
                )
        ) flags,
        __typeof (
                __builtin_choose_expr (
                        (
                                __same_type((umode_t) 0, 0LL) ||
                                __same_type((umode_t) 0, 0ULL)
                        ), 0LL, 0L
                )
        ) mode
) {
        long ret = SYSC_open((const char __user *)filename,
                        (int)flags, (umode_t) mode);

        (void) BUILD_BUG_ON_ZERO(
                !(
                        __same_type((const char __user *)0, 0LL) ||
                        __same_type((const char __user *)0, 0ULL)
                ) && sizeof(const char __user *) > sizeof(long)
        ),

        (void) BUILD_BUG_ON_ZERO(
                !(
                        __same_type((int)0, 0LL) ||
                        __same_type((int)0, 0ULL)
                ) && sizeof(int) > sizeof(long)
        ),

        (void) BUILD_BUG_ON_ZERO(
                !(
                        __same_type((umode_t) 0, 0LL) ||
                        __same_type((umode_t) 0, 0ULL)
                ) && sizeof(umode_t) > sizeof(long)
        );

        asmlinkage_protect(3, ret, filename, flags, mode);

        return ret;
}

static inline long
SYSC_open(const char __user * filename, int flags, umode_t mode)
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;
        return do_sys_open(AT_FDCWD, filename, flags, mode);
}
}

综上系统调用：

sys_open() == SyS_open() —> SYSC_open() —> do_sys_open()

L7256
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux驱动基础
zsffzb的博客
04-21 1095
APP打开的文件在内核中如何表示？ 我们在前面学习文件IO的过程中知道 当打开一个文件时，内核就会创建一个新的 打开文件表表项，也就是file结构体。file结构体保存了关于这个文件的许多信息。 APP打开文件时，可以得到一个整数，这个整数被称为文件句柄（文件描述符）。对于APP的每一个文件句柄，在内核里面都有一个“struct file”与之对应。 可以猜测，我们使用 open 打开文件时，传入的 flags、mode 等参数会被记录在内核 中对应的 struct file 结构体里(f_f
系统调用实现
在雨一方
01-20 2871
当用户态的进程调用一个系统调用时，CPU从用户态切换到内核态并开始执行一个内核函数。Linux通过由向量为128（0x80）的编程异常实现CPU由用户态到内核态的转换。 因为内核实现了许多不同的系统调用，为了区别他们，进程必须传递一个系统调用号的参数来识别所需的系统调用。EAX寄存器是负责传递系统调用号的。 系统调用处理程序执行下列操作： （1）在内核栈保存大多数寄存器的内容（这个操作对所有
系统调用如何实现
锄禾日当午
11-29 4546
系统调用的实现与一般过程调用的实现相比，两者间有很大差异。对于系统调用，控制是由原来的用户态转换为系统态，这是借助于中断和陷入机制来完成的，在该机制中包括中断和陷入硬件机构及中断与陷入处理程序两部分。 　　中断和陷入硬件机构 　　图1所示为中断的处理过程。中断可进一步分为外中断和内中断。外中断是指由于外部设备事件所引起的中断，如通常的磁盘中断、打印机中断等;而内中断则是指由于CPU内部事件所引
ARM linux 系统调用过程
JJ1116的博客
03-09 1967
Linux系统调用是系统提供的从用户空间进入内核空间的方式。每一种系统调用在内核都实现了其对应功能。 在应用层我们看到的是open()，read()，write()等由C库封装好的接口，这些接口都对应了一个内核函数sys_xxx() [sys_open()，sys_read()，sys_write()]。下面开始分析C库函数是怎么调用到内核函数sys_xxx()。 先提出问题： 1、如何进入内核？ 2、内核如何知道是发生了哪一种系统调用？ 3、进入内核做了哪些操作？ 现在开始解答这些问题： ..
系统调用实现过程
热门推荐
嘿嘿白日的博客
10-31 1万+
系统调用的实现与一般过程调用的实现相比，两者间有很大差异。对于系统调用，控制是由原来的用户态转换为系统态，这是借助于中断和陷入机制来完成的，在该机制中包括中断和陷入硬件机构及中断与陷入处理程序两部分。 　　中断和陷入硬件机构 　　图1所示为中断的处理过程。中断可进一步分为外中断和内中断。外中断是指由于外部设备事件所引起的中断，如通常的磁盘中断、打印机中断等;而内中断则是指由于CPU内部
系统调用简介和实现
weixin_46098612的博客
02-18 2039
1.系统调用的概念 **系统调用，顾名思义，说的是操作系统提供给用户程序调用的一组“特殊”接口。**用户程序可以通过这组“特殊”接口来获得操作系统内核提供的服务，比如用户可以通过文件系统相关的调用请求系统打开文件、关闭文件或读写文件，可以通过时钟相关的系统调用获得系统时间或设置定时器等。 从逻辑上来说，系统调用可被看成是一个内核与用户空间程序交互的接口——它好比一个中间人，把用户进程的请求传达给内核，待内核把请求处理完毕后再将处理结果送回给用户空间。 系统服务之所以需要通过系统调用来提供给用户空间的根本原
nachos系统调用实现Write、Read、Exec、Join
zhao_yuting的博客
05-09 8113
了解nachos系统调用的原理： 1.要实现nachos的系统调用，首先查看syscall.h当中声明的系统调用函数 可以发现Nachos已经为我们在syscall.h中声明好了这些系统调用函数。 2.观察Start.s中的汇编代码，定义了系统调用函数的实现 我们可以观察到Halt函数的实现是将系统调用类型（type）SC_Halt放入了2号寄存器中，然后执行sysc...
论文研究-Linux快速系统调用实现机制分析 .pdf
08-14
Linux快速系统调用实现机制分析，王宗涛，，本文首先介绍了快速系统调用指令SYSENTER/SYSEXIT出现的原因，然后详细介绍了X86体系结构下快速系统调用的实现策略和处理机制；最后对Li
三种方法实现Linux系统调用
09-15
以下是关于三种方法实现Linux系统调用的详细说明： 1. **通过glibc提供的库函数**： glibc（GNU C Library）是Linux环境下广泛使用的标准C库，它为程序员提供了大量的API，包括对系统调用的封装。glibc中的库函数...
Linux的系统调用实现机制与系统调用实例分析-Jin-Yang.pdf
08-24
"Linux 系统调用实现机制与系统调用实例分析" 一、系统调用概述 系统调用是操作系统中必不可少的一个组成部分，对于以该操作系统作为平台进行程序设计的程序员来说，系统调用提供了该系统面向用户的编程界面，程序...
Linux 系统调用实现机制实验报告-内核安装详解.pdf
11-01
【Linux 系统调用实现机制实验】 在深入探讨Linux系统调用的实现机制之前，首先需要理解系统调用的概念。系统调用是操作系统提供给应用程序的接口，它允许程序请求操作系统的服务，如进程控制、文件操作、内存管理...
华中科技大学操作系统课程设计——1.系统调用实现文件拷贝
06-13
1.1 利用系统调用实现文件拷贝（含代码和makefile） 1.2 多进程编程，实现三个子进程窗口（含代码和makefile） 2 自己的系统调用，只有系统调用实现的代码，系统调用需要自己编译内核 3 字符设备驱动的编写（含代码...
系统调用内核实现讲解
08-02
至于描述中提到的“神奇实验”，可能是模拟一个简单的系统调用实现，例如自定义一个打印消息的系统调用。通过这种方式，你可以亲自了解系统调用的注册、参数传递、处理流程以及返回到用户空间的过程，这对于理解系统...
Linux的syscall源码,Linux内核跟踪之syscall tracer
weixin_39673184的博客
05-12 432
------------------------------------------本文系本站原创,欢迎转载!转载请注明出处:http://ericxiao.cublog.cn/------------------------------------------一: 前言Syscall tracer是用来跟踪系统调用的,它会检测所有系统调用的入口和出口,再将相关的信息保存到ring buffer....
内核模块在/sys/module/xx/产生自己的配置文件
yldfree的博客
03-25 1198
下面代码会产生/sys/module/xxx/security/testhello 配置文件 #include <linux/kmod.h> #include <linux/module.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/kobject...
SOI_1-kernel:minix系统中的内核编译和系统调用实现
03-19
在"SOI_1-kernel:minix系统中的内核编译和系统调用实现"这个主题中，我们将深入探讨Minix内核的编译过程以及如何实现系统调用。 首先，让我们来看看Minix内核的编译步骤。在Minix系统中，内核是用C语言编写的，这与...
Linux系统调用.ppt
11-21
3. 增强了系统稳定性：因为系统调用是在内核实现的，内核可以通过系统调用来控制开放什么功能及什么权限给应用程序，从而避免用户程序不正确的使用硬件设备。 4. 分离用户程序和内核的开发：用户程序只需要关心系统...
在ksycall中对系统调用实现
最新发布
11-10
在ksycall中对系统调用的实现是通过底层的机制来实现的。ksycall（Kernel System Call）是指用户程序或应用程序通过系统调用接口（API）向操作系统内核发出请求，以便使用操作系统内核提供的功能或资源。 在ksycall...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值