CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Golang标准库syscall详解（什么是系统调用）由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、什么是系统调用

  。

In computing, a system call is the programmatic way in which a computer program requests a service from the kernel of the operating system it is executed on. This may include hardware-related services (for example, accessing a hard disk drive), creation and execution of new processes, and communication with integral kernel services such as process scheduling. System calls provide an essential interface between a process and the operating system. 。

系统调用是程序向操作系统内核请求服务的过程，通常包含硬件相关的服务(例如访问硬盘),创建新进程等。系统调用提供了一个进程和操作系统之间的接口.

2、Golang标准库-syscall

  。

syscall包包含一个指向底层操作系统原语的接口.

注意：该软件包已被锁定。标准以外的代码应该被迁移到golang.org/x/sys存储库中使用相应的软件包。这也是应用新系统或版本所需更新的地方。 Signal ， Errno 和 SysProcAttr 在 golang.org/x/sys 中尚不可用，并且仍然必须从 syscall 程序包中引用。有关更多信息，请参见 https://golang.org/s/go1.4-syscall.

https://pkg.go.dev/golang.org/x/sys 该存储库包含用于与操作系统进行低级交互的补充Go软件包.

1. syscall无处不在 。

举个最常用的例子, fmt.Println(“hello world”), 这里就用到了系统调用 write, 我们翻一下源码.

1. func Println(a ...interface{}) (n int, err error) {
2. return Fprintln(os.Stdout, a...)
3. }

1. Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
2.  
3. func (f *File) write(b []byte) (n int, err error) {
4. if len(b) == 0 {
5. return 0, nil
6. }
7. // 实际的write方法，就是调用syscall.Write()
8. return fixCount(syscall.Write(f.fd, b))
9. }

2. syscall demo举例:

go版本的strace Strace 。

strace 是用于查看进程系统调用的工具, 一般使用方法如下

strace -c 用于统计各个系统调用的次数 。

1. [root@localhost ~]# strace -c echo hello
2. hello
3. % time seconds usecs/call calls errors syscall
4. ------ ----------- ----------- --------- --------- ----------------
5. 0.00 0.000000 0 1 read
6. 0.00 0.000000 0 1 write
7. 0.00 0.000000 0 3 open
8. 0.00 0.000000 0 5 close
9. 0.00 0.000000 0 4 fstat
10. 0.00 0.000000 0 9 mmap
11. 0.00 0.000000 0 4 mprotect
12. 0.00 0.000000 0 2 munmap
13. 0.00 0.000000 0 4 brk
14. 0.00 0.000000 0 1 1 access
15. 0.00 0.000000 0 1 execve
16. 0.00 0.000000 0 1 arch_prctl
17. ------ ----------- ----------- --------- --------- ----------------
18. 100.00 0.000000 36 1 total
19. [root@localhost ~]#

stace 的实现原理是系统调用 ptrace, 我们来看下 ptrace 是什么.

man page 描述如下:

The ptrace() system call provides a means by which one process (the “tracer”) may observe and control the execution of another process (the “tracee”), and examine and change the tracee's memory and registers. It is primarily used to implement breakpoint debuggingand system call tracing. 。

简单来说有三大能力

追踪系统调用 读写内存和寄存器 向被追踪程序传递信号 。

ptrace接口:

1. int ptrace(int request, pid_t pid, caddr_t addr, int data);
2.  
3. request包含:
4. PTRACE_ATTACH
5. PTRACE_SYSCALL
6. PTRACE_PEEKTEXT, PTRACE_PEEKDATA
7. 等

tracer 使用 PTRACE_ATTACH 命令，指定需要追踪的PID。紧接着调用 PTRACE_SYSCALL。 tracee 会一直运行，直到遇到系统调用，内核会停止执行。 此时，tracer 会收到 SIGTRAP 信号，tracer 就可以打印内存和寄存器中的信息了.

接着，tracer 继续调用 PTRACE_SYSCALL, tracee 继续执行，直到 tracee退出当前的系统调用。 需要注意的是，这里在进入syscall和退出syscall时，tracer都会察觉.

go版本的strace

  。

了解以上内容后，presenter 现场实现了一个go版本的strace, 需要在 linux amd64 环境编译。 https://github.com/silentred/gosys 。

// strace.go 。

1. package main
2.  
3. import (
4. "fmt"
5. "os"
6. "os/exec"
7. "syscall"
8. )
9.  
10. func main() {
11. var err error
12. var regs syscall.PtraceRegs
13. var ss syscallCounter
14. ss = ss.init()
15.  
16. fmt.Println("Run: ", os.Args[1:])
17.  
18. cmd := exec.Command(os.Args[1], os.Args[2:]...)
19. cmd.Stderr = os.Stderr
20. cmd.Stdout = os.Stdout
21. cmd.Stdin = os.Stdin
22. cmd.SysProcAttr = &syscall.SysProcAttr{
23. Ptrace: true,
24. }
25.  
26. cmd.Start()
27. err = cmd.Wait()
28. if err != nil {
29. fmt.Printf("Wait err %v \n", err)
30. }
31.  
32. pid := cmd.Process.Pid
33. exit := true
34.  
35. for {
36. // 记得 PTRACE_SYSCALL 会在进入和退出syscall时使 tracee 暂停，所以这里用一个变量控制，RAX的内容只打印一遍
37. if exit {
38. err = syscall.PtraceGetRegs(pid, &regs)
39. if err != nil {
40. break
41. }
42. //fmt.Printf("%#v \n",regs)
43. name := ss.getName(regs.Orig_rax)
44. fmt.Printf("name: %s, id: %d \n", name, regs.Orig_rax)
45. ss.inc(regs.Orig_rax)
46. }
47. // 上面Ptrace有提到的一个request命令
48. err = syscall.PtraceSyscall(pid, 0)
49. if err != nil {
50. panic(err)
51. }
52. // 猜测是等待进程进入下一个stop，这里如果不等待，那么会打印大量重复的调用函数名
53. _, err = syscall.Wait4(pid, nil, 0, nil)
54. if err != nil {
55. panic(err)
56. }
57.  
58. exit = !exit
59. }
60.  
61. ss.print()
62. }

// 用于统计信息的counter, syscallcounter.go 。

1. package main
2.  
3. import (
4. "fmt"
5. "os"
6. "text/tabwriter"
7.  
8. "github.com/seccomp/libseccomp-golang"
9. )
10.  
11. type syscallCounter []int
12.  
13. const maxSyscalls = 303
14.  
15. func (s syscallCounter) init() syscallCounter {
16. s = make(syscallCounter, maxSyscalls)
17. return s
18. }
19.  
20. func (s syscallCounter) inc(syscallID uint64) error {
21. if syscallID > maxSyscalls {
22. return fmt.Errorf("invalid syscall ID (%x)", syscallID)
23. }
24.  
25. s[syscallID]++
26. return nil
27. }
28.  
29. func (s syscallCounter) print() {
30. w := tabwriter.NewWriter(os.Stdout, 0, 0, 8, ' ', tabwriter.AlignRight|tabwriter.Debug)
31. for k, v := range s {
32. if v > 0 {
33. name, _ := seccomp.ScmpSyscall(k).GetName()
34. fmt.Fprintf(w, "%d\t%s\n", v, name)
35. }
36. }
37. w.Flush()
38. }
39.  
40. func (s syscallCounter) getName(syscallID uint64) string {
41. name, _ := seccomp.ScmpSyscall(syscallID).GetName()
42. return name
43. }

最后结果:

Run:  [echo hello] Wait err stop signal: trace/breakpoint trap name: execve, id: 59 name: brk, id: 12 name: access, id: 21 name: mmap, id: 9 name: access, id: 21 name: open, id: 2 name: fstat, id: 5 name: mmap, id: 9 name: close, id: 3 name: access, id: 21 name: open, id: 2 name: read, id: 0 name: fstat, id: 5 name: mmap, id: 9 name: mprotect, id: 10 name: mmap, id: 9 name: mmap, id: 9 name: close, id: 3 name: mmap, id: 9 name: arch_prctl, id: 158 name: mprotect, id: 10 name: mprotect, id: 10 name: mprotect, id: 10 name: munmap, id: 11 name: brk, id: 12 name: brk, id: 12 name: open, id: 2 name: fstat, id: 5 name: mmap, id: 9 name: close, id: 3 name: fstat, id: 5 hello name: write, id: 1 name: close, id: 3 name: close, id: 3         1|read         1|write         3|open         5|close         4|fstat         7|mmap         4|mprotect         1|munmap         3|brk         3|access         1|execve         1|arch_prctl 。

3、参考

  。

Golang标准库——syscall 参考URL： https://www.jianshu.com/p/44109d5e045b Golang 与系统调用 参考URL: https://blog.csdn.net/weixin_33744141/article/details/89033990 。

以上就是Golang标准库syscall详解（什么是系统调用）的详细内容，更多关于Golang标准库syscall的资料请关注我其它相关文章！ 。

原文链接：https://blog.csdn.net/inthat/article/details/117248718 。

最后此篇关于Golang标准库syscall详解（什么是系统调用）的文章就讲到这里了,如果你想了解更多关于Golang标准库syscall详解（什么是系统调用）的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。