MIPS系统调用追踪(一)

最新推荐文章于 2024-06-27 21:12:44 发布
最新推荐文章于 2024-06-27 21:12:44 发布
阅读量1k 收藏 3
点赞数
分类专栏： 处理器架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wennuanddianbo/article/details/82909002
版权

说明：
内核版本：4.4
架构：mips64
c库：glibc-2.24

一、用户态到c库
这里以系统调用 sync_file_range举例。
原因有两点：一是这个系统调用在参数多达6个；二是参数中有64位参数，
这个系统调用的原型为：

int sync_file_range (int fd, __off64_t from, __off64_t to, unsigned int flags)
{
  return SYSCALL_CANCEL (sync_file_range, fd,
                         __LONG_LONG_PAIR ((long) (from >> 32), (long) from),
                         __LONG_LONG_PAIR ((long) (to >> 32), (long) to),
                         flags);
}

将这个SYSCALL_CANCEL宏层层展开后，sysnc_file_range的定义如下所示：

int
sync_file_range (int fd, __off64_t from, __off64_t to, unsigned int flags)
{
  return SYSCALL_CANCEL (sync_file_range, fd,
                         __LONG_LONG_PAIR ((long) (from >> 32), (long) from),
                         __LONG_LONG_PAIR ((long) (to >> 32), (long) to),
                         flags);
}

sync_file_range 展开==>

|SYSCALL_CANCEL (sync_file_range, fd,
                         __LONG_LONG_PAIR ((long) (from >> 32), (long) from),
                         __LONG_LONG_PAIR ((long) (to >> 32), (long) to),
                         flags);
==>
/* 为了表述方便 将上面的fd...flags这6个参数用a1~a6表示 */
|__SYSCALL_CALL (__VA_ARGS__) ==>
 |__SYSCALL_DISP (__SYSCALL, __VA_ARGS__) ==>
  |__SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) ==>
   |__SYSCALL6(sync_file_range, a1, a2, a3, a4, a5, a6)  ==>
    |INLINE_SYSCALL (sync_file_range, 6, a1, a2, a3, a4, a5, a6)

层展开后系统调用逐渐舒展开，最终到INLINE_SYSCALL()宏逐渐显露出系统调用的面目。对于mips64/n64，INLINE_SYSCALL展开如下：

#define INLINE_SYSCALL(name, nr, args...)                               \
  ({ INTERNAL_SYSCALL_DECL (_sc_err);                                   \	
     long result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args);      \
     if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) )              \
       {                                                                \
         __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err));    \
         result_var = -1L;                                              \
       }                                                                \
     result_var; })

这个宏大概包括三个部分：
(1) 变量申明
INTERNAL_SYSCALL_DECL (_sc_err)

/* sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h */
#define INTERNAL_SYSCALL_DECL(err) long err __attribute__ ((unused))

声明了一个变量err用于保存函数调用的错误值
(2) 执行系统调用
INTERNAL_SYSCALL (name, _sc_err, nr, args)
这个是整个宏的核心部分，其功能就是执行系统调用这个动作。
(3)返回值与错误码处理

INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err)和INTERNAL_SYSCALL_ERRNO (result_var, _sc_err)两个宏用于系统调用的返回值和错误码处理。

下面分别说一下第(2)和第(3)步。
1 执行系统调用
执行真正系统调用的宏INTERNAL_SYSCALL (name, _sc_err, nr, args)定义在 sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h 文件，展开如下：

#define INTERNAL_SYSCALL(name, err, nr, args...)                        \
        internal_syscall##nr ("li\t%0, %2\t\t\t# " #name "\n\t",        \
                              "IK" (SYS_ify (name)),                    \
                              0, err, args)

其中SYS_ify(syscall_name)展开后就是代表name对应的系统调用号：

#define SYS_ify(syscall_name)   __NR_##syscall_name

将系统调用name sync_file_range和SYS_ify宏展开后如下：

#define INTERNAL_SYSCALL(sync_file_range, err, 6, args...)                        \
        internal_syscall6 ("li\t%0, %2\t\t\t# " #sync_file_range "\n\t",        \
                              "IK" (__NR_sync_file_range),                    \
                              0, err, args)

