精华内容
下载资源
问答
  • 系统调用linux 内核实现讲解,里面设计了一个非常神奇的实验,如果弄明白,那就全部能搞清楚了.
  • 基于Linux系统调用内核级Rootkit技术研究.pdf
  • 操作系统—系统调用内核

    千次阅读 2015-04-06 18:50:44
    应用程序不能直接访问内核数据,也无法直接调用内核函数,他们只能在用户空间操纵用户数据,调用用户空间函数。但在很多情况下,应用程序需要获得系统服务,这时就必须利用系统提供给用户的特殊接口--系统调用。 ...

    1.系统调用:

    操作系统服务之所以通过系统调用的方式供用户使用,其根本原因是对系统进行“保护”。程序的运行空间分为内核空间和用户空间,其程序各自按不同的特权运行,在逻辑上相互隔离。应用程序不能直接访问内核数据,也无法直接调用内核函数,他们只能在用户空间操纵用户数据,调用用户空间函数。但在很多情况下,应用程序需要获得系统服务,这时就必须利用系统提供给用户的特殊接口--系统调用。

    系统调用是应用程序获得操作系统服务的唯一途径。

    系统调用与库函数的区别:库函数可以隐藏访管指令的细节,使得系统调用更像函数调用,对用户隐藏系统调用,这样在改动内核时不会影响应用程序的正确性。但是库函数属于应用程序,在用户态运行,系统调用属于系统程序,在核心态运行。


    2.内核:是一组程序模块,作为可信软件来提供支持进程并发执行的基本功能和基本操作,常驻留在内核空间,运行于核心态,具有访问硬件设备和所有主存空间权限,是仅有的能执行特权指令的程序。

    内核的一些属性:

    (1)内核是由中断驱动的

    (2)内核是不可抢占的

    (3)内核部分程序在屏蔽中断状态下执行

    (4)内核可使用特权指令


    展开全文
  • 文章目录Unix/Linux的体系架构Linux系统调用简述系统调用号与系统调用内核态与用户态内核态与用户态的转换 Unix/Linux的体系架构 如上图所示,从宏观上来看,Linux操作系统的体系架构分为用户态和内核态(或者...

    Unix/Linux的体系架构

    如上图所示,从宏观上来看,Linux操作系统的体系架构分为用户态内核态(或者用户空间和内核)。内核从本质上看是一种软件——控制计算机的硬件资源,并提供上层应用程序运行的环境。用户态即上层应用程序的活动空间,应用

    展开全文
  • Linux 2.6内核标准教程 第7章 系统调用 使用 Linux 系统调用内核命令 深入理解Linux的系统调用  Linux系统调用接口、系统调用例程和内核服务例程之间的关系 向linux内核中添加三个系统调用...
    Linux 2.6内核标准教程  第7章 系统调用
    

    使用 Linux 系统调用的内核命令

    深入理解Linux的系统调用 

    Linux系统调用接口、系统调用例程和内核服务例程之间的关系

    向linux内核中添加三个系统调用(Ubuntu9.10)

    ++++++++++++++++++++++++++++++++++

    使用 Linux 系统调用的内核命令



    作者:M. Tim Jones    转贴自:本站原创



    Linux® 系统调用 —— 我们每天都在使用它们。不过您清楚系统调用是如何在用户空间和内核之间执行的吗?本文将探究 Linux 系统调用接口(SCI),学习如何添加新的系统调用(以及实现这种功能的其他方法),并介绍与 SCI 有关的一些工具。

    系统调用就是用户空间应用程序和内核提供的服务之间的一个接口。由于服务是在内核中提供的,因此无法执行直接调用;相反,您必须使用一个进程来跨越用户空间与内核之间的界限。在特定架构中实现此功能的方法会有所不同。因此,本文将着眼于最通用的架构 —— i386。

    在本文中,我将探究 Linux SCI,演示如何向 2.6.20 内核添加一个系统调用,然后从用户空间来使用这个函数。我们还将研究在进行系统调用开发时非常有用的一些函数,以及系统调用的其他选择。最后,我们将介绍 与系统调用有关的一些辅助机制,比如在某个进程中跟踪系统调用的使用情况。

    SCI

    Linux 中系统调用的实现会根据不同的架构而有所变化,而且即使在某种给定的体架构上也会不同。例如,早期的 x86 处理器使用了中断机制从用户空间迁移到内核空间中,不过新的 IA-32 处理器则提供了一些指令对这种转换进行优化(使用 sysenter 和 sy***it 指令)。由于存在大量的方法,最终结果也非常复杂,因此本文将着重于接口细节的表层讨论上。更详尽的内容请参看本文最后的 参考资料。

    要对 Linux 的 SCI 进行改进,您不需要完全理解 SCI 的内部原理,因此我将使用一个简单的系统调用进程(请参看图 1)。每个系统调用都是通过一个单一的入口点多路传入内核。eax 寄存器用来标识应当调用的某个系统调用,这在 C 库中做了指定(来自用户空间应用程序的每个调用)。当加载了系统的 C 库调用索引和参数时,就会调用一个软件中断(0x80 中断),它将执行 system_call 函数(通过中断处理程序),这个函数会按照 eax 内容中的标识处理所有的系统调用。在经过几个简单测试之后,使用 system_call_table 和 eax 中包含的索引来执行真正的系统调用了。从系统调用中返回后,最终执行 syscall_exit,并调用 resume_userspace 返回用户空间。然后继续在 C 库中执行,它将返回到用户应用程序中。


    图 1. 使用中断方法的系统调用的简化流程
    系统调用的简化流程  

    SCI 的核心是系统调用多路分解表。这个表如图 2 所示,使用 eax 中提供的索引来确定要调用该表中的哪个系统调用(sys_call_table)。图中还给出了表内容的一些样例,以及这些内容的位置。(有关多路分解的更多内容,请参看侧栏 “系统调用多路分解”)


    图 2. 系统调用表和各种链接
    系统调用表和各种链接 

    添加一个 Linux 系统调用

    系统调用多路分解

    有些系统调用会由内核进一步进行多路分解。例如,BSD(Berkeley Software Distribution)socket 调用(socket、bind、 connect 等)都与一个单独的系统调用索引(__NR_socketcall)关联在一起,不过在内核中会进行多路分解,通过另外一个参数进入适当的调用。请参看 ./linux/net/socket.c 中的 sys_socketcall 函数。

    添加一个新系统调用主要是一些程序性的操作,但应该注意几件事情。本节将介绍几个系统调用的构造,从而展示它们的实现和用户空间应用程序对它们的使用。

    向内核中添加新系统调用,需要执行 3 个基本步骤:

    1. 添加新函数。
    2. 更新头文件。
    3. 针对这个新函数更新系统调用表。

    注意: 这个过程忽略了用户空间的需求,我将稍后介绍。

    最常见的情况是,您会为自己的函数创建一个新文件。不过,为了简单起见,我将自己的新函数添加到现有的源文件中。清单 1 所示的前两个函数,是系统调用的简单示例。清单 2 提供了一个使用指针参数的稍微复杂的函数。


    清单 1. 系统调用示例的简单内核函数


    asmlinkage long sys_getjiffies( void )
    {
      return (long)get_jiffies_64();
    }

    asmlinkage long sys_diffjiffies( long ujiffies )
    {
      return (long)get_jiffies_64() - ujiffies;
    }


    在清单 1 中,我们为进行 jiffies 监视提供了两个函数。(有关 jiffies 的更多信息,请参看侧栏 “Kernel jiffies”)。第一个函数会返回当前 jiffy,而第二个函数则返回当前值与所传递进来的值之间的差值。注意 asmlinkage 修饰符的使用。这个宏(在 linux/include/asm-i386/linkage.h 中定义)告诉编译器将传递栈中的所有函数参数。


    清单 2. 系统调用示例的最后内核函数


    asmlinkage long sys_pdiffjiffies( long ujiffies, long __user *presult )
    {
      long cur_jiffies = (long)get_jiffies_64();
      long result;
      int  err = 0;

      if (presult) {

        result = cur_jiffies - ujiffies;
        err = put_user( result, presult );

      }

      return err ? -EFAULT : 0;
    }


    内核 jiffies

    Linux 内核具有一个名为 jiffies 的全局变量,它代表从机器启动时算起的时间滴答数。这个变量最初被初始化为 0,每次时钟中断时都会加 1。您可以使用 get_jiffies_64 函数来读取 jiffies 的值,然后使用 jiffies_to_msecs 将其换算成毫秒或使用 jiffies_to_usecs 将其换算成微秒。jiffies 的全局定义和相关函数是在 ./linux/include/linux/jiffies.h 中提供的。

    清单 2 给出了第三个函数。这个函数使用了两个参数:一个 long 类型,以及一个指向被定义为 __user 的 long 的指针。__user 宏简单告诉编译器(通过 noderef)不应该解除这个指针的引用(因为在当前地址空间中它是没有意义的)。这个函数会计算这两个 jiffies 值之间的差值,然后通过一个用户空间指针将结果提供给用户。put_user 函数将结果值放入 presult 所指定的用户空间位置。如果在这个操作过程中出现错误,将立即返回,您也可以通知用户空间调用者。

    对于步骤 2 来说,我对头文件进行了更新:在系统调用表中为这几个新函数安排空间。对于本例来说,我使用新系统调用号更新了 linux/include/asm/unistd.h 头文件。更新如清单 3 中的黑体所示。


    清单 3. 更新 unistd.h 文件为新系统调用安排空间


    #define __NR_getcpu        318
    #define __NR_epoll_pwait    319
    #define __NR_getjiffies        320
    #define __NR_diffjiffies    321
    #define __NR_pdiffjiffies    322
    #define NR_syscalls    323


    现在已经有了自己的内核系统调用,以及表示这些系统调用的编号。接下来需要做的是要在这些编号(表索引)和函数本身之间建立一种对等关系。这就是第 3 个步骤,更新系统调用表。如清单 4 所示,我将为这个新函数更新 linux/arch/i386/kernel/syscall_table.S 文件,它会填充清单 3 显示的特定索引。


    清单 4. 使用新函数更新系统调用表


    .long sys_getcpu
    .long sys_epoll_pwait
    .long sys_getjiffies        /* 320 */
    .long sys_diffjiffies
    .long sys_pdiffjiffies


    注意: 这个表的大小是由符号常量 NR_syscalls 定义的。

    现在,我们已经完成了对内核的更新。接下来必须对内核重新进行编译,并在测试用户空间应用程序之前使引导使用的新映像变为可用。

    对用户内存进行读写

    Linux 内核提供了几个函数,可以用来将系统调用参数移动到用户空间中,或从中移出。方法包括一些基本类型的简单函数(例如 get_user 或 put_user)。要移动一块儿数据(如结构或数组),您可以使用另外一组函数: copy_from_user 和 copy_to_user。可以使用专门的调用移动以 null 结尾的字符串: strncpy_from_user 和 strlen_from_user。您也可以通过调用 access_ok 来测试用户空间指针是否有效。这些函数都是在 linux/include/asm/uaccess.h 中定义的。

    您可以使用 access_ok 宏来验证给定操作的用户空间指针。这个函数有 3 个参数,分别是访问类型(VERIFY_READ 或 VERIFY_WRITE),指向用户空间内存块的指针,以及块的大小(单位为字节)。如果成功,这个函数就返回 0:

    int access_ok( type, address, size );

    要在内核和用户空间移动一些简单类型(例如 int 或 long 类型),可以使用 get_user 和 put_user 轻松地实现。这两个宏都包含一个值以及一个指向变量的指针。get_user 函数将用户空间地址(ptr)指定的值移动到所指定的内核变量(var)中。 put_user 函数则将内核变量(var)指定的值移动到用户空间地址(ptr)。 如果成功,这两个函数都返回 0:

    int get_user( var, ptr );
    int put_user( var, ptr );


    要移动更大的对象,例如结构或数组,您可以使用 copy_from_user 和 copy_to_user 函数。这些函数将在用户空间和内核之间移动完整的数据块。 copy_from_user 函数会将一块数据从用户空间移动到内核空间,copy_to_user 则会将一块数据从内核空间移动到用户空间:

    unsigned long copy_from_user( void *to, const void __user *from, unsigned long n );
    unsigned long copy_to_user( void *to, const void __user *from, unsigned long n );

    最后,您可以使用 strncpy_from_user 函数将一个以 NULL 结尾的字符串从用户空间移动到内核空间中。在调用这个函数之前,您可以通过调用 strlen_user 宏来获得用户空间字符串的大小:

    long strncpy_from_user( char *dst, const char __user *src, long count );
    strlen_user( str );

    这些函数为内核和用户空间之间的内存移动提供了基本功能。实际上还可以使用另外一些函数(例如减少执行检查数量的函数)。您可以在 uaccess.h 中找到这些函数。

    使用系统调用

    现在内核已经使用新系统调用完成更新了,接下来看一下从用户空间应用程序中使用这些系统调用需要执行的操作。使用新的内核系统调用有两种方法。第一种方法非常方便(但是在产品代码中您可能并不希望使用),第二种方法是传统方法,需要多做一些工作。

    使用第一种方法,您可以通过 syscall 函数调用由其索引所标识的新函数。使用 syscall 函数,您可以通过指定它的调用索引和一组参数来调用系统调用。例如,清单 5 显示的简单应用程序就使用其索引调用了 sys_getjiffies。


    清单 5. 使用 syscall 调用系统调用


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

    #define __NR_getjiffies        320

    int main()
    {
      long jiffies;

      jiffies = syscall( __NR_getjiffies );

      printf( "Current jiffies is %lx\n", jiffies );

      return 0;
    }

    正如您所见,syscall 函数使用了系统调用表中使用的索引作为第一个参数。如果还有其他参数需要传递,可以加在调用索引之后。大部分系统调用都包括了一个 SYS_ 符号常量来指定自己到 __NR_ 索引的映射。例如,使用 syscall 调用 __NR_getpid 索引:

    syscall( SYS_getpid )

    syscall 函数特定于架构,使用一种机制将控制权交给内核。其参数是基于 __NR 索引与 /usr/include/bits/syscall.h 提供的 SYS_ 符号之间的映射(在编译 libc 时定义)。永远都不要直接引用这个文件;而是要使用 /usr/include/sys/syscall.h 文件。

    传统的方法要求我们创建函数调用,这些函数调用必须匹配内核中的系统调用索引(这样就可以调用正确的内核服务),而且参数也必须匹配。Linux 提供了一组宏来提供这种功能。_syscallN 宏是在 /usr/include/linux/unistd.h 中定义的,格式如下:

    _syscall0( ret-type, func-name )
    _syscall1( ret-type, func-name, arg1-type, arg1-name )
    _syscall2( ret-type, func-name, arg1-type, arg1-name, arg2-type, arg2-name )

    用户空间和 __NR 常量

    注意清单 6 中提供了 __NR 符号常量。您可以在 /usr/include/asm/unistd.h 中找到它们(对于标准系统调用来说)。

    _syscall 宏最多可定义 6 个参数(不过此处只显示了 3 个)。

    现在,让我们来看一下如何使用 _syscall 宏来使新系统调用对于用户空间可见。清单 6 显示的应用程序使用了 _syscall 宏定义的所有系统调用。


    清单 6. 将 _syscall 宏 用于用户空间应用程序开发 
    #include <stdio.h>
    #include <linux/unistd.h>
    #include <sys/syscall.h>

    #define __NR_getjiffies        320
    #define __NR_diffjiffies    321
    #define __NR_pdiffjiffies    322

    _syscall0( long, getjiffies );
    _syscall1( long, diffjiffies, long, ujiffies );
    _syscall2( long, pdiffjiffies, long, ujiffies, long*, presult );

    int main()
    {
      long jifs, result;
      int err;

      jifs = getjiffies();

      printf( "difference is %lx\n", diffjiffies(jifs) );

      err = pdiffjiffies( jifs, &result );

      if (!err) {
        printf( "difference is %lx\n", result );
      } else {
        printf( "error\n" );
      }

      return 0;
    }

    注意 __NR 索引在这个应用程序中是必需的,因为 _syscall 宏使用了 func-name 来构造 __NR 索引(getjiffies -> __NR_getjiffies)。其结果是您可以使用它们的名字来调用内核函数,就像其他任何系统调用一样。

    用户/内核交互的其他选择

    系统调用是请求内核中服务的一种有效方法。使用这种方法的最大问题就是它是一个标准接口,很难将新的系统调用增加到内核中,因此可以通过其他方法来 实现类似服务。如果您无意将自己的系统调用加入公共的 Linux 内核中,那么系统调用就是将内核服务提供给用户空间的一种方便而且有效的方法。

    让您的服务对用户空间可见的另外一种方法是通过 /proc 文件系统。/proc 文件系统是一个虚拟文件系统,您可以通过它来向用户提供一个目录和文件,然后通过文件系统接口(读、写等)在内核中为新服务提供一个接口。

    使用 strace 跟踪系统调用

    Linux 内核提供了一种非常有用的方法来跟踪某个进程所调用的系统调用(以及该进程所接收到的信号)。这个工具就是 strace,它可以在命令行中执行,使用希望跟踪的应用程序作为参数。例如,如果您希望了解在执行 date 命令时都执行了哪些系统调用,可以键入下面的命令:

    strace date

    结果会产生大量信息,显示在执行 date 命令过程中所执行的各个系统调用。您会看到加载共享库、映射内存,最后跟踪到的是在标准输出中生成日期信息:

    ...
    write(1, "Fri Feb  9 23:06:41 MST 2007\n", 29Fri Feb  9 23:06:41 MST 2007) = 29
    munmap(0xb747a000, 4096)    = 0
    exit_group(0)            = ?

    当当前系统调用请求具有一个名为 syscall_trace 的特定字段集(它导致 do_syscall_trace 函数的调用)时,将在内核中完成跟踪。您还可以看到跟踪调用是 ./linux/arch/i386/kernel/entry.S 中系统调用请求的一部分(请参看 syscall_trace_entry)。

    结束语

    系统调用是穿越用户空间和内核空间,请求内核空间服务的一种有效方法。不过对这种方法的控制也很严格,更简单的方式是增加一个新的 /proc 文件系统项来提供用户/内核间的交互。不过当速度因素非常重要时,系统调用则是使应用程序获得最佳性能的理想方法。请参看 参考资料 的内容进一步了解 SCI。


    ++++++++++++++++++++++++++++++++++

    深入理解Linux的系统调用 发布时间:2005.06.30 13:18      来源:赛迪网     作者:技术应用

    一、 什么是系统调用

    在Linux的世界里,我们经常会遇到系统调用这一术语,所谓系统调用,就是内核提供的、功能十分强大的一系列的函数。这些系统调用是在内核中实现的,再 通过一定的方式把系统调用给用户,一般都通过门(gate)陷入(trap)实现。系统调用是用户程序和内核交互的接口。

    二、 系统调用的作用

    系统调用在Linux系统中发挥着巨大的作用,如果没有系统调用,那么应用程序就失去了内核的支持。

    我们在编程时用到的很多函数,如fork、open等这些函数最终都是在系统调用里实现的,比如说我们有这样一个程序:


    这里我们用到了两个函数,即fork和exit,这两函数都是glibc中的函数,但是如果我们跟踪函数的执行过程,看看glibc对fork和exit 函数的实现就可以发现在glibc的实现代码里都是采用软中断的方式陷入到内核中再通过系统调用实现函数的功能的。具体过程我们在系统调用的实现过程会详 细的讲到。

    由此可见,系统调用是用户接口在内核中的实现,如果没有系统调用,用户就不能利用内核。

    三、 系统调用的现实及调用过程

    详细讲述系统调用的之前也讲一下Linux系统的一些保护机制。

    Linux系统在CPU的保护模式下提供了四个特权级别,目前内核都只用到了其中的两个特权级别,分别为“特权级0”和“特权级3”,级别0也就是我们通 常所讲的内核模式,级别3也就是我们通常所讲的用户模式。划分这两个级别主要是对系统提供保护。内核模式可以执行一些特权指令和进入用户模式,而用户模式 则不能。

    这里特别提出的是,内核模式与用户模式分别使用自己的堆栈,当发生模式切换的时候同时要进行堆栈的切换。

    每个进程都有自己的地址空间(也称为进程空间),进程的地址空间也分为两部分:用户空间和系统空间,在用户模式下只能访问进程的用户空间,在内核模式下则 可以访问进程的全部地址空间,这个地址空间里的地址是一个逻辑地址,通过系统段面式的管理机制,访问的实际内存要做二级地址转换,即:逻辑地址?线性地 址?物理地址。

    系统调用对于内核来说就相当于函数,我们是关键问题是从用户模式到内核模式的转换、堆栈的切换以及参数的传递。

    下面将结合内核源代码对这些过程进行分析,以下分析环境为FC2,kernel 2.6.5

    下面是内核源代码里arch/i386/kernel/entry.S的一段代码。


    以上这段代码里定义了两个非常重要的宏,即SAVE_ALL和RESTORE_ALL

    SAVE_ALL先保存用户模式的寄存器和堆栈信息,然后切换到内核模式,宏__SWITCH_KERNELSPACE实现地址空间的转换RESTORE_ALL的过程过SAVE_ALL的过程正好相反。

    在内核原代码里有一个系统调用表:(entry.S的文件里)


    在2.6.5的内核里,有280多个系统调用,这些系统调用的名称全部在这个系统调用表里。

    在这个原文件里,还有非常重要的一段。


    这一段完成系统调用的执行。

    system_call函数根据用户传来的系统调用号,在系统调用表里找到对应的系统调用再执行。

    从glibc的函数到系统调用还有一个很重要的环节就是系统调用号。

    系统调用号的定义在include/asm-i386/unistd.h里


    每一个系统调用号都对应有一个系统调用

    接下来就是系统调用宏的展开

    没有参数的系统调用的宏展开

    !!!代码6::

    带一个参数的系统调用的宏展开

    !!!代码7::

    两个参数

    代码8:: 

    #define _syscall2(type,name,type1,arg1,type2,arg2) \

    三个参数的

    代码9:: 

    #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \

    四个参数的

    代码10:: 

    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 

    五个参数的

    代码11:: 

    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 

    type5,arg5) \ 

    六个参数的

    代码12::

    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 

    type5,arg5,type6,arg6) \

    _res); \ 

    从这段代码我们可以看出int $0x80通过软中断开触发系统调用,当发生调用时,函数中的name会被系统系统调用名所代替。然后调用前面所讲的system_call。这个过程里包含了系统调用的初始化,系统调用的初始化原代码在:

    arch/i386/kernel/traps.c中每当用户执行int 0x80时,系统进行中断处理,把控制权交给内核的system_call。

    整个系统调用的过程可以总结如下:

    1. 执行用户程序(如:fork) 

    2. 根据glibc中的函数实现,取得系统调用号并执行int $0x80产生中断。

    3. 进行地址空间的转换和堆栈的切换,执行SAVE_ALL。(进行内核模式)

    4. 进行中断处理,根据系统调用表调用内核函数。

    5. 执行内核函数。

    6. 执行RESTORE_ALL并返回用户模式

    解了系统调用的实现及调用过程,我们可以根据自己的需要来对内核的系统调用作修改或添加。

    ++++++++++++++++++++++++++++++++++

    Linux系统调用接口、系统调用例程和内核服务例程之间的关系
    信息来源: 维库开发网 发布时间:2009年2月17日

      系统调用接口的主要任务是把进程从用户态切换到内核态。在具有保护机制的计算机系 统中,用户必须通过软件中断或陷阱,才能使进程从用户态切换为内核态。

      在i386体系中,Linux的系统调用接口是通过调用软中断指令“int 0x80”使进程从用户态进入内核态的,这个过程也叫做“陷入”。当系统调用接口调用软中断指令“int 0x80”时,这个指令会发生一个中断向量码为128的中断请求,并在中断响应过程中将进程由用户态切换为内核态。

      因为Linux只允许系统调用接口使用128这一个软中断向量,这也就意味着所有的系统调用接口必 须共享这一个中断通道,并在同一个中断服务例程中调用不同的内核服务例程,所以,系统调用接口除了要引发“int 0x80”软中断之外,为了进人内核后能调用不同的内核服务例程,还要提供识别内核服务例程的参数,这个参数叫做“系统调用号”。也就是说,所有可为进程 提供服务的内核服务例程都应具有一个唯一的系统调用号。当然,系统调用接口还应为内核服务例程准各必要的参数。

      综上所述,系统调用接口需要完成以下几个任务:

      ●用软中断指令“int 0x80”发生一个中断向量码为128的中断请求,以使进程进入内核态。

      ●要保护用户态的现场,即把处理器的用户态运行环境保护到进程的内核堆栈。

      ●为内核服务例程准备参数,并定义返回值的存储位置。

      ●跳转到系统调用例程。

      ●系统调用例程结束后返回。

      系统调用例程是系统提供的一个通用的汇编语言程序.其实它是一个中断向量为128的中断服务程序,其入口为system_call。它应完成的任务有:

      ●接受系统调用接口的参数。

      ●根据系统调用号,转向对应的内核服务例程,并将相关参数传遴给内核服务例程。

      ●在内核服务例程结束后,自中断返田到系统凋甩接口.

      系统调用的过程如图所示。

      从图中可以看到,系统调用接口是用高级语言来编写的,而通过调用中断指令陷入内核后的系统调用例程(即图中的系统调用处理程序)则是用汇编语言编写的。

      为了通过系统调用号来调用不同的内核服务例程,系统必须维护一个系统调用表,这个表实质上就是系统 调用号与内核服务函数的对照表。Linux是用数组sys_call_tabl来作为这个表的,在这个表的每个表项中存放着对应内核服务例程的指针,而该 表项的下标就是该内核服务例程的系统调用号。Linux规定,在1386体系中,系统调用号由处理器的寄存器eax来传递。

    系统调用的处理过程



      图 系统调用的处理过程

      系统调用表Sys_call_table的部分内容列举如下:


      欢迎转载,信息来自维库电子市场网(www.dzsc.com


    ++++++++++++++++++++++++++++++++++

    向linux内核中添加三个系统调用(Ubuntu9.10)

               系统调 用是操作系统提供给软件开发人员的唯一接口,开发人员可利用它使用系统功能。OS核心中都有一组实现系统功能的过程(子程序),系统调用就是对上述过程的调用。因此,系统调用像一个黑箱子那样,对用户屏蔽了操作系统的具体动作而只提供有关的功能。
        
        系统调用在os中发挥着巨大的作用,如果没有系统调用那么应用程序就是失去了内核的支持。在系统中真正被所有进程都使用的内核通信方式是系统调用。例如 当进程请求内核服务时,就使用的是系统调用。一般情况下,进程是不能够存取系统内核的。它不能存取内核使用的内存段,也不能调用内核函数,CPU的硬件结 构保证了这一点。只有系统调用是一个例外。进程使用寄存器中适当的值跳转到内核中事先定义好的代码中执行,(当然,这些代码是只读的)。在Intel结构 的计算机中,这是由中断0x80实现的。

        进程可以跳转到的内核中的位置叫做system_call。在此位置的过程检查系统调用号,它将告诉内核进程请求的服务是什么。然后,它再查找系统调用表sys_call_table,找到希望调用的内核函数的地址,并调用此函数,最后返回。
        

        所以,如果希望改变一个系统调用的函数,需要做的是编写一个自己的函数,然后改变sys_call_table中的指针指向该函数,最后再使用 cleanup_module将系统调用表恢复到原来的状态。我们现在向内核中添加的三个系统调用就是属于向内核中添加新的函数,且这些函数是可以直接操 作系统内核的。下面是系统调用的基本处理过程:

       

        
        

        Linux的系统调用机制
         
         在Linux系统中,系统调用是作为一种异常类型实现的。它将执行相应的机器代码指令来产生异常信号。产生中断或异常的重要效果是系统自动将用户态切换为 核心态来对它进行处理。这就是说,执行系统调用异常指令时,自动地将系统切换为核心态,并安排异常处理程序的执行。Linux用来实现系统调用异常的实际 指令是:
                     Int $0x80

    这 一指令使用中断/异常向量号128(即16进制的80)将控制权转移给内核。为达到在使用系统调用时不必用机器指令编程,在标准的C语言库中为每一系统调 用提供了一段短的子程序,完成机器代码的编程工作。事实上,机器代码段非常简短。它所要做的工作只是将送给系统调用的参数加载到CPU寄存器中,接着执行 int $0x80指令。然后运行系统调用,系统调用的返回值将送入CPU的一个寄存器中,标准的库子程序取得这一返回值,并将它送回用户程序。

      为使系统调用的执行成为一项简单的任务,Linux提供了一组预处理宏指令。它们可以用在程序中。这些宏指令取一定的参数,然后扩展为调用指定的系统调用的函数。

      这些宏指令具有类似下面的名称格式:

      _syscallN(parameters)

      其中N是系统调用所需的参数数目,而parameters则用一组参数代替。这些参数使宏指令完成适合于特定的系统调用的扩展。例如,为了建立调用setuid()系统调用的函数,应该使用:

      _syscall1( int, setuid, uid_t, uid )

      syscallN( )宏指令的第1个参数int说明产生的函数的返回值的类型是整型,第2个参数setuid说明产生的函数的名称。后面是系统调用所需要的每个参数。这一宏指令后面还有两个参数uid_t和uid分别用来指定参数的类型和名称。

       另外,用作系统调用的参数的数据类型有一个限制,它们的容量不能超过四个字节。这是因为执行int $0x80指令进行系统调用时,所有的参数值都存在32位的CPU寄存器中。使用CPU寄存器传递参数带来的另一个限制是可以传送给系统调用的参数的数 目。这个限制是最多可以传递5个参数。所以Linux一共定义了6个不同的_syscallN()宏指令,从_syscall0()、 _syscall1()直到_syscall5()。

        一旦_syscallN()宏指令用特定系统调用的相应参数进行了扩展,得到的结果是一个与系统调用同名的函数,它可以在用户程序中执行这一系统调用。 
        
    整个系统调用的过程可以总结如下:
    1,  执行用户程序;
        2, 根据glibc(GNU实现的一套标准C的库函数)中的函数实现,取得系统调    用号并执行 int $0x80产生中断;
        3, 进行地址空间的转换和堆栈的切换,执行SAVE_ALL。(进入内核模式)
        4, 进行中断处理,根据系统调用表调用内核函数;
        5, 执行内核函数;
        6, 执行RESTORE_ALL并返回用户模式;
        
        

        系统实现:

     

          这里以具体的例子来说明如何向系统中添加新的系统调用。具体实现所用的文件等可能与上面所述有点不一致,但原理是相同的。
        1、实验环境:
           实验的环境为Ubuntu9.10系统,内核版本为2.6.31-21-generic。添加完系统调用后的内核版本命名为2.6.31-12。
         2,实验步骤:
        1) 下载Linux内核:在终端中输入命令$sudo apt-get install   linux-source。下载后的文件默认放在目录/usr/src下。
        2)  将内核代码解压缩:例如下载的内核文件为linux-source-2.6.31.tar.bz2,运行解压命令tar –jxvf linux-source-2.6.31.tar.bz2。解压出的文件夹为/usr/src/linux-source-2.6.31。如下图:
        
       3)   修改/usr/src/linux-source-2.6.31/kernel/sys.c文件,在文件末尾增加三个系统响应函数。函数实现如下:
    asmlinkage int sys_mycall(int number)
     {
        printk("这是我添加的第一个系统调用");
        return number;
     }
     asmlinkage int sys_addtotal(int number)
     {
         int i=0,enddate=0;
         printk("这是我添加的第二个系统调用");
         while(i<=number)
           enddate+=i++;
         return enddate;
     }
     asmlinkage int sys_three()
     {
         printk("这是我添加的第三个系统调用");
         return 0;
     }

         4) 在/usr/src/linux-source-2.6.31/arch/x86/kernel/ syscall_table_32.S 中添加:.long sys_mycall。

     

        
           
            
           5) 在 /usr/src/linux-2.6.31/arch/x86/include/asm/unistd_32.h中添加:#define __NR_mycall 序号(例如337),添加系统调用的入口参数(注意:其中会顺序定义入口参数的序号,添加的序号是在原有最大值的基础上+1);实现如下:
          
        编译内核,命令依次如下:
       首先切换到解压的内核目录下。

       第一步:make mrproper //清除内核中不稳定的目标文件,附属文件及内核配置文件
       第二步:make clean //清除以前生成的目标文件和其他文件
       第三步:make oldconfig// 采用默认的内核配置(使用make menuconfig可以自己配置编译选项)
       第四步:make bzImage //编译内核
       第五步:make modules //编译模块
       第六步:make modules_install// 安装模块

        编译完成后,设置采用新内核启动。

        我编译成功的内核版本号命名为2.6.31.12
        运行命令:
        cp /usr/src/linux-source-2.6.31/arch/i386/boot/ 
        bzImage   /boot/vmlinuz-2.6.31.12-mykernel(注意:2.6.31.12为你编译的内核版本。)
        
        mkinitramfs  -o initrd.img-2.6.31.12 2.6.31.12
           //执行目录/usr/src/linux-source-2.6.31/下
        
        cp /usr/src/linux-source-2.6.31/initrd.img-2.6.31.12 /boot/    initrd.img-2.6.31.12   
        
        
        
        增加引导菜单项,配置启动项文件/boot/grub/grub.cfg。添加的配置如下:
         
    完成后执行终端命令sudo update-grub2,之后重启,终端输入uname -a检查你的内核版本是否是你编译的版本2.6.31.12 。


        编写测试函数:我的测试函数如下:
        /*~~~~~~~~~~~~~~~test1.c~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
        #include<stdio.h>
        
        int main()
        {
          int tmp;
          tmp=syscall(337,1);
          printf("\n");
          if(tmp==1)
          {
            printf("第1次系统调用成功!\n");
          }
        
          tmp=syscall(338,5);
          printf("\n");
          if(tmp==15)
          {
            printf("第2次系统调用成功!\n");
          }
          tmp=syscall(339);
          printf("\n");
          if(tmp==0)
          {
            printf("第3次系统调用成功!\n");
          }
        }
        
    编译,运行。在终端输入dmesg -c可显示函数的输出内容。



        总结:
    由于使用了系统调用,编译和执行程序时,用户都应该获得超级用户权限。而且grub.cfg默认是没有写权限的,需要修改是有写权限,为了系统安全,在配置完文件后不要忘了再将权限改回来。

    编译的时间会很长,我成功的一次编译用了接近2.5个小时。需要点耐心。

    如果用虚拟机安装的话,需要注意磁盘空间的大小,我第一次用了个5G个虚拟系统,结果编译到中途就没空间了。10G左右的系统大小估计差不多。

    最后的测试函数可能看不到预想的输出系统,因为printk不会直接打印出来,而是需要命令:dmesg,直接执行会打印出很多东西,但它有一个参数:-c,清除缓存中的系统信息。于是每次用dmesg时,都加上这个参数,结果就只打印我们需要的信息。

    转自:点击打开原文地址

    展开全文
  • 操作系统添加系统调用+内核编译

    千次阅读 2018-04-15 22:58:44
    实验要求:添加一个系统调用,实现对指定进程的nice值的修改或读取功能,并返回进程最新的nice以及优先级prio。建议调用原型为: int mysetnice(pid_t pid,int flag,int nicevalue,void __user* prio,void __user ...

    实验要求:添加一个系统调用,实现对指定进程的nice值的修改或读取功能,并返回进程最新的nice以及优先级prio。建议调用原型为:
    int mysetnice(pid_t pid,int flag,int nicevalue,void __user* prio,void __user *nice);
    参数含义:
    pid:进程id
    flag:若值为0,表示读取nice值;若值为1,表示修改nice值
    prio、nice:指向进程当前优先级以及nice值
    系统调用成功时返回0,失败时返回错误码EFAULT

    一看到这个实验要求,就产生了很多困惑,通过大量的查阅资料和阅读源码弄懂了个大概
    (1)进程nice值是什么?
       进程nice值可以调整该进程的优先级。int类型,值从-20到+19,负值表示调整到高优先级,0表示不调整优先级,正值表示调整到低优先级
    (2)pid_t是什么类型?

    //linux4.16.2源码中是这么写的
    typedef __kernel_pid_t  pid_t;
    typedef int     __kernel_pid_t;

    那为什么不直接声明为int类型呢?为了在不同平台间可移植性好一些。
    (3)void __user* 又是什么类型?
    (void __user *)arg 指的是arg值是一个用户空间的地址,不能直接进行拷贝等,要使用例如copy_from_user,copy_to_user等函数。
    大概意思就是在内核函数里,拷贝这种类型的数据要用copy_from_user,copy_to_user函数
    copy_to_user函数原型:

    unsigned long copy_to_user(void __user *to, const void *from, unsigned long n);

    (4)EFAULT是什么?

    #define EFAULT  14  /* Bad address */

    再通过一张图来了解下系统调用的原理:
    这里写图片描述
    用户调用系统调用时,会执行一条访管指令,该指令会产生一个访管中断,从而让系统暂停当前进程执行,转入核心态调用处理程序。

    接下来进入实际操作
    一、下载虚拟机
    常用虚拟机软件:Vimware workstation pro或VitualBox
    创建虚拟机之前先去下载对应系统的iso文件
    虚拟机配置:64位Ubuntu 16.04,磁盘空间100G(建议大于80G,有条件的可以分在固态盘C盘,速度比较快),内存8G,2核
    磁盘空间太小会因空间不足而导致编译内核失败。内存太小会影响编译速度,一般编译时间在1.5h-3h。


    注:以下操作均在虚拟机内进行

    二、网上下载内核
    下载内核:点我QAQwww.kernel.org

    这里写图片描述

    笔者下载的是最新的4.16.2,点击黄色框框即可下载


    三、添加系统调用
    切换到root用户,将下载的内核文件复制到/home或者其他空闲目录,在该目录下打开终端,分两步解压缩:

    (1)sudo xz -d linux-4.16.2.tar.xz
    (2)sudo tar -xvf linux-4.16.2.tar

    解压完成后会生成一个linux-4.16.2的文件,进入该文件夹,开始添加系统调用。
    添加系统调用需三步:

    (1)查看系统调用表(./arch/x86/entry/syscalls/syscall_64.tbl)

    每个系统调用在表中占一项,格式为:
    <系统调用号> <64/x32/common> <系统调用名> <服务例程入口>
    系统调用号非常关键,一旦分配就不能就任何更改。每个系统调用需要一个服务例程完成其具体功能。

    选择一个未使用的系统调用号进行分配
    如图:
    这里写图片描述

    (2)声明系统调用服务例程
    进入目录linux-4.16.2/include/linux/syscalls.h中,在文件末尾添加内容
    如图:
    这里写图片描述

    asmlinkage是一个必须的限定词,用于通知编译器仅从内核中提取该函数的参数,而不是从寄存器中,因为在执行服务例程之前系统已经将通过寄存器传递过来的参数压入内核堆栈了。

    (3)实现系统调用服务例程
    这里就要编写系统调用实现代码了,进入目录linux-4.16.2/kernel/sys.c,
    在该文件中添加以下代码:

    SYSCALL_DEFINE5 (mysetnice,pid_t,pid,int,flag,int,nicevalue,void __user*,prio,void __user*,nice){
        //SYSCALL_DEFINEN中N表示系统调用所需要的参数个数,我们的是5个
         struct task_struct *p;//进程结构体指针
         struct pid *id;//pid结构体
         int m,n;
         id=find_get_pid(pid);//通过传入的pid_t pid得到id结构体 
         p=pid_task(id,PIDTYPE_PID);//通过id得到指定进程,PIDTYPE_PID指的是进程类型的pid 
         m=task_nice(p);     //通过p得到nice值 
         n=task_prio(p);     //通过p得到prio值(优先级) 
         if(flag==0){//读取 
            copy_to_user(nice,(void*)&m,sizeof(m));//将m的地址强转为void *类型 
            copy_to_user(prio,(void*)&n,sizeof(n));
            return 0;
         }
         else if(flag==1){//修改 
            printk("nice value before modified:%d\n",m); 
            set_user_nice(p,nicevalue);//修改nice的值
            return 0;
         } 
         printk("syscall failed!");
         return EFAULT; 
    }

    如图:
    这里写图片描述
    以上用到的函数和结构体可以在linux源码中查阅。
    另外一开始很困惑为什么SYSCALL_DEFINE类型的函数参数声明中类型和参数名要用逗号分开,直到查到了这篇文章:
    Linux系统调用之SYSCALL_DEFINE


    四、开始内核编译
    在linux-4.16.2目录下打开终端

    step 1.安装编译可能需要的库(血泪教训:没有这些库编译会出更多错)

    sudo apt-get install libncurses5-dev libssl-dev 
    
    sudo apt-get install build-essential openssl 
    
    sudo apt-get install zlibc minizip 
    
    sudo apt-get install libidn11-dev libidn11

    step 2.库安装完成后执行以下命令

    sudo make mrproper //清除以前编译的残留文件
    
    sudo make clean 
    
    sudo make menuconfig //配置内核

    在该过程中可能会出现一些依赖不存在的问题
    只需按照图中的错误提示,sudo apt-get install <文件名> 就可以解决了
    例如:
    这里写图片描述
    提示说“bison:not found”
    解决方法:sudo apt-get install bison

    然后会弹出以下窗口:
    如图:
    这里写图片描述

    不用管它(保留默认值不做修改),save一下然后exit退出即可

    step 3.编译内核
    sudo make
    tips:若虚拟机是多核,可执行sudo make -j N 加快编译速度,其中N是核的数量
    该步骤耗时较长,笔者用了2小时(等哭了有木有啊!)

    step 4.编译模块
    sudo make modules
    只用了10分钟。。。网上都说编译内核快,编译模块慢(总觉得在骗我Q_Q)

    step 5.安装内核
    (1)安装模块:sudo make modules_install
    (2)安装内核:sudo make install

    step 6.配置grub引导
    (顺便提一下引导作用:计算机启动时,引导程序在对计算机系统进行初始化后,把操作系统的核心部分程序装入住存储器)
    sudo update-grub2

    step 7.重启系统
    reboot
    重启后应该能够在grub中在新老内核中切换
    如图:
    这里写图片描述
    进入Ubuntu高级选项
    这里写图片描述
    若不能切换,解决方案:
    桌面打开终端->sudo update-grub->sudo gedit /etc/default/grub
    这里写图片描述
    在该行之前加一个“#”注释掉该行后重启。


    五、测试系统调用
    新建一个文本文档,文件名为Test.c
    这里写图片描述
    在该文档所在目录打开终端,执行以下三步
    (1)gcc Test.c
    (2)./a.out //gcc默认文件名
    (3)dmesg //显示内核信息

    a.out用户态程序输出:
    这里写图片描述
    dmesg内核程序输出:
    这里写图片描述

    比对发现测试成功!

    展开全文
  • 操作系统作业:添加一个简单的系统调用一、实验目的二、实验内容三、实验环境四、操作方法和步骤(1)准备工作(2)修改源程序,增加系统调用(3)编译内核(4)测试系统调用五、总结 一、实验目的 学习Linux的...
  • 早上听人说到某个程序的一部分是内核态...现在自己的理解是,用户程序不可用直接调用内核函数,除非通过系统调用接口。如果想调用哪个内核函数(或自己写的内核函数),怎么办?增加一个系统调用就行了。 原文如下:
  • Linux系统调用怎么调用到内核态函数的 用户态应用程序App在编写代码时,使用open/read/write等系统调用进行文件操作。 系统调用向下调用glibc库中与open/read/write相关的接口函数。 无论是App还是glibc都是出于...
  • open的详细调用过程,根据linux内核2.6.35
  • linux系统调用内核函数的关系

    千次阅读 2015-02-27 14:00:35
    早上听人说到某个程序的一部分是内核态...现在自己的理解是,用户程序不可用直接调用内核函数,除非通过系统调用接口。如果想调用哪个内核函数(或自己写的内核函数),怎么办?增加一个系统调用就行了。 原文如下:
  • 现在在业界,“系统调用”这个术语的使用有些混乱。...但是,内核函数是为了提供系统功能服务的函数,或者说,用户是为了享用系统提供的与系统有关的服务才调用内核函数的,所以为了与提供数学运算之类通用
  • 系统调用接口的主要任务是把进程从用户态切换到内核态。在具有保护机制的计算机系 统中,用户必须通过软件中断或陷阱,才能使进程从用户态切换为内核态。  在i386体系中,Linux的系统调用接口是通过调用软中断指令...
  • 系统调用通常通过函数进行调用(这句话的意思是系统调用函数是封装在其他函数中)
  • 关于Linux系统调用内核函数【转】

    千次阅读 2018-12-24 12:13:38
    早上听人说到某个程序的一部分是...现在自己的理解是,用户程序不可用直接调用内核函数,除非通过系统调用接口。如果想调用哪个内核函数(或自己写的内核函数),怎么办?增加一个系统调用就行了。 原文如下: Linux...
  • linux内核添加系统调用的方法, 含详细过程 操作系统课程设计
  • linux2.4.16内核升级到2.6.18
  • 今天在做Linux系统调用内核编译的实验,主要任务有两个: 1)添加一个新的系统调用:mysyscall,功能仅为打印一条语句。 2)编译内核。 实验步骤如下:
  • 使用 Linux 系统调用内核命令

    千次阅读 2009-10-22 13:41:00
    使用 Linux 系统调用内核命令探究 SCI 并添加自己的调用 级别: 中级M. Tim Jones, 顾问工程师, Emulex

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 481,642
精华内容 192,656
关键字:

系统调用是不是内核的