linux下的系统调用函数到内核函数的追踪

最新推荐文章于 2024-01-20 15:09:20 发布
最新推荐文章于 2024-01-20 15:09:20 发布
阅读量1.1k 收藏 2
点赞数

转自：http://blog.chinaunix.net/uid-28458801-id-3468966.html
非常感谢！

使用的 glibc : glibc-2.17

使用的 linux kernel ：linux-3.2.07


 
系统调用是内核向用户进程提供服务的唯一方法，应用程序调用操作系统提供的功能模块（函数）。

用户程序通过系统调用从用户态（user mode）切换到核心态（kernel mode ），从而可以访问
相应的资源。这样做的好处是：
为用户空间提供了一种硬件的抽象接口，使编程更加容易。
有利于系统安全。
有利于每个进程度运行在虚拟系统中，接口统一有利于移植。

             运行模式、地址空间、上下文 ：

运行模式（mode）
Linux 使用了其中的两个： 特权级0和特权级3 ，即 内核模式(kernel mode) 和用户模式(user mode ）
地址空间（space ）
a）每个进程的虚拟地址空间可以划分为两个部分：用 户空间和内核空间
b）在用户态下只能访问用户空间；而在核心态下，既可以访问用户空间，又可以访问内核空间。 
c）内核空间在每个进程的虚拟地址空间中都是固定的 （虚拟地址为3G～4G的地址空间）。

上下文（context ）
一个进程的上下文可以分为三个部分：用户级上下文、寄存器上下文以及系统级上下文。
a）用户级上下文：正文、数据、用户栈以及共享存储区；
b）寄存器上下文：通用寄存器、程序寄存器（IP ）、处理机状态寄存器（EFLAGS）、栈指针（ESP）；
c）系统级上下文：进程控制块task_struct 、内存管理信息(mm_struct 、vm_area_struct、pgd 、pmd、
   pte 等)、核心栈等。

             系统调用、API和C 库
 
a）Linux 的 应用编程接口（API）遵循POSIX标准
 
b） Linux 的系统调用作为c库的一部分提供。c库中实现了Linux 的主要API，
   包括标准c库函数和系统调用。
 
c） 应用编程接口(API)其实是一组函数定义，这些函数说明了如何获得一个给定的服务；
   而 系统调用是通过软中断向内核发出一个明确的请求， 每个系统调用对应一个封装例程
  （wrapper routine，唯一目的就是发布系统调用）。一些API应用了封装例程。
      @a@ API还包含各种编程接口，如：C库函数、OpenGL 编程接口等
 
d） 系统调用的实现是在内核完成的，而用户态的函数是在函数库中实现的



           系统调用与操作系统命令

a） 操作系统命令相对应用编程接口更高一层，每个操作系统命令都是一个可执行程序，
   比如ls 、hostname 等，
 
b） 操作系统命令的实现调用了系统调用
 
c）通过  strace 命令可以查看操作系统命令所调用的系统调用，如：
   strace ls
   strace hostname

            系统调用与内核函数

a） 内核函数在形式上与普通函数一样，但它是在内核实现的，需要满足一些内核编程的要求
 
b）系统调用是用户进程进入内核的接口层，它本身并非内核函数，但它是由内核函数实现的
 
c）进入内核后，不同的系统调用会找到各自对应的内核函数，
   这些 内核函数被称为系统调用的“服务例程 ”

          系统调用处理程序及服务例程

a）当用户态的进程调用一个系统调用时，CPU切换
到内核态并开始执行一个内核函数
 
b）系统调用处理程序执行下列操作：
   @a@ 在内核栈 保存大多数寄存器的内容
 
   @b@ 调用名为 系统调用服务例程（system call service routine）的相应的C函数来
     处理系统调用
 
   @c@ 通过ret_from_sys_call(  ) 函数从系统调用返回

            系统调用流程





          系统调用中参数传递

a）每个系统调用至少有一个参数，即通过  eax 寄存器传递来的系统调用号
 
b）用寄存器传递参数 必须满足两个条件： 
   @a@  每个参数的长度不能超过寄存器的长度
 
   @b@  参数的个数不能超过6 个（包括eax 中传递的系统调用号），否则，
        用一个单独的寄存器指向进程地址空间中这些参数值所在的一个内存区
 
c）在少数情况下，系统调用不使用任何参数
 
d）服务例程的 返回值必须写到eax 寄存器中

很多系统调用需要不止一个参数
普通C函数的参数传递是通过把参数值写入堆栈(用户态堆栈或内核态堆栈)来实现的。
但因为系统调用是一种特殊函数，它由用户态进入了内核态，所以既不能使用用户态的堆栈
也不能直接使用内核态堆栈


在int $0x80汇编指令之前，系统调用的参数被写入CPU的寄存器。然后，在进入内核态调用系统调用服务例程之前，内核再把存放在CPU寄存器中的参数拷贝到内核态堆栈中。因为毕竟服务例程是C函数，它还是要到堆栈中去寻找参数的



                        系统调用小结
程序执行系统调用大致可归结为以下几个步骤：
 
1、程序调用libc 库的封装函数。
 
2、调用软中断int 0x80  进入内核。
 
3、在内核中首先执行system_call 函数（首先将系统调用号(eax)和可以
   用到的所有CPU寄存器保存到相应的堆栈中（由SAVE_ALL完成）），
   接着根据系统调用号在系统调用表中查找到对应的系统调用服务例程。
 
4、执行该服务例程。
 
5、执行完毕后，转入ret_from_sys_call 例程，从系统调用返回




在深入讨论内核和用户空间库如何实现系统调用的技术细节之前，
简要看一下内核以系统调用形式实际提供的各个函数是很有用处的。
每个系统调用都通过一个符号常数标识，符号常数的定义是平台相关的，
在内核源码  <include/asm_xx/unistd.h> 中指定,
XX表示平台相关，有些是  asm_arch,有的是  asm_generic 等


用于实现系统调用的处理程序函数，在形式上有如下几个共同的特性：
1， 每个函数的名称前缀都是 sys_ ,将该函数唯一地标识为一个系统调用，
   更精确的说，标识为一个系统调用的处理程序函数。

2， 所有的处理程序函数都最多接收 5 个参数。 否则，
    用一个单独的寄存器指向进程  地址空间中这些参数值所在的一个内存区即可

3， 所有的系统调用都在内核态执行。




系统调用由内核分配的一个编号唯一标识。
所有的系统调用都由一处中枢代码处理，根据调用编号和一个静态表，将调用分派到具体的函数。
传递的参数也是由中枢代码处理，这样参数的传递独立于实际的系统调用。

从用户态到内核态，以及调用分派和参数传递，都是由汇编语言代码实现的。

为容许用户态和内核态之间的切换，用户进程必须通过一条专用的机器指令，引起处理器/内核
对该进程的关注，这需要 C 标准库的协助。内核也必须提供一个例程，来满足切换请求并执行
相关操作。该例程不能在用户空间中实现，因为其中需要执行普通应用程序不允许执行的命令。

系统调用表 <linux/arch/arm/kernel/calls.S> (armV7)

点击(此处)折叠或打开

  1. /*
  2. * linux/arch/arm/kernel/calls.S
  3. *
  4. * Copyright (C) 1995-2005 Russell King
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. *
  10. * This file is included thrice in entry-common.S
  11. */
  12. /* 0 */ CALL(sys_restart_syscall)
  13. CALL(sys_exit)
  14. CALL(sys_fork_wrapper)
  15. CALL(sys_read)
  16. CALL(sys_write)
  17. /* 5 */ CALL(sys_open)
  18. CALL(sys_close)
  19. CALL(sys_ni_syscall) /* was sys_waitpid */
  20. CALL(sys_creat)
  21. CALL(sys_link)
  22. /* 10 */ CALL(sys_unlink)
  23. CALL(sys_execve_wrapper)
  24. CALL(sys_chdir)
  25. CALL(OBSOLETE(sys_time)) /* used by libc4 */




以系统调用 open() 函数为例:


1，X86 平台：

1，用户空间
   1，函数 open() 的声明
      @1@ 在使用 open（）函数时，要 include <fcntl.h>

点击(此处)折叠或打开  <glibc-2.17\include\fcntl.h>

  1. #ifndef _FCNTL_H
  2. #include <io/fcntl.h>

  4. #ifndef _ISOMAC
  5. /* Now define the internal interfaces. */
  6. extern int __open64 (const char *__file, int __oflag, ...);
  7. libc_hidden_proto (__open64)
  8. extern int __libc_open64 (const char *file, int oflag, ...);
  9. extern int __libc_open (const char *file, int oflag, ...);
  10. libc_hidden_proto (__libc_open)
  11. extern int __libc_creat (const char *file, mode_t mode);
  12. extern int __libc_fcntl (int fd, int cmd, ...);

  14. ...

点击(此处)折叠或打开   <glibc-2.17\io\fcntl.h>

  1. ...

  3. /* Open FILE and return a new file descriptor for it, or -1 on error.
  4.    OFLAG determines the type of access used. If O_CREAT is on OFLAG,
  5.    the third argument is taken as a `mode_t', the mode of the created file.

  7.    This function is a cancellation point and therefore not marked with
  8.    __THROW. */
  9. #ifndef __USE_FILE_OFFSET64
  10. extern int open (const char *__file, int __oflag, ...) __nonnull ((1));
  11. #else
  12. # ifdef __REDIRECT
  13. extern int __REDIRECT (open, (const char *__file, int __oflag, ...), open64)
  14.      __nonnull ((1));
  15. # else
  16. # define open open64
  17. # endif
  18. #endif
  19. #ifdef __USE_LARGEFILE64
  20. extern int open64 (const char *__file, int __oflag, ...) __nonnull ((1));
  21. #endif

  23. ...




点击(此处)折叠或打开

  1. /* Define a macro which expands inline into the wrapper code for a system
  2.    call. */
  3. # undef INLINE_SYSCALL
  4. # define INLINE_SYSCALL(name, nr, args...) \
  5.   ({                                     \
  6.     unsigned long int resultvar = INTERNAL_SYSCALL (name, , nr, args);     \
  7.     if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar, ), 0))     \
  8.       {                                     \
  9.     __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, ));         \
  10.     resultvar = (unsigned long int) -1;                 \
  11.       }                                     \
  12.     (long int) resultvar; })