接着，展开宏internal_syscall6：

#define internal_syscall6(v0_init, input, number, err,                  \
                          arg1, arg2, arg3, arg4, arg5, arg6)           \
({                                                                      \
        long _sys_result;                                               \
                                                                        \
        {                                                               \
        register long __s0 asm ("$16") __attribute__ ((unused))         \
          = (number);                                                   \
        register long __v0 asm ("$2");                                  \
        register long __a0 asm ("$4") = (long) (arg1);                  \
        register long __a1 asm ("$5") = (long) (arg2);                  \
        register long __a2 asm ("$6") = (long) (arg3);                  \
        register long __a3 asm ("$7") = (long) (arg4);                  \
        register long __a4 asm ("$8") = (long) (arg5);                  \
        register long __a5 asm ("$9") = (long) (arg6);                  \
        __asm__ volatile (                                              \
        ".set\tnoreorder\n\t"                                           \
        v0_init                                                         \
        "syscall\n\t"                                                   \
        ".set\treorder"                                                 \
        : "=r" (__v0), "+r" (__a3)                                      \
        : input, "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4),        \
          "r" (__a5)                                                    \
        : __SYSCALL_CLOBBERS);                                          \
        err = __a3;                                                     \
        _sys_result = __v0;                                             \
        }                                                               \
        _sys_result;                                                    \
})

将入参和其他宏展开到internal_syscall6中===>

#define internal_syscall6(v0_init, input, 0, err,                  
                     fd, __LONG_LONG_PAIR ((long) (from >> 32), (long) from),
			__LONG_LONG_PAIR ((long) (to >> 32), (long) to),flags)           
{                                                                      
        long _sys_result;                                               
                                                                        
        {
	  /*
 	    * 定义通用寄存器，并将入参放到合入的寄存器
	    * 对于mips n64，参数小于8个时依次放入a0~a7
	  */                                                               
        register long __s0 asm ("$16") __attribute__ ((unused))         
          = (number);                                                   
        register long __v0 asm ("$2");                                  
        register long __a0 asm ("$4") = (long) (arg1);                  
        register long __a1 asm ("$5") = (long) (arg2);                  
        register long __a2 asm ("$6") = (long) (arg3);                  
        register long __a3 asm ("$7") = (long) (arg4);                  
        register long __a4 asm ("$8") = (long) (arg5);                  
        register long __a5 asm ("$9") = (long) (arg6); 
        /* 下面这段内联汇编 开始真正系统调用 */                 
        __asm__ volatile (                                              
        ".set\tnoreorder\n\t"                                           
        "li\t%0, %2\t\t\t"  #sync_file_range "\n\t     /* 将系统调用号取到v0寄存器 */                                                    
        "syscall\n\t"                                  /* 前面参数已经准备就绪，执行syscall指令陷入内核 */                 
        ".set\treorder"                                                 
        : "=r" (__v0), "+r" (__a3)                                      
        : "IK" (__NR_sync_file_range), "r" (__a0), "r" (__a1), "r" (__a2), "r" (__a4),        
          "r" (__a5)                                                    
        : __SYSCALL_CLOBBERS);                                          
        err = __a3;                                   /* 系统调用的错误码存放在a3寄存器 */                                            
        _sys_result = __v0;                           /* 函数返回值存放在v0 */                  
        }                                                               
        _sys_result;                                                    
}

上面的internal_syscall6()宏主要做的两件事情：(1)设置参数;(2)执行syscall指令陷入内核; (3) 保存返回值和错误码。
关于函数中参数如何传递，可以参考在mips n64的ABI标准如下：
$2~$3对应v0~v1，用于函数返回值；
$4~$11对应a0~a7，用于参数传递；
$16~$23对应s0~s7，需要保存的寄存器。

2 返回值与错误码处理

前面long result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args);这个宏执行了真正的系统调用，执行完成后将返回值放到result_var，同时将a3寄存器的值放到_sc_err变量以指示是否发生错误。

     if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) )              
       {                                                                
         __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err));    
         result_var = -1L;                                              
       }                                                                
     result_var; })

