深入理解Solaris X64系统调用

p { margin-bottom: 0.1in; line-height: 120% } a:link { }

理解系统调用的关键在于洞悉系统调用号是联系用户模式与内核模式的纽带。而在Solaris x64平台上，系统调用号被保存在寄存器RAX中，从用户模式传递到内核模式。一旦进入内核模式，内核的sys_syscall入口程序就根据保存在RAX中的系统调用号，从内核维护的系统调用表(sysent)中查询出对应的系统调用处理程序，从而进行系统调用。系统调用最多支持６个参数，参数被顺序保存在寄存器RDI, RSI, RDX, RCX, R8, R9中完成传递。另外，从用户模式陷入内核模式，通过汇编指令syscall实现切换，而从内核模式返回到用户模式，则通过汇编指令sysret完成切换。

 

1 系统调用概述

1.1 什么是系统调用
在现代操作系统中，用户的应用程序访问并使用内核所提供的各种服务的途径被称之为系统调用(syscall)。

1.2 为什么需要系统调用
第一，系统调用可以为用户空间提供访问硬件资源的统一接口，以至于用户程序不必去关注具体的硬件操作。比如，读写文件时，用户完全没有必要关心文件存放在何种磁盘上，也不用关心文件在何种文件系统上。
第二，系统调用可以对操作系统进行保护，保证系统的稳定和安全。系统调用的存在规定了用户进程进入操作系统内核的具体方式。换言之，用户进程访问内核的路径是事先规定好了的，只能从规定的位置进入内核，而不允许随便跳入内核。有了这样的进入内核的统一访问路径上的限制，才能充分保证内核的安全。


1.3 系统调用与C库函数的关系
内核提供的系统调用在C库中都有相应的封装函数。系统调用与其封装的C库函数名称常常相同。例如: modctl系统调用在C库中的封装函数即为modctl函数，其实现位于modctl.s汇编文件中。


1.4 系统调用与系统命令的关系
系统命令位于C库函数的上一层，是利用C库函数实现的可执行程序。例如: 命令modinfo调用C库函数modctl()查询内核模块的信息。而C库函数封装了进入内核的系统调用，modctl()使用syscall指令(有别于int 0x80, 是一种快速系统调用指令)进入内核。


1.5 系统调用与系统函数的关系
内核函数与C库函数的区别仅仅是内核函数在内核中实现，因此必须遵循内核编程的规则。系统调用最终必须具有明确的操作。用户应用程序通过系统调用进入内核后，会执行系统调用对应的内核函数，也就是系统调用服务例程。例如：modctl系统调用的服务例程是内核函数modctl()。

 

系统调用过程如下图所示：

2 Solaris x64系统调用实现原理

Solaris 支持x64和sparc两种平台，目前内核都是64位，但是支持32位和64位的应用程序，因此，32位和64位的系统调用都是支持的。为简单起见，接下来的讨论只阐述x64平台上的64位系统调用。

2.1 AMD64 ABI基础

理解Solaris X64系统调用，不可避免地需要了解一下基本的AMD64 ABI。Solaris x64实现遵循的ABI文档是:
System V Application Binary Interface, AMD64 Architecture Processor Supplement
这里使用简化的ABI文档: http://www.x86-64.org/documentation/abi.pdf

A.2 AMD64 Linux Kernel Conventions
...
A.2.1 Calling Conventions

The Linux AMD64 kernel uses internally the same calling conventions as user-level applications (see section 3.2.3 for details). User-level applications that like to call system calls should use the functions from the C library. The interface between the C library and the Linux kernel is the same as for the user-level applications with the following differences:

1. User-level applications use as integer registers for passing the sequence %rdi, %rsi, %rdx, %rcx, %r8 and %r9. The kernel interface uses %rdi, %rsi, %rdx, %r10, %r8 and %r9.

2. A system-call is done via the syscall instruction. The kernel destroys registers %rcx and %r11.

3. The number of the syscall has to be passed in register %rax.

4. System-calls are limited to six arguments, no argument is passed directly on the stack.

5. Returning from the syscall, register %rax contains the result of the system-call. A value in the range between -4095 and -1 indicates an error, it is -errno.

6. Only values of class INTEGER or class MEMORY are passed to the kernel.

另外，来自d3s.mff.cuni.cz/teaching/crash_dump_analysis的slides可以作为参考。 【贴两张主要的截图】

 

下面给出一个内核函数反汇编后的例子帮助理解ABI。

函数原型：
ibt_status_t ibt_suggest_alt_path(ibt_channel_hdl_t channel,
ibt_execution_mode_t mode,
ibt_suggest_alt_path_info_t *alt_path,
void *priv_data,
ibt_priv_data_len_t priv_data_len,
ibt_spr_returns_t *ret_args);