2，内核空间

（1）系统启动时，对INT 0x80进行一定的初始化。

使用汇编子程序setup_idt（linux/arch/i386/kernel/head.S）初始化idt表（中断描述符表），这时所有的入口函数偏移地址都被设为ignore_int ，如下图所示。

2）用户程序需要系统提供服务的时候，会通过系统调用产生一个int 0x80的软中断，就会进入到系统调用的入口函数，入口函数存放在以下文件当中

点击(此处)折叠或打开    <arch\x86\kernel\entry_32.S>

  1. ENTRY(system_call) 
  2.     RING0_INT_FRAME # cant unwind into user space anyway 
  3.     pushl %eax      # save orig_eax ，将系统调用号压入栈中
  4.     CFI_ADJUST_CFA_OFFSET 4 
  5.     SAVE_ALL       #将寄存器的值压入堆栈当中，压入堆栈的顺序对应着结构体struct pt_regs ，
  6.                    #当出栈的时候，就将这些值传递到结构体struct pt_regs里面的成员，
  7.                    #从而实现汇编代码向C程序传递参数
  8.  
  9.     GET_THREAD_INFO(%ebp) 
  10.                   # system call tracing in operation / emulation 
  11.                #GET_THREAD_INFO宏获得当前进程的thread_info结构的地址，获取当前进程的信息。
  12.                #thread_inof结构中flag字段的_TIF_SYSCALL_TRACE或_TIF_SYSCALL_AUDIT 
  13.                #被置1。如果发生被跟踪的情况则转向相应的处理命令处。 

  15.     testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp) 

  17.    jnz syscall_trace_entry    #比较结果不为零的时候跳转。 
  18.                               #对用户态进程传递过来的系统调用号的合法性进行检查
  19.                               #如果不合法则跳到syscall_badsys标记的命令处。 

  21.    cmpl $(nr_syscalls), %eax 

  23.    jae syscall_badsys         #比较结果大于或者等于最大的系统调用号的时候跳转，不合法 
  24.                               #合法则跳转到相应系统调用号所对应的服务例程当中， 
  25.                               #也就是在sys_call_table表中找到了相应的函数入口点。 
  26.            #由于sys_call_table表的表项占4字节字节字节字节，因此获得服务例程指针的具体方法
  27.            #是将由eax保存的系统调用号乘以4再与sys_call_table表的基址相加。 

  29. syscall_call: 
  30.     call *sys_call_table(,%eax,4) 
  31.     movl %eax,PT_EAX(%esp)    # store the return value 将保存的结果返回。