将INTERNAL_SYSCALL_ERROR_P与INTERNAL_SYSCALL_ERRNO两个宏展开后即为：

if(((void) (result_var), (long) (_sc_err)))
{
  errno = ((void) (_sc_err), result_var);
  result_var = -1L; 
}

首先检查_sc_err是否为0，如果不为0表示系统调用失败，并将系统调用返回值result_var赋值给errno。这样用户程序就可以通过errno知道发生了什么错误。

 

二. 异常发生时cpu的工作
当异常发生时，cpu会进行如下工作：
(1) 设置EPC，指向异常返回的位置;
(2) Status寄存器EXL自动置位，这会强行进入核心态并禁止中断;
(3) 设置Cause寄存器，使得软件可以查到异常的原因;
(4) CPU从 "普通异常"向量入口点取指执行，接下来的工作就交给软件去执行了。
有几点需要进行说明：
首先，上述这些工作都是自动完成，不需要代码来干预；
其次，mips架构中一旦发生异常SR寄存器的EXL位会自动置位，例如我们这里执行”syscall”指令；
最后，这个"普通异常"处理入口并非系统调用处理函数的入口。

三. 异常处理点分析

第三章中提到异常发生时cpu会自动跳转到普通异常处理入口点取指令准备执行，然后剩下的时候就交由软件来处理了。
问题来了："普通异常"处理入口在哪里？它和syscall系统调用处理函数入口有何关系？
答案是："普通异常"处理入口在地址在ebase + 0x180 处。
其中ebase是异常入口基地址，也就是寄存器ebase的值；而ebase+0x180存放的是称为“普通(generic)异常”处理函数except_vec3_generic的代码。实际上内核在初始化初期是将except_vec3_generic处理代码拷贝到ebase + 0x180处，拷贝的大小为0x80；
而内核中所有"普通异常"处理函数地址集中起来放到一个unsigned long exception_handlers[32]的数组中，其中syscall"异常"的异常处理程序地址这个数组的第8号位，即index为8；在发生异常时Cause寄存器的ExcCode域置为8就表示发生了syscall"异常"。
上面这些地址的安装与准备都是在trap_init函数中实施的，大致情况如下：

trap_init-->
 |set_handler(0x180, &except_vec3_generic, 0x80);
  |memcpy((void *)(ebase + 0x180), &except_vec3_generic, 0x80);
 |set_except_vector(8, handle_sys);
  |xchg(&exception_handlers[8], handle_sys)

拷贝到ebase + 0x180处的except_vec3_generic代码的主要任务就是根据casue寄存器的ExcCode域值，结合except_handlers[]数组找到实际发生的异常对应的处理函数的入口地址，然后跳转到异常处理函数去执行对应的异常处理，如下所示：

/* arch/mips/kernel/genex.S */
NESTED(except_vec3_generic, 0, sp)
        .set    push
        .set    noat
#if R5432_CP0_INTERRUPT_WAR
        mfc0    k0, CP0_INDEX
#endif
        /* 取casue寄存器的ExcCode域到k1,即[bit6,bit2]*/
        mfc0    k1, CP0_CAUSE
        andi    k1, k1, 0x7c
#ifdef CONFIG_64BIT
        dsll    k1, k1, 1
#endif
       /* 根据ExcCode值将具体处理函数地址放到k0寄存器，然后跳转去执行 */
        PTR_L   k0, exception_handlers(k1)
        jr      k0
        .set    pop
        END(except_vec3_generic)

总结一下：
    A、Syscall异常入口函数为handle_sys；
    B、内核启动时先将Generic异常例程&except_vec3_generic拷贝到BASE+0X180处；
    C、再将syscall异常入口函数handle_sys放到全局数组&exception_handlers[8]中；
    D、当发生syscall异常，cpu自动跳转到BASE+0X180处执行except_vec3_generic，接着这个函数会根据cause寄存器的ExcCode域取出值8作为全局数组exception_handlers[]的index，这样就找到了syscall的异常入口函数handle_sys并跳转执行。
下一次，也就是MIPS系统调用追踪(二)中，我们将会探索mips-o32中系统调用处理函数handle_sys的详细实现流程，其中包括保留现场，堆栈切换，参数处理等等精彩内容，敬请期待。