用mdb -k进入内核反汇编
root# mdb -k
> ibt_suggest_alt_path::dis
ibt_suggest_alt_path:           pushq  %rbp             ; save rbp
ibt_suggest_alt_path+1:         movq   %rsp,%rbp        ;
ibt_suggest_alt_path+4:         subq   $0x30,%rsp       ;
ibt_suggest_alt_path+8:         movq   %rdi,-0x8(%rbp)  ; arg1 : rdi
ibt_suggest_alt_path+0xc:       movq   %rsi,-0x10(%rbp) ; arg2 : rsi
ibt_suggest_alt_path+0x10:      movq   %rdx,-0x18(%rbp) ; arg3 : rdx
ibt_suggest_alt_path+0x14:      movq   %rcx,-0x20(%rbp) ; arg4 : rcx
ibt_suggest_alt_path+0x18:      movq   %r8,-0x28(%rbp)  ; arg5 : r8
ibt_suggest_alt_path+0x1c:      movq   %r9,-0x30(%rbp)  ; arg6 : r9
ibt_suggest_alt_path+0x20:      pushq  %rbx             ; save rbx
ibt_suggest_alt_path+0x21:      pushq  %r12             ; save r12
ibt_suggest_alt_path+0x23:      pushq  %r13             ; save r13
ibt_suggest_alt_path+0x25:      pushq  %r14             ; save r14
ibt_suggest_alt_path+0x27:      pushq  %r15             ; save r15
...
ibt_suggest_alt_path+0xa11:     popq   %r15             ; restore r15
ibt_suggest_alt_path+0xa13:     popq   %r14             ; restore r14
ibt_suggest_alt_path+0xa15:     popq   %r13             ; restore r13
ibt_suggest_alt_path+0xa17:     popq   %r12             ; restore r12
ibt_suggest_alt_path+0xa19:     popq   %rbx             ; restore rbx
ibt_suggest_alt_path+0xa1a:     leave                   ; restore rsp, rbp
ibt_suggest_alt_path+0xa1b:     ret                     ;
> $q                            // leave == movq %rbp, %rsp + popq %rbp

 

2.2 系统调用号

每一个系统调用都有一个独一无二的系统调用号。操作系统最多支持512个系统调用。如果一个系统调用被废弃，那么它对应的系统调用号将被保留，而不能分配给新的系统调用使用。所有系统调用号位于文件/etc/name_to_sysnum中。ABI规定了系统调用号是由寄存器rax传递给内核的，例如: modctl的系统调用号为152 (=0x98), 从modctl::dis的输出中我们可以看出，在执行syscall指令之前，%eax == 0x98。

root# egrep "modctl" /etc/name_to_sysnum
modctl                  152

root# echo "modctl::dis" | mdb /lib/64/libc.so.1
modctl:                         movq   %rcx,%r10
modctl+3:                       movl   $0x98,%eax
modctl+8:                       syscall
modctl+0xa:                     jb     -0x126d30        <__cerror>
modctl+0x10:                    xorq   %rax,%rax
modctl+0x13:                    ret

- modctl()的实现可参见usr/src/lib/libc/common/sys/modctl.s

有关系统调用号的定义，见源文件usr/src/uts/common/sys/syscall.h,
例如：
#define     SYS_modctl      152
内核在进入sys_syscall()后，根据寄存器rax中存储的系统调用号查找相应的系统调用内核函数。

2.3 系统调用表
      Solaris内核维护了一张系统调用表，表中的每一个元素是一个struct sysent。

2.3.1 结构体struct sysent

321 /*
322  * Structure of the system-entry table.
323  *
324  *  Changes to struct sysent should maintain binary compatibility with
325  *  loadable system calls, although the interface is currently private.
326  *
327  *  This means it should only be expanded on the end, and flag values
328  *  should not be reused.
329  *
330  *  It is desirable to keep the size of this struct a power of 2 for quick
331  *  indexing.
332  */
333 struct sysent {
334     char            sy_narg;        /* total number of arguments */
335 #ifdef _LP64
336     unsigned short  sy_flags;       /* various flags as defined below */
337 #else
338     unsigned char   sy_flags;       /* various flags as defined below */
339 #endif
340     int             (*sy_call)();   /* argp, rvalp-style handler */
341     krwlock_t       *sy_lock;       /* lock for loadable system calls */
342     int64_t         (*sy_callc)();  /* C-style call hander or wrapper */
343 };

root# mdb -k
> ::sizeof struct sysent
sizeof (struct sysent) = 0x20
> ::offsetof sysent sy_callc
offsetof (sysent, sy_callc) = 0x18, sizeof (...->sy_callc) = 8

注意：结构体sysent的大小为0x20(=32), 系统调用服务例程sy_callc在结构体sysent中的偏移为0x18。后面我们分析sys_syscall()汇编代码的时候会用到0x20, 0x18这两个数字。

 

2.3.2 系统调用表struct sysent sysent[NSYSCALL]

o 宏NSYSCALL定义于头文件usr/src/uts/common/sys/systm.h中，

#define NSYSCALL 256 /* number of system calls */

o sysent[NSYSCALL]定义于源文件usr/src/uts/common/os/sysent.c中

/*
* Native sysent table.
*/
struct sysent sysent[NSYSCALL] =
{
/*  0 */ IF_LP64(
SYSENT_NOSYS(),
SYSENT_C("indir",       indir,          1)),
/*  1 */ SYSENT_CI("exit",              rexit,          1),
...
/* 152 */ SYSENT_CI("modctl",           modctl,         6),
...
/* 255 */ SYSENT_CI("umount2",          umount2,        2)
...
};

o 宏SYSENT_CI定义于源文件 usr/src/uts/common/os/sysent.c中，

#define    SYSENT_CI(name, call, narg)    \
{ (narg), SE_32RVAL1, NULL, NULL, (llfcn_t)(call) }

o 宏SE_32RVAL1定义于头文件 usr/src/uts/common/sys/systm.h中,

#define SE_32RVAL1 0x0 /* handler returns int32_t in rval1 */

o 以modctl为例，其在sysent表中被展开后就是:

{6, 0x0, NULL, NULL, (llfcn_t)modctl}

o 用mdb查看一下,

> (sysent + 0x20 * 0t152)::print -Ta struct sysent
fffffffffc243480 struct sysent {
fffffffffc243480 char sy_narg = '\006'
fffffffffc243482 unsigned short sy_flags = 0
fffffffffc243488 int (*)() sy_call = 0
fffffffffc243490 krwlock_t *sy_lock = 0
fffffffffc243498 int64_t (*)() sy_callc = modctl
}
>

果然，sys_narg = 6, sy_callc = modctl; 也就是说，modctl系统函数中会接收6个参数。

o modctl在usr/src/uts/common/os/sysent.c的申明如下，

int modctl(int, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);

 

2.4 系统调用入口sys_syscall

o 用户态的C库函数调用syscall指令后进入内核，内核从sys_syscall()开始执行。注意sys_syscall()是通过汇编代码实现的，源文件为:
usr/src/uts/i86pc/ml/syscall_asm_amd64.s

525 _syscall_invoke:
526    movq    REGOFF_RDI(%rbp), %rdi
527    movq    REGOFF_RSI(%rbp), %rsi
528    movq    REGOFF_RDX(%rbp), %rdx
529    movq    REGOFF_RCX(%rbp), %rcx
530    movq    REGOFF_R8(%rbp), %r8
531    movq    REGOFF_R9(%rbp), %r9
532
533    cmpl    $NSYSCALL, %eax
534    jae    _syscall_ill
535    shll    $SYSENT_SIZE_SHIFT, %eax
536    leaq    sysent(%rax), %rbx
537
538    call    *SY_CALLC(%rbx)
539
540    movq    %rax, %r12
541    movq    %rdx, %r13

o 对sys_syscall()用mdb查看

1 > sys_syscall::dis
2 sys_syscall:       swapgs
3 ...
4 sys_syscall+0x21d: movq  0x10(%rbp),%rdi
5 sys_syscall+0x221: movq  0x18(%rbp),%rsi
6 sys_syscall+0x225: movq  0x20(%rbp),%rdx
7 sys_syscall+0x229: movq  0x28(%rbp),%rcx
8 sys_syscall+0x22d: movq  0x30(%rbp),%r8
9 sys_syscall+0x231: movq  0x38(%rbp),%r9
10 sys_syscall+0x235: cmpl  $0x100,%eax
11 sys_syscall+0x23a: jae   +0x11a   <0xfffffffffb8014bb>
12 sys_syscall+0x240: shll  $0x5,%eax
13 sys_syscall+0x243: leaq  0xfffffffffc242180(%rax),%rbx <sysent>
14 sys_syscall+0x24a: call  *0x18(%rbx)
15 sys_syscall+0x24d: movq  %rax,%r12
16 sys_syscall+0x250: movq  %rdx,%r13
17 ...
18 nopop_sys_syscall_swapgs_sysretq:   swapgs
19 nopop_sys_syscall_swapgs_sysretq+3: sysret
20 ...

o sys_syscall.s中的这3行，

535    shll    $SYSENT_SIZE_SHIFT, %eax
536    leaq    sysent(%rax), %rbx
538    call    *SY_CALLC(%rbx)

对应于将sys_syscall反汇编后这3行

12 sys_syscall+0x240: shll  $0x5,%eax
13 sys_syscall+0x243: leaq  0xfffffffffc242180(%rax),%rbx <sysent>
14 sys_syscall+0x24a: call  *0x18(%rbx)

12: 将eax的值也就是系统调用号左移5位，eax = eax << 5 = eax * 32;
13: 将rax的值加上系统调用表sysent的首地址，存入rbx中;
14: 将rbx的值加上0x18, 该内存地址中的值就是系统调用服务例程的收地址，call [rbx+0x18], 就是调用对应的系统调用服务例程。

o 例如： (以modctl为例)

> ::sizeof struct sysent
sizeof (struct sysent) = 0x20

> ::offsetof struct sysent sy_callc
offsetof (struct sysent, sy_callc) = 0x18, sizeof (...->sy_callc) = 8

> sysent + 0x20 * 0t152 = J
fffffffffc243480
> fffffffffc243480 + 0x18 = J
fffffffffc243498
> fffffffffc243498/J
sysent+0x1318:  fffffffffbcad4e0

> fffffffffbcad4e0::whatis
fffffffffbcad4e0 is modctl, in genunix's text segment
> fffffffffbcad4e0/i
modctl:
modctl:         pushq  %rbp

> sysent + 0x20 * 0t152 ::print -Ta struct sysent
fffffffffc243480 struct sysent {
fffffffffc243480 char sy_narg = '\006'
fffffffffc243482 unsigned short sy_flags = 0
fffffffffc243488 int (*)() sy_call = 0
fffffffffc243490 krwlock_t *sy_lock = 0
fffffffffc243498 int64_t (*)() sy_callc = modctl
}
>

一旦sys_syscall()找到了系统调用的服务例程(当然是根据系统调用号计算出来的)，就进入那个服务例程执行。而系统调用的参数准备在寄存器rdi, rsi, rdx, rcx, r8, r9中。

L4-9正是把储存在stack上的参数值取出来，装入对应的寄存器。系统调用服务例程将从寄存器中取得参数，例如：

4 sys_syscall+0x21d: movq  0x10(%rbp),%rdi
5 sys_syscall+0x221: movq  0x18(%rbp),%rsi
6 sys_syscall+0x225: movq  0x20(%rbp),%rdx
7 sys_syscall+0x229: movq  0x28(%rbp),%rcx
8 sys_syscall+0x22d: movq  0x30(%rbp),%r8
9 sys_syscall+0x231: movq  0x38(%rbp),%r9
10 sys_syscall+0x235: cmpl  $0x100,%eax
11 sys_syscall+0x23a: jae   +0x11a   <0xfffffffffb8014bb>
12 sys_syscall+0x240: shll  $0x5,%eax
13 sys_syscall+0x243: leaq  0xfffffffffc242180(%rax),%rbx <sysent>
14 sys_syscall+0x24a: call  *0x18(%rbx)

系统调用服务例程将从寄存器中取得参数，例如：

> fffffffffbcad4e0::dis
modctl:                         pushq  %rbp
modctl+1:                       movq   %rsp,%rbp
modctl+4:                       subq   $0x30,%rsp
modctl+8:                       movq   %rdi,-0x8(%rbp)
modctl+0xc:                     movq   %rsi,-0x10(%rbp)
modctl+0x10:                    movq   %rdx,-0x18(%rbp)
modctl+0x14:                    movq   %rcx,-0x20(%rbp)
modctl+0x18:                    movq   %r8,-0x28(%rbp)
modctl+0x1c:                    movq   %r9,-0x30(%rbp)
...

到此为止，用户程序调用C库函数modctl()的参数已经从用户空间传入内核空间，等待内核空间的modctl()执行。当然，中间经过了sys_syscall()存入stack中又从stack中取出来的过程。一旦内核空间的modctl()执行完毕，sys_syscall()就通过sysret指令返回给用户空间的modctl().

 

3 系统调用过程观察实例

3.1 最简单直接的观察

o 在终端A上启动mdb, 调试命令modinfo

root# mdb /usr/sbin/modinfo
> main:b
> :r -i 16
mdb: target stopped at:
ld.so.1`rtld_db_postinit:       pushq  %rbp
> :c
mdb: target stopped at:
ld.so.1`rtld_db_dlactivity:     pushq  %rbp
mdb: You've got symbols!
Loading modules: [ ld.so.1 libc.so.1 libuutil.so.1 ]
> modctl:b
> modctl::dis
libc.so.1`modctl:               movq   %rcx,%r10
libc.so.1`modctl+3:             movl   $0x98,%eax
libc.so.1`modctl+8:             syscall
libc.so.1`modctl+0xa:           jb     -0x126d30        <libc.so.1`__cerror>
libc.so.1`modctl+0x10:          xorq   %rax,%rax
libc.so.1`modctl+0x13:          ret
> :s
mdb: target stopped at:
ld.so.1`rtld_db_dlactivity+1:   movq   %rsp,%rbp
> :s
mdb: target stopped at:
libc.so.1`modctl+3:     movl   $0x98,%eax
> :s
mdb: target stopped at:
libc.so.1`modctl+8:     syscall

> // 在进入内核模式前，先看看寄存器
> $r
%rax = 0x0000000000000098       %r8  = 0x0000000000000000
%rbx = 0xffff80fdae44e2d0       %r9  = 0x0000000000000000
%rcx = 0x000000061bf989a0       %r10 = 0x000000061bf989a0
%rdx = 0xffff80fdae44e2d0       %r11 = 0x00007ff91dcbfe90
%rsi = 0x0000000000000010       %r12 = 0xffff80fdae44e2d8
%rdi = 0x0000000000000002       %r13 = 0x0000000000000000
...
> // rax = 0x98 = 152 // modctl的系统调用号
> // rdi = 0x2        // cmd MODINFO = 2
> // rsi = 0x10 = 16  // mod ID
> // rdx = 0xffff80fdae44e2d0 // struct modinfo *
> 0xffff80fdae44e2d0::print struct modinfo mi_id mi_name mi_msinfo[0]
mi_id = 0x10
mi_name = [ '\0', ... ]
mi_msinfo[0] = {
mi_msinfo[0].msi_linkinfo = [ '\001', ... ]
mi_msinfo[0].msi_p0 = 0xae44e438
}
>

> :s   // 现在不能按回车键, 一旦按下回车键，就执行syscall进入内核模式

o 在终端B(console)上启动mdb -K, 设置断点modctl:b; 这样，一旦在终端A >:s 后敲入回车，立即进入内核模式，可从终端B上观察到

root# mdb -K
kmdb: target stopped at:
kmdb_enter+0xb: movq   %rax,%rdi
[5]> modctl:b
[5]> :c
root#

o 在终端A上键入回车

> :s
[光标在此闪烁]；用户程序被暂停了！

与此同时，终端B上进入内核模式

root# mdb -K
kmdb: target stopped at:
kmdb_enter+0xb: movq   %rax,%rdi
[5]> modctl:b
[5]> :c
root# kmdb: stop at modctl
kmdb: target stopped at:
modctl:         pushq  %rbp
[22]>

o 在终端B上查看调用参数

[22]> $r
%rax = 0x0000000000001300                 %r9  = 0x0000000000000000
%rbx = 0xfffffffffc243480   sysent+0x1300 %r10 = 0xffff80fdae44e5d8
%rcx = 0x000000061bf989a0                 %r11 = 0xffff80fdae44e268
%rdx = 0xffff80fdae44e2d0                 %r12 = 0x0000000000000000
%rsi = 0x0000000000000010                 %r13 = 0x0000000000000000
%rdi = 0x0000000000000002                 %r14 = 0xffffa1c009e87000
%r8  = 0x0000000000000000                 %r15 = 0xffffa1c00458a4c0

%rip = 0xfffffffffbcad4e0 modctl
...

> // rdi = 0x2
> // rsi = 0x10
> // rdx = 0xffff80fdae44e2d0
[22]> 0xffff80fdae44e2d0::print struct modinfo mi_id mi_name
mi_id = 0x10
mi_name = [ '\0', ...]

o 在终端B上输入 :z, :c返回

[22]>
[22]> :z
[22]> :c

与此同时，终端A上的被暂停的:s被激活，
> :s
mdb: target stopped at:
libc.so.1`modctl+0xa:   jb     -0x126d30        <libc.so.1`__cerror>
>

说明内核调用已经结束，返回到用户模式。

o 在终端A上查看地址0xffff80fdae44e2d0处的内容，我们期望的数据应该已被内核调用填好

> 0xffff80fdae44e2d0::print struct modinfo
{
mi_info = 5
mi_state = 3
mi_id = 0x10
mi_nextid = 0x10
mi_base = 0xfffffffffbdbc2d8
mi_size = 0x5d198
mi_rev = 1
mi_loadcnt = 1
mi_name = [ "pcie" ]
mi_msinfo = [
{
msi_linkinfo = [ "PCI Express Framework Module" ]
msi_p0 = 0xffffffff
},
...

注意: mis_base, mi_size, mi_name, ms_msinfo[0]中的数据已如我们期望的被填充好。

ID  LOADADDR         SIZE   INFO REV NAMEDESC
16  fffffffffbdbc2d8 5d198  --   1   pcie (PCI Express Framework Module)
mdb: target has terminated
>

到此为止，我们观察到了从用户模式进入内核模式，再从内核模式返回到用户模式的全过程。系统调用的神秘面纱已经被揭开。接下来将用DTrace深入观察内核服务例程的行为。

 

3.2 使用DTrace观察内核行为

o 在终端A启动mdb, 调试命令modinfo

root# mdb /usr/sbin/modinfo
> main:b
> :r -i 16
mdb: target stopped at:
ld.so.1`rtld_db_postinit:       pushq  %rbp
> :c
mdb: target stopped at:
ld.so.1`rtld_db_dlactivity:     pushq  %rbp
mdb: You've got symbols!
Loading modules: [ ld.so.1 libc.so.1 libuutil.so.1 ]
> modctl:b
> :c
mdb: stop at libc.so.1`modctl
mdb: target stopped at:
libc.so.1`modctl:       movq   %rcx,%r10
> :s
mdb: target stopped at:
libc.so.1`modctl+3:     movl   $0x98,%eax
> :s
mdb: target stopped at:
libc.so.1`modctl+8:     syscall
>
> $r
%rax = 0x0000000000000098       %r8  = 0x0000000000000000
%rbx = 0xffff80dbdcb43120       %r9  = 0x0000000000000000
%rcx = 0x0000000f25c48f90       %r10 = 0x0000000f25c48f90
%rdx = 0xffff80dbdcb43120       %r11 = 0x00007ffdc84bfe90
%rsi = 0x0000000000000010       %r12 = 0xffff80dbdcb43128
%rdi = 0x0000000000000002       %r13 = 0x0000000000000000
...
> 0xffff80dbdcb43120::print struct modinfo mi_id mi_name
mi_id = 0x10
mi_name = [ '\0', ...]

o 在终端B启动dtrace脚本

root# ./fook.d

  fook.d的代码如下：

1 #!/usr/sbin/dtrace -qs
2
3 syscall::modctl:entry
4 /execname == "modinfo"/
5 {
6         printf("%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
7         printf("args: 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
8                 arg0, arg1, arg2, arg3, arg4, arg5);
9         stack();
10         printf("\n---------------------------------------------------------\n");
11         self->n = 1;
12 }
13
14 syscall::modctl:return
15 /execname == "modinfo"/
16 {
17         self->n = 0;
18 }
19
20 fbt::modctl:entry
21 /self->n == 1/
22 {
23         printf("%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
24         printf("args: 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
25                 arg0, arg1, arg2, arg3, arg4, arg5);
26         stack();
27         printf("\n---------------------------------------------------------\n");
28 }
29
30 fbt::modctl_modinfo:entry
31 /self->n == 1/
32 {
33         printf("%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
34         printf("args: 0x%X, 0x%X\n", arg0, arg1);
35         stack();
36
37         self->mip = (struct modinfo *)arg1;
38
39         /*
40          * usr/src/uts/common/sys/modctl.h#421
41          * struct modinfo {
42          *     int                mi_info;     // Flags for info wanted
43          *     int                mi_state;    // Flags for module state
44          *     int                mi_id;       // id of this loaded module
45          *     int                mi_nextid;   // id of next module or -1
46          *     caddr_t            mi_base;     // virtual addr of text
47          *     size_t             mi_size;     // size of module in bytes
48          *     int                mi_rev;      // loadable modules rev
49          *     int                mi_loadcnt;  // # of times loaded
50          *     char               mi_name[MODMAXNAMELEN]; // name of module
51          *     struct modspecific_info mi_msinfo[MODMAXLINK];
52          *                                     // mod specific info
53          * };
54          *
55          * struct modspecific_info {
56          *     char    msi_linkinfo[MODMAXLINKINFOLEN]; // name in linkage struct
57          *     int     msi_p0;                 // module specific information
58          * };
59          *
60          * usr/src/cmd/modload/modinfo.c#248
61          *  static boolean_t
62          *  print_mod_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
63          *
64          * XXX: Here we cannot use self->mip->mi_id,... directly, so copyin !
65          */
66         self->mi = (struct modinfo *)(copyin((uintptr_t)(self->mip),
67                                              sizeof(struct modinfo)));
68         printf("\n");
69         printf("ENT: ID       mi->mi_id                     = %d\n",
70                 self->mi->mi_id);
71         printf("ENT: LOADADDR mi->mi_base                   = %p\n",
72                 self->mi->mi_base);
73         printf("ENT: SIZE     mi->mi_size                   = %x\n",
74                 self->mi->mi_size);
75         printf("ENT: INFO     mi->mi_mi_msinfo[0].msi_p0    = %d\n",
76                 self->mi->mi_msinfo[0].msi_p0);
77         printf("ENT: REV      mi->mi_rev                    = %x\n",
78                 self->mi->mi_rev);
79         printf("ENT: NAME     mi->mi_name                   = %s\n",
80                 stringof(self->mi->mi_name));
81         printf("ENT: DESC     mi->mi_msinfo[0].msi_linkinfo = %s\n",
82                 stringof(self->mi->mi_msinfo[0].msi_linkinfo));
83         printf("\n---------------------------------------------------------\n");
84 }
85
86 fbt::modctl_modinfo:return
87 /self->n == 1/
88 {
89         printf("%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
90
91         stack();
92
93         /*
94          * XXX: Here we cannot use self->mip->mi_id,... directly, so copyin !
95          */
96         self->mi = (struct modinfo *)(copyin((uintptr_t)(self->mip),
97                                              sizeof(struct modinfo)));
98         printf("\n");
99         printf("RET: ID       mi->mi_id                     = %d\n",
100                 self->mi->mi_id);
101         printf("RET: LOADADDR mi->mi_base                   = %p\n",
102                 self->mi->mi_base);
103         printf("RET: SIZE     mi->mi_size                   = %x\n",
104                 self->mi->mi_size);
105         printf("RET: INFO     mi->mi_mi_msinfo[0].msi_p0    = %d\n",
106                 self->mi->mi_msinfo[0].msi_p0);
107         printf("RET: REV      mi->mi_rev                    = %x\n",
108                 self->mi->mi_rev);
109         printf("RET: NAME     mi->mi_name                   = %s\n",
110                 stringof(self->mi->mi_name));
111         printf("RET: DESC     mi->mi_msinfo[0].msi_linkinfo = %s\n",
112                 stringof(self->mi->mi_msinfo[0].msi_linkinfo));
113         printf("\n---------------------------------------------------------\n");
114
115         self->mip = 0;
116 }
117
118 fbt::copyin:entry,
119 fbt::copyout:entry
120 /self->n == 1/
121 {
122         printf("%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
123         printf("args: 0x%X, 0x%X, 0x%X\n", arg0, arg1, arg2);
124         stack();
125         printf("\n---------------------------------------------------------\n");
126 }

注意：内核内存和用户内存是严格隔离的，当内核需要访问用户内存时，必须使用copyin();反之，如内核需要把数据传递会用户空间，必须使用copyout()。

o 在终端A中执行:s (执行汇编指令syscall)

> :s
mdb: target stopped at:
libc.so.1`modctl+0xa:   jb     -0x126d30        <libc.so.1`__cerror>
>

与此同时，终端B的输出如下

root# ./fook.d
syscall::modctl :entry
args: 0x2, 0x10, 0xFFFF80DBDCB43120, 0xF25C48F90, 0x0, 0x0

unix`sys_syscall+0x24d

---------------------------------------------------------
fbt:genunix:modctl :entry
args: 0x2, 0x10, 0xFFFF80DBDCB43120, 0xF25C48F90, 0x0, 0x0

genunix`dtrace_systrace_syscall+0x14d
unix`sys_syscall+0x24d

---------------------------------------------------------
fbt:genunix:modctl_modinfo :entry
args: 0x10, 0xFFFF80DBDCB43120

genunix`modctl+0x4e7
genunix`dtrace_systrace_syscall+0x14d
unix`sys_syscall+0x24d

ENT: ID       mi->mi_id                     = 16
ENT: LOADADDR mi->mi_base                   = 0
ENT: SIZE     mi->mi_size                   = 0
ENT: INFO     mi->mi_mi_msinfo[0].msi_p0    = -592170360
ENT: REV      mi->mi_rev                    = 0
ENT: NAME     mi->mi_name                   =
ENT: DESC     mi->mi_msinfo[0].msi_linkinfo = ##

---------------------------------------------------------
fbt:unix:copyin :entry
args: 0xFFFF80DBDCB43120, 0xFFFFFFFC81AEDA30, 0x1B0

genunix`modctl_modinfo+0xa0
genunix`modctl+0x4e7
genunix`dtrace_systrace_syscall+0x14d
unix`sys_syscall+0x24d

---------------------------------------------------------
fbt:unix:copyout :entry
args: 0xFFFFFFFC81AEDA30, 0xFFFF80DBDCB43120, 0x1B0

genunix`modctl_modinfo+0x1e6
genunix`modctl+0x4e7
genunix`dtrace_systrace_syscall+0x14d
unix`sys_syscall+0x24d

---------------------------------------------------------
fbt:genunix:modctl_modinfo :return

genunix`modctl+0x4e7
genunix`dtrace_systrace_syscall+0x14d
unix`sys_syscall+0x24d

RET: ID       mi->mi_id                     = 16
RET: LOADADDR mi->mi_base                   = fffffffffbdbc2d8
RET: SIZE     mi->mi_size                   = 5d198
RET: INFO     mi->mi_mi_msinfo[0].msi_p0    = -1
RET: REV      mi->mi_rev                    = 1
RET: NAME     mi->mi_name                   = pcie
RET: DESC     mi->mi_msinfo[0].msi_linkinfo = PCI Express Framework Module

---------------------------------------------------------

o 在终端A中查看地址0xffff80dbdcb43120的内容

> 0xffff80dbdcb43120::print struct modinfo
{
mi_info = 5
mi_state = 3
mi_id = 0x10
mi_nextid = 0x10
mi_base = 0xfffffffffbdbc2d8
mi_size = 0x5d198
mi_rev = 1
mi_loadcnt = 1
mi_name = [ "pcie" ]
mi_msinfo = [
{
msi_linkinfo = [ "PCI Express Framework Module" ]
msi_p0 = 0xffffffff
},
　　...

该输出跟DTrace中观测到的数据一致。

o 在终端A上执行dtrace脚本观察用户模式下的调用栈

root# ./foou.d -c "modinfo -i 16"
ID  LOADADDR         SIZE   INFO REV NAMEDESC
16  fffffffffbdbc2d8 5d198  --   1   pcie (PCI Express Framework Module)

pid22782:libc.so.1:modctl :entry
args: 0x2, 0x10, 0xFFFF80F02D9A1730, 0x927D90DF0, 0x0

libc.so.1`modctl
modinfo`main+0x3b6
modinfo`0x7ffe48701b34

foou.d的代码如下：

1 #!/usr/sbin/dtrace -qs
2
3 pid$target::modctl:entry
4 /execname == "modinfo"/
5 {
6         printf("\n%s:%s:%s :%s\n", probeprov, probemod, probefunc, probename);
7         printf("args: 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
8                 arg0, arg1, arg2, arg3, arg4);
9         ustack();
10 }

o 在终端B上观察内核模式下的调用栈

(1) 在终端B上启动DTrace,

root# dtrace -n "fbt::mod_infonull:entry {stack();}"
dtrace: description 'fbt::mod_infonull:entry ' matched 1 probe

(2) 在终端A上执行命令 modinfo -i 16

root# modinfo -i 16
ID  LOADADDR         SIZE   INFO REV NAMEDESC
16  fffffffffbdbc2d8 5d198  --   1   pcie (PCI Express Framework Module)

与此同时，终端B上的输出为:

root# dtrace -n "fbt::mod_infonull:entry {stack();}"
dtrace: description 'fbt::mod_infonull:entry ' matched 1 probe
CPU     ID                    FUNCTION:NAME
3  54642               mod_infonull:entry
genunix`mod_info+0x66
pcie`_info+0x1f
genunix`mod_getinfo+0x5a
genunix`modinfo+0x125
genunix`modctl_modinfo+0xd5
genunix`modctl+0x4e7
unix`sys_syscall+0x24d

^C

 

4. 直接使用系统调用编程

下面给出一个简单的例子，说明只需要准备好系统调用号和相应的参数，直接使用汇编指令syscall就可以完成系统调用。

1 BITS 64
2
3 SECTION .data
4
5 Hello:          db "Hello world!", 10
6 len_Hello:      equ $-Hello
7
8 SECTION .text
9
10 global _start
11
12 _start:
13         mov rdi, 1              ; fd = stdout
14         mov rsi, Hello          ; *buf = Hello
15         mov rdx, len_Hello      ; count = len_Hello
16         mov rax, 4              ; write syscall (x86_64)
17         syscall
18
19         mov rdi, 0              ; status = 0 (exit normally)
20         mov rax, 1              ; exit syscall (x86_64)
21         syscall

编译，执行如下所示：

root# yasm -f elf64 foo.asm
root# ld -o foo foo.o
root# ./foo
Hello world!
root# echo $?
0

 

最后，关于如何给Solaris添加一个系统调用，请参考《Solaris内核结构》（第2版）一书的附录B:Adding a System Call to Solaris。

推荐阅读： The Definitive Guide to Linux System Calls