点击(此处)折叠或打开   <arch\x86\include\asm\ptrace.h>

  1. struct pt_regs {
  2.     unsigned long bx;
  3.     unsigned long cx;
  4.     unsigned long dx;
  5.     unsigned long si;
  6.     unsigned long di;
  7.     unsigned long bp;
  8.     unsigned long ax;
  9.     unsigned long ds;
  10.     unsigned long es;
  11.     unsigned long fs;
  12.     unsigned long gs;
  13.     unsigned long orig_ax;
  14.     unsigned long ip;
  15.     unsigned long cs;
  16.     unsigned long flags;
  17.     unsigned long sp;
  18.     unsigned long ss;
  19. };


MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal0

接下来，会进入到系统调用表查找到系统调用服务程序的入口函数的地址，再进行跳转，

整个过程如下图所示：


  

MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal0

1,系统调用号:

点击(此处)折叠或打开       <arch\x86\include\asm\unistd_32.h>

  1. #ifndef _ASM_X86_UNISTD_32_H
  2. #define _ASM_X86_UNISTD_32_H

  4. /*
  5.  * This file contains the system call numbers.
  6.  */

  8. #define __NR_restart_syscall 0
  9. #define __NR_exit         1
  10. #define __NR_fork         2
  11. #define __NR_read         3
  12. #define __NR_write         4
  13. #define __NR_open         5
  14. #define __NR_close         6
  15. #define __NR_waitpid         7
MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal02,系统调用原型：

点击(此处)折叠或打开    <include\linux\syscalls.h>

  1. asmlinkage long sys_open(const char __user *filename,
  2.                 int flags, int mode);
   

MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal0

其中这里使用了一个宏asmlinkage ，我们再看一下它在系统里的定义：

点击(此处)折叠或打开    <arch\x86\include\asm\linkage.h>

  1. #ifdef CONFIG_X86_32
  2. #define asmlinkage CPP_ASMLINKAGE __attribute__((regparm(0)))
MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal0

后面的 __attribute__((regparm(0)))表示的是不通过寄存器来传递参数，通过栈来传递


    所以系统调用的入口函数里面参数的传递：

点击(此处)折叠或打开     <arch\x86\kernel\entry_32.S>

  1. ENTRY(system_call)
  2.     SAVE_ALL     #将寄存器的值压入堆栈当中，压入堆栈的顺序对应着结构体struct pt_regs ，
  3.                  #当出栈的时候，就将这些值传递到结构体struct pt_regs里面的成员，
  4.                  #从而实现从汇编代码向C程序传递参数。
    定义 SAVE_ALL 是将参数压到堆栈中，然后通过堆栈来进行参数的传递


3，获取系统调用入口函数：

点击(此处)折叠或打开    <arch\x86\kernel\entry_32.S>

  1. syscall_call:
  2.     call *sys_call_table(,%eax,4)
sys_call_table 每一项占用4个字节。system_call函数可以读取 eax 寄存器，获取当前系统调用的
系统调用号，将其乘以 4 生成偏移地址，然后以 sys_call_table 为基址，基址加上偏移地址
所指向的内容，既是应该调用的服务程序的地址。

点击(此处)折叠或打开         <arch\x86\kernel\syscall_table_32.S>

  1. ENTRY(sys_call_table)
  2.     .long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */
  3.     .long sys_exit
  4.     .long ptregs_fork
  5.     .long sys_read
  6.     .long sys_write
  7.     .long sys_open /* 5 */
  8.     .long sys_close
  9.     .long sys_waitpid
  10.     .long sys_creat
  11.     .long sys_link
  12.     .long sys_unlink /* 10 */
   在本例中，sys_open 是系统调用服务程序的入口地址

4，调用系统调用函数：（在新的内核中，函数的实现并不是直接通过 sys_xxx 函数，
                       而是通过一个宏的封装）
sys_open -> do_sys_open -> do_filp_open ->do_last-> nameidata_to_filp -> __dentry_open 

点击(此处)折叠或打开          <fs/open.c>

  1. SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
  2. {
  3.     long ret;

  5.     if (force_o_largefile())
  6.         flags |= O_LARGEFILE;

  8.     ret = do_sys_open(AT_FDCWD, filename, flags, mode);
  9.     /* avoid REGPARM breakage on x86: */
  10.     asmlinkage_protect(3, ret, filename, flags, mode);
  11.     return ret;
  12. }
其中宏 SYSCALL_DEFINE3 定义如下：

点击(此处)折叠或打开       <include\linux\syscalls.h>

  1. #ifdef CONFIG_FTRACE_SYSCALLS
  2. #define SYSCALL_DEFINE0(sname)                    \
  3.     SYSCALL_TRACE_ENTER_EVENT(_##sname);            \
  4.     SYSCALL_TRACE_EXIT_EVENT(_##sname);            \
  5.     static struct syscall_metadata __used            \
  6.      __syscall_meta__##sname = {                \
  7.         .name         = "sys_"#sname,            \
  8.         .syscall_nr    = -1,    /* Filled in at boot */    \
  9.         .nb_args     = 0,                \
  10.         .enter_event    = &event_enter__##sname,    \
  11.         .exit_event    = &event_exit__##sname,        \
  12.         .enter_fields    = LIST_HEAD_INIT(__syscall_meta__##sname.enter_fields), \
  13.     };                            \
  14.     static struct syscall_metadata __used            \
  15.      __attribute__((section("__syscalls_metadata")))    \
  16.      *__p_syscall_meta_##sname = &__syscall_meta__##sname;    \
  17.     asmlinkage long sys_##sname(void)
  18. #else
  19. #define SYSCALL_DEFINE0(name)     asmlinkage long sys_##name(void)
  20. #endif

  22. #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
  23. #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
  24. #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
  25. #define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
  26. #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
  27. #define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
在本例中，结合 sys_open 的定义：

点击(此处)折叠或打开    <include\linux\syscalls.h>

  1. asmlinkage long sys_open(const char __user *filename,
  2.                 int flags, int mode);
可以知道，SYSCALL_DEFINE3 中的数字 3 表示这个函数需要传递 3 个参数。
其中 “##”表示宏中字符直接，即：
SYSCALL_DEFINEx(3,_open,__VA_ARGS__)

其中 SYSCALL_DEFINEx 定义如下：

点击(此处)折叠或打开     <include\linux\syscalls.h>

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

其中 __SYSCALL_DEFINEx 定义如下：

点击(此处)折叠或打开      <include\linux\syscalls.h>

  1. #define __SYSCALL_DEFINEx(x, name, ...)                    \
  2.     asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__));        \
  3.     static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__));    \
  4.     asmlinkage long SyS##name(__SC_LONG##x(__VA_ARGS__))        \
  5.     {                                \
  6.         __SC_TEST##x(__VA_ARGS__);                \
  7.         return (long) SYSC##name(__SC_CAST##x(__VA_ARGS__));    \
  8.     }                                \
  9.     SYSCALL_ALIAS(sys##name, SyS##name);                \
  10.     static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__))
在本例中如下：

点击(此处)折叠或打开      <include\linux\syscalls.h>

  1. #define __SYSCALL_DEFINEx(3, _open, ...)                    \
  2.     asmlinkage long sys_open(__SC_DECL3(__VA_ARGS__));        \
  3.     static inline long SYSC_open(__SC_DECL3(__VA_ARGS__));    \
  4.     asmlinkage long SyS_open(__SC_LONG3(__VA_ARGS__))        \
  5.     {                                \
  6.         __SC_TEST3(__VA_ARGS__);                \
  7.         return (long) SYSC_open(__SC_CAST3(__VA_ARGS__));    \
  8.     }                                \
  9.     SYSCALL_ALIAS(sys_open, SyS_open);                \
  10.     static inline long SYSC_open(__SC_DECL3(__VA_ARGS__))
MicrosoftInternetExplorer402DocumentNotSpecified7.8Normal0

当我们自己定义一个不需要传递参数的系统调用的时候，可以这样定义我们的函数：

SYSCALL_DEFINE0(mycall)

{

printk("This is my_sys_call\n");

return 0;

}



5,对调用的函数进行解析

点击(此处)折叠或打开          <fs/open.c>

  1. SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
  2. {
  3.     long ret;

  5.     if (force_o_largefile())
  6.         flags |= O_LARGEFILE;

  8.     ret = do_sys_open(AT_FDCWD, filename, flags, mode);
  9.     /* avoid REGPARM breakage on x86: */
  10.     asmlinkage_protect(3, ret, filename, flags, mode);
  11.     return ret;
  12. }
@a1@  open的核心处理在函数 do_sys_open() 中

点击(此处)折叠或打开       <fs/open.h>

  1. long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
  2. {
  3.     struct open_flags op;
  4.     int lookup = build_open_flags(flags, mode, &op);

  6.     /*获取文件名，getname()函数内部首先创建存取文件名的内存空间，
  7.       然后从用户空间把文件名拷贝到内存空间来*/
  1.     char *tmp = getname(filename);  
  2.     int fd = PTR_ERR(tmp);

  4.     if (!IS_ERR(tmp)) {

  6. /*获取一个可用的 fd,该函数通过调用 alloc_fd() 函数从 fd_table 中获取一个可用的 fd，
  7.  *并做一些简单的初始化。
  8.  *需要注意的是：文件描述符 fd，只对本进程有效，也就是说这个 fd 只在该进程中可见，
  9.               在别的进程中可能不没有使用或是表示别的文件。
  10.  */
  11.         fd = get_unused_fd_flags(flags);
  12.         if (fd >= 0) {

  14. /*文件描述符 fd 获取成功，则打开文件，创建一个 file 对象
  15.  */
  16.             struct file *f = do_filp_open(dfd, tmp, &op, lookup);
  17.             if (IS_ERR(f)) {
  18.                 //打开失败，释放 fd
  19.                 put_unused_fd(fd);
  20.                 fd = PTR_ERR(f);
  21.             } else {

  23. /*如果文件已经打开，根据 inode 所指定的信息进行打开函数，函数（参数为 f）将该文件加入到
  24.  *文件监控的系统中。该系统是用来监控文件被打开，创建，读写，关闭，修改等操作的。
  25.  */
  26.                 fsnotify_open(f);

  28. /*将文件指针安装在 fd 数组中，
  29.  *将 struct file *f 加入到 fd 索引位置处 的数组中。在后续过程中，有对这个文件描述符操作的话，
  30.  *就会通过查找该数组得到对应的文件结构，然后进行相关的操作
  31.  */
  32.                 fd_install(fd, f);
  33.             }
  34.         }
  35.         //释放放置从用户空间拷贝过来的文件名的存储空间
  36.         putname(tmp);
  37.     }
  38.     return fd;
  39. }


点击(此处)折叠或打开    <include/linux/namei.h>

  1. struct nameidata {
  2.     struct path    path;   //当前目录的数据结构
  3.     struct qstr    last;   //用以保存当前目录的名称
  4.     struct path    root;
  5.     struct inode    *inode; /* path.dentry.d_inode */
  6.     unsigned int    flags;
  7.     unsigned    seq;
  8.     int        last_type;
  9.     unsigned    depth;     //连接文件的深度
  10.     char *saved_names[MAX_NESTED_LINKS + 1];

  12.     /* Intent data */
  13.     union {
  14.         struct open_intent open;
  15.     } intent;
  16. };

do_filp_open()解析：

点击(此处)折叠或打开        <fs/namei.c>

  1. struct file *do_filp_open(int dfd, const char *pathname,
  2.         const struct open_flags *op, int flags)
  3. {
  4.     struct nameidata nd;
  5.     struct file *filp;

  7.     /*根据目录打开文件
  8.      */
  1.     filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
  2.     if (unlikely(filp == ERR_PTR(-ECHILD)))
  3.         filp = path_openat(dfd, pathname, &nd, op, flags);
  4.     if (unlikely(filp == ERR_PTR(-ESTALE)))
  5.         filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
  6.     return filp;
  7. }
path_openat（）：

点击(此处)折叠或打开        <fs/namei.c>

  1. static struct file *path_openat(int dfd, const char *pathname,
  2.         struct nameidata *nd, const struct open_flags *op, int flags)
  3. {
  4.     struct file *base = NULL;
  5.     struct file *filp;
  6.     struct path path;
  7.     int error;

  1. ...
  2.     current->total_link_count = 0;

  4.     //对路径进行解析
  5.     error = link_path_walk(pathname, nd);
  6.     if (unlikely(error))
  7.         goto out_filp;

  9.     filp = do_last(nd, &path, op, pathname);
  10. ...
  11. }
link_path_walk（）：

点击(此处)折叠或打开          <fs/namei.c>

  1. /*
  2.  * Name resolution.
  3.  * This is the basic name resolution function, turning a pathname into
  4.  * the final dentry. We expect 'base' to be positive and a directory.
  5.  *
  6.  * Returns 0 and nd will have valid dentry and mnt on success.
  7.  * Returns error and drops reference to input namei data on failure.
  8.  */
  9. static int link_path_walk(const char *name, struct nameidata *nd)
  10. {
  11.     struct path next;
  12.     int err;
  13.     
  14. ...
  15.         //查找文件
  16.      err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
  17.         if (err < 0)
  18.             return err;
  19. ...
  20. }
walk_component ():

点击(此处)折叠或打开          <fs/namei.c>

  1. static inline int walk_component(struct nameidata *nd, struct path *path,
  2.         struct qstr *name, int type, int follow)
  3. {
  4.     struct inode *inode;
  5.     int err;
  6.     /*
  7.      * "." and ".." are special - ".." especially so because it has
  8.      * to be able to know about the current root directory and
  9.      * parent relationships.
  10.      */
  11. ...
  12.     //查找文件的具体实现
  13.     err = do_lookup(nd, name, path, &inode);
  14.     if (unlikely(err)) {
  15.         terminate_walk(nd);
  16.         return err;
  17.     }
  18.   ...
  19. }

最后根据条件打开设备：

点击(此处)折叠或打开        <fs/namei.c>

  1. /*
  2.  * Handle the last step of open()
  3.  */
  4. static struct file *do_last(struct nameidata *nd, struct path *path,
  5.              const struct open_flags *op, const char *pathname)
  6. {
  7.     struct dentry *dir = nd->path.dentry;
  8.     struct dentry *dentry;
  9.     int open_flag = op->open_flag;
  10.     int will_truncate = open_flag & O_TRUNC;
  11.     int want_write = 0;
  12.     int acc_mode = op->acc_mode;
  13.     struct file *filp;
  14.     int error;

  16.     nd->flags &= ~LOOKUP_PARENT;
  17.     nd->flags |= op->intent;

  19. ...

  21. common:
  22.     error = may_open(&nd->path, acc_mode, open_flag);
  23.     if (error)
  24.         goto exit;
  25.     //打开设备
  26.     filp = nameidata_to_filp(nd);
  27. ...
  28. }

点击(此处)折叠或打开

  1. /**
  2.  * nameidata_to_filp - convert a nameidata to an open filp.
  3.  * @nd: pointer to nameidata
  4.  * @flags: open flags
  5.  *
  6.  * Note that this function destroys the original nameidata
  7.  */
  8. struct file *nameidata_to_filp(struct nameidata *nd)
  9. {
  10.     const struct cred *cred = current_cred();
  11.     struct file *filp;

  13.     /* Pick up the filp from the open intent */
  14.     filp = nd->intent.open.file;
  15.     nd->intent.open.file = NULL;

  17.     /* Has the filesystem initialised the file for us? */
  18.     if (filp->f_path.dentry == NULL) {
  19.         path_get(&nd->path);

  21.         /*填充一个 struct file 结构，打开设备的具体实现
  22.          */
  23.  filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp,
  24.                NULL, cred);
  25.     }
  26.     return filp;
  27. }

点击(此处)折叠或打开

  1. static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
  2.                     struct file *f,
  3.                     int (*open)(struct inode *, struct file *),
  4.                     const struct cred *cred)
  5. {
  6.     static const struct file_operations empty_fops = {};
  7.     struct inode *inode;
  8.     int error;

  10.     f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
  11.                 FMODE_PREAD | FMODE_PWRITE;

  13.     if (unlikely(f->f_flags & O_PATH))
  14.         f->f_mode = FMODE_PATH;

  16. ...
  17.     if (!open && f->f_op)

  19.           //调用 def_chr_fops里的open函数，即chrdev_dev
  20.         open = f->f_op->open;  
  21.     if (open) {
  22.         error = open(inode, f);   //执行该设备的 open 函数
  23.         if (error)
  24.             goto cleanup_all;
  25.     }
  26. ...
  27. }

@a DONE@
missingu1314
关注
Linux系统调试课：内核函数调用堆栈打印方法汇总
内核笔记
03-23 1835
📢本篇将对驱动调试方法进行汇总学习。
linux调用ko的函数,linux 内核模块函数调用
weixin_39666550的博客
05-03 1747
在编写linux内核模块的时候，有时候我们需要调用一只内核模块里面的函数，然而如果是在不同目录下面编译生成的内核模块，此时A模块去调用B模块的函数时候会出现函数未定义，无法调用的情况。那么以前我是在同一个目录下面，先后写两个makefile，然后编译生成两个不同的内核模块，这种方式可以正常实现A模块调用B模块里面的函数，不过非常麻烦。本博文将会针对这种情况提出一种可以同时生成多个内核模块，不要再次...
系统调用入口函数源码分析system_call——X86_64
zdd_11111的博客
05-13 8047
在实验中用到这一块，就去看源码分析整理了一下，全部为个人理解。有错误的地方，希望和大牛交流。 首先解释一下，我实验的目的是获得系统调用入口函数system_entry的起始地址和函数大小。 在linux-3.10.1, x86 64位的系统下，系统调用的入口地址保存在MSR寄存器中，通过rdmsrl(MSR_LSTAR,ksystem_call);便可获得系统调用的入口地址，然后对该入口地址进
Linux系统中的函数跳转，setjmp() 和longjmp()的使用
记录和分享程序人生的点点滴滴
07-06 2338
setjmp() 和longjmp()用来进行函数的跳转，并且可以跳回到原来的位置继续执行。当程序员希望在某个时刻，跳回到以前的一个位置执行的时候，setjmp() 和longjmp()就派上用场了。
【Linux】Linux系统调用函数（300多个）
crr411422的博客
05-13 4299
一、初级I/O函数二、文件管理操作函数三、标准I/O函数四、格式化输入输出函数五、进程控制六、进程间通信函数七、信号函数八、用户、组函数及环境变量函数九、错误处理与内存分配函数十、日志函数、动态函数与正则表达式函数十一、时间函数十二、socket相关函数十三、字符测试函数十四、数据转换函数十五、字符串处理函数十六、数学计算函数十七、随机数及数据加密函数十八、数据结构函数十九、其他函数
万字解析Linux内核调试之动态追踪
youzhangjing_的博客
03-30 805
动态追踪技术，是通过探针机制来采集内核或者应用程序的运行信息，从而可以不用修改内核或应用程序的代码，就获得调试信息，对问题进行分析、定位。通常在排查和调试异常问题时，我们首先想到的是使用 GDB 在程序运行路径上设置断点，然后结合命令进行分析定位；或者，在程序源码中增加一系列的日志，从日志输出中寻找线索。不过，断点往往会中断程序的正常运行；而增加新的日志，往往需要重新编译和部署。在面对偶现问题以及对时延要求严格的场景下，GDB 和增加日志的方式就不能满足需求了。
系统调用
fay8048的博客
06-05 1036
 系统调用目 录系统调用系统调用简述宏系统调用表系统调用入口函数系统调用实现过程函数名约定系统调用号系统调用表从ptrace系统调用命令到INT 0X80中断请求的转换系统调用功能模块的初始化内核服务代码分析：mlock
LINUX的系统调用与函数调用.pdf
09-07
在Linux操作系统中，系统调用和函数调用是两种不同的程序交互方式，它们各自有着独特的特性和应用场景。本文主要探讨了Linux系统调用和函数调用的区别以及它们在系统中的作用。 首先，系统调用是操作系统为应用程序...
详解Linux内核进程调度函数schedule()的触发和执行时机
01-20
内核的调度操作分为触发和执行两个部分，触发时仅仅设置一下当前进程的TIF_NEED_RESCHED标志，执行的时候则是通过schedule()函数来完成进程的选择和切换。当前进程的thread_info->flags中TIF_NEED_RESCHED位表示需要...
Linux内核函数调用关系的验证方法.pdf
09-06
【Linux内核函数调用关系的验证方法】 Linux内核是开源操作系统的核心，其功能强大且复杂，被广泛应用于各种领域。理解内核的工作机制对于系统开发和优化至关重要。目前，学习Linux内核的主要方式包括阅读教科书、...
【系统调用】常用系统调用函数（一）
最新发布
bala5569的博客
01-20 635
操作系统的职责什么是Linux系统编程系统编程主要就是为了让用户能够更好和更方便的操作硬件设备，并且对硬件设备也起到保护作用。我们所写的程序，本质就是对硬件设备的操作，所以操作系统提供接口可以对硬件进行操作。系统调用概述：本质都是要对硬件设备进行操作，但是Linux操作系统在硬件之上设置了内核，也就是只有内核才可以直接操作硬件设备，如果想操作内核，需要调用内核的系统调用，如果要操作内核中的系统调用，有三种方式：第一种：shell，用户通过shell命令，由shell解释器操作内核的系统调用。
#Linux杂记--Linux 内核态下的文件操作
投笔丶从戎的博客
05-12 3126
#Linux杂记--Linux 内核态下的文件操作引言相关函数介绍实现代码 引言        总所周知，用户态进程读写任何类型的文件系统都可以使用read和write着两个系统调用，但是在linux内核中没有这样的系统调用我们如何操作文件呢？我们知道read和write在进入内核态之后，实际执行的是sys_read和sys_write，但是查看内核源代码，发现这些操作文件的函数都没有导出(使用EXPORT_SYMBOL导出)，也就是说在
linux 4.9内核,Linux Kernel 4.9 正式发布
weixin_39853843的博客
04-30 607
上一篇博文开启TCP BBR拥塞控制算法使用的内核是 4.9rc 版，如今可替换为正式版。新闻Linus Torvalds 在内核邮件列表上宣布正式释出 Linux Kernel 4.9，4.10合并窗口开启。为期两周的合并窗口预计将在圣诞节这天关闭，Linus表示因为假期的原因他考虑缩短或延长合并窗口，最有可能的做法是缩短而不是延长，以便于开发者们能度过一个平静的圣诞假期。Linux Kerne...
Linux内核（十六）Linux 内核态进行读写文件的函数 使用和解析
weixin_43564241的博客
09-01 1996
这个函数和vfs_read()都是差不多的,只是调用的文件操作方法不同而已(file->f_op->write) ,如果没有定义file->f_op->write ,同样也需要do_sync_write()调用同样文件写操作, 首先把数据写到内存中,然后在适当的时候把数据同步到具体的存储介质中去。以open /sys/log为例，该方法最终的结果是，更新struct nameidata实例指针nd中的path、inode字段，使其指向路径/sys/，更新nd中的last值，使其为log。
如何跟踪Linux内核中的write系统调用？
z1026544682的专栏
09-07 303
在 current_tracer 文件中写入所需的跟踪类型。现在您可以根据需要运行程序，并在完成后禁用跟踪。将您选择的事件写入set_event。dhsable 跟踪事件。确定您要跟踪的跟踪类型。
linux的exec和system函数介绍及选择
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
07-28 2712
在应用程序中有时候需要调用第三方的应用，这是常见的需求。此时可以使用linux下的exec命令或system命令达到目的。但是这两个该选择哪个呢？有什么区别？下面总结介绍下。
【Linux】运行程序前加上strace，可以追踪到函数库调用过程
smartvxworks的博客
08-04 2505
如执行结果可知： 我们的程序虽然只有一个printf函数，但是在执行过程中，我们前后调用了execve、access、open、fstat、mmap、brk、write等系统调用。其中write系统调用会把字符串：yikoulinux通过设备文件1，发送到驱动，该设备节点对应终端stdout。【注意】运行程序前加上strace，可以追踪到函数库调用过程。
嵌入式C语言自我修养 (10)：内联函数探究
宅学部落-王利涛
01-26 1072
10.1 属性声明：noinline &amp; always_inline 这一节，接着讲 attribute 属性声明，attribute可以说是 GNU C 最大的特色。我们接下来继续讲一下跟内联函数相关的两个属性：noinline 和 always_inline。这两个属性的用途是告诉编译器：编译时，对我们指定的函数内联展开或不展开。它们的使用方法如下。 static  inline...
对于Linux下system函数的深度理解
好习惯成就伟大
12-25 3129
转载自：http://blog.sina.com.cn/s/blog_8043547601017qk0.html 这几天调程序(嵌入式linux),发现程序有时就莫名其妙的死掉,每次都定位在程序中不同的system()函数,直接在shell下输入 system()函数中调用的命令也都一切正常.就没理这个bug,以为是其他的代码影响到这个,或是内核驱动文件系统什么的异常导致,昨天有出现了这个 问题,...
Linux内核源代码解析：system_call函数与系统调用接口
`system_call`函数在内核中接收到系统调用请求后，会根据传递的参数和系统调用号执行相应的操作。在x86体系结构中，系统调用号通常存储在`eax`寄存器中。内核通过这个调用号查找并执行相应的处理函数。这些处理函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值