温暖的电波
关注
专栏目录
浅谈分布式存储之sync详解
qq_23929673的博客
01-27 1261
文章目录前言posixsyncfsyncmsyncfdatasyncO_SYNCsync_file_range 前言 由于内存比磁盘读写速度快了好几个数量级，为了弥补磁盘IO性能低，Linux内核引入了页面高速缓存(PageCache)。我们通过Linux系统调用(open—>write)写文件时，内核会先将数据从用户态缓冲区拷贝到PageCache便直接返回成功，然后由内核按照一定的策略把...
c语言函数调用约定,MIPS下C语言函数调用规则
weixin_34983902的博客
05-20 893
现在mips上支持3种函数调用约定。1.被称为o32(old 32bit)的，现在被广泛应用的传统的约定2.n64(new 64bit),次模式中c语言常用的指针，和long都会被看成是是64bit，这将会带来很大程度上的误解。也会带来很多现在的程序无法执行。3.n32(new 32 bit),此模式能够很好的兼容现在广泛应用的代码。参数传递上和N64相同，但是c语言指针，和long还会以3...
一步一步学linux操作系统: 06 系统调用
墨1024
06-15 693
linux 内核，glibc 对系统调用的封装， 32 位系统调用过程，64 位系统调用过程
深入理解Unix/Linux中sync、fsync、fdatasync和sync_file_range系统调用以及他们的区别
最新发布
Go与Python双剑合一
06-27 1911
在linux内核中都有缓冲区或者页面高速缓存，大多数磁盘IO都是通过缓冲写的。当你想将数据write进文件时，内核通常会将该数据复制到其中一个缓冲区中，如果该缓冲没被写满的话，内核就不会把它放入到输出队列中。当这个缓冲区被写满或者内核想重用这个缓冲区时，才会将其排到输出队列中。等它到达等待队列首部时才会进行实际的IO操作。在进行数据库开发时，为了避免缓存中的数据还没有写入到磁盘就宕机导致的数据丢失，就需要使用fsync或这fdatasync来保证数据成功写入磁盘。
Linux系统调用
Jiajun Zhu
09-12 946
glibc版本2.34，kernel版本4.20以read为例，声明在/usr/include/unistd.h中，定义在glibc/sysdeps/unix/sysv/linux/read.c中。
64/32位Linux系统的差异(地址空间布局,系统调用)对比分析
tugouxp的专栏
05-09 2066
映射地址：可以看到，对应的地址0x7fd9b8c00000是PSE页，映射了10M，是PMD级的大页映射，也就是2M页面的映射。连续影射了5个PMD大页。这些大页的分配是在mmap后，执行memset(addr, 0x5a, ...)时通过page fault流程进行分配的，对应执行hugetlb_fault的执行流程。
MIPS® Architecture For Programmers
11-12
5. **异常和中断**：MIPS处理器如何处理异常事件，如硬件错误、软件中断以及系统调用，这些是操作系统和其他关键软件组件的基础。 6. **浮点处理**：MIPS架构还支持浮点运算，包括单精度和双精度浮点单元，这对于...
linux mips汇编指令集,MIPS汇编指令集
weixin_39527879的博客
05-12 1040
MIPS有三种指令格式：R型655556oprsrtrdshamtfunct功能：寄存器-寄存器ALU操作 (算术运算，逻辑运算)I型65516oprsrt立即数操作功能：条件分支，跳转J型626op跳转地址功能：跳转MIPS常用指令集lb / lh / lw: 从存储器中读取一个byte/half word/word的数据到寄存器中.sb/sh/sw: 把一个byte/h...
mips体系架构和堆栈操作
11-25
MIPS（Microprocessor without Interlocked Pipeline Stages）是一种精简指令集计算机（RISC）架构，广泛用于教学、嵌入式系统以及部分高性能计算领域。本文将深入探讨MIPS体系结构的基本概念，以及在该架构下如何...
Linux vdso的系统调用
三月未央的博客
10-13 4452
当你使用x86_64或arm64时, 执行特定的系统调用(如: gettimeofday), 使用strace来调用将无法看此任务系统调用, 这时就会百思不得其解. 此时, 你应该想到是不是被系统调用被vdso的方式给跳过了. 至于vdso的说明请参见: Linux vdso的由来我就被这样的调用方法给坑了一把, 众里寻它千百度啊…让我们自上而下的捋一下逻辑, 本文基于Android M线, arm
linux系统调用频繁,Linux下新系统调用sync_file_range
weixin_32743045的博客
05-03 482
我们在做数据库程序或者IO密集型的程序的时候，通常在更新的时候，比如说数据库程序，希望更新有一定的安全性，我们会在更新操作结束的时候调用fsync或者fdatasync来flush数据到持久设备去。而且通常是以页面为单位，16K一次或者4K一次。 安全性保证了，但是性能就有很大的损害。而且我们更新的时候，通常是更新文件的某一个页面，那么由于是更新覆盖操作，对文件系统的元数据来讲的话，无需变更，所以...
linux系统文件制作编译器,制作mipsel-linux交叉编译工具
weixin_42393929的博客
05-08 474
1 前言在嵌入式开发中，MIPs处理器是常见的几中处理器类型之一。另一方面，Linux是开源软件，应用范围很广， 因其对包括MIPS在内的多种嵌入式处理器架构的良好支持. 因此在嵌入式应用也.也大量采用Linux。在嵌入式开发过程中，很容易获得运行于x86架构PC上的Linux，并可使用其上的丰富的工具。gcc是Linux中一个很著名的C编译器，在编译Linux核心时，就要用到gcc。在PC机的L...
学习笔记：MIPS 交叉编译GLIB
wch3535 小牛在成长
10-12 1862
<br />1、echo ac_cv_type_long_long=yes>mips-linux.cache;echo glib_cv_long_long_format=ll>>mips-linux.cache;echo glib_cv_stack_grows=no>>mips-linux.cache;echo glib_cv_uscore=no>>mips-linux.cache;echo ac_cv_func_posix_getpwuid_r=yes>>mips-linux.cache;echo ac_
PostgreSQL 9.6 IO Hang问题浅析与优化
weixin_33762321的博客
09-29 513
背景 PostgreSQL检查点是将shared buffer中的脏页打标记，并集中将其刷到磁盘的动作（fsync）。（期间可能有刷盘的调度，降低当脏页很多时带来的IO影响） 在检查点之外，平时bgwriter进程则会使用bufferio的方式（write）将脏页写到OS的dirty page。 如果shared buffer非常大，而且数据库应用如果是...
fopen的默认缓冲大小和setvbuf 用法
mydear_33000的专栏
12-19 8859
《unix环境高级编程》是这么说的： 标准IO流操作读写普通文件是使用全缓冲的，默认缓冲区长度是该文件系统优先选用的IO长度（从stat结构得到的st_blksize值） //读取st_blksize的例子： int main(int argc, char* argv[]) {     if(argc!=2)     {         printf("2 argment
Linux fsync和fdatasync系统调用实现分析（Ext4文件系统）
热门推荐
My Linux Journey
03-18 1万+
本文将介绍Linux系统中的fsync和fdatasync的功能和区别，并以Ext4文件系统为例，详细分析内核如何将文件数据同步到磁盘。
Linux环境下编译redis报错:undefined reference to sync_file_range
nnnnnnnick_的博客
05-22 574
今天生产机环境下安装编译redis，解压完之后 make编译报错，undefined reference to ‘sync_file_range’ 放个生产环境图片： 尝试好多方法无果之后在github上看到了一个10年前的帖子，网站放这里：https://github.com/JackieXie168/redis/commit/baba838ca24a9766fae492c03c60a5809178720a 里面内容是让修改config.c得配置，我修改了半天还是不行，最后选择使用redis-2.4.1
Mips调用系统服务
05-26
MIPS CPU 可以通过系统调用指令 `syscall` 来调用系统服务。常用的系统服务包括文件 I/O、网络操作、进程控制等。 MIPS 调用系统服务的步骤如下： 1.将系统调用号存入寄存器 $v0 中。 2.将系统调用需要的参数存入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值