2019年11月

让我们通过本系列文章来学习基本的 Bash 编程语法和工具,以及如何使用变量和控制运算符,这是三篇中的第一篇。

Shell 是操作系统的命令解释器,其中 Bash 是我最喜欢的。每当用户或者系统管理员将命令输入系统的时候,Linux 的 shell 解释器就会把这些命令转换成操作系统可以理解的形式。而执行结果返回 shell 程序后,它会将结果输出到 STDOUT(标准输出),默认情况下,这些结果会显示在你的终端。所有我熟悉的 shell 同时也是一门编程语言。

Bash 是个功能强大的 shell,包含众多便捷特性,比如:tab 补全、命令回溯和再编辑、别名等。它的命令行默认编辑模式是 Emacs,但是我最喜欢的 Bash 特性之一是我可以将其更改为 Vi 模式,以使用那些储存在我肌肉记忆中的的编辑命令。

然而,如果你把 Bash 当作单纯的 shell 来用,则无法体验它的真实能力。我在设计一套包含三卷的 Linux 自学课程时(这个系列的文章正是基于此课程),了解到许多 Bash 的知识,这些是我在过去 20 年的 Linux 工作经验中所没有掌握的,其中的一些知识就是关于 Bash 的编程用法。不得不说,Bash 是一门强大的编程语言,是一个能够同时用于命令行和 shell 脚本的完美设计。

本系列文章将要探讨如何使用 Bash 作为命令行界面(CLI)编程语言。第一篇文章简单介绍 Bash 命令行编程、变量以及控制运算符。其他文章会讨论诸如:Bash 文件的类型;字符串、数字和一些逻辑运算符,它们能够提供代码执行流程中的逻辑控制;不同类型的 shell 扩展;通过 forwhileuntil 来控制循环操作。

Shell

Bash 是 Bourne Again Shell 的缩写,因为 Bash shell 是 基于 更早的 Bourne shell,后者是 Steven Bourne 在 1977 年开发的。另外还有很多其他的 shell 可以使用,但下面四个是我经常见到的:

  • csh:C shell 适合那些习惯了 C 语言语法的开发者。
  • ksh:Korn shell,由 David Korn 开发,在 Unix 用户中更流行。
  • tcsh:一个 csh 的变种,增加了一些易用性。
  • zsh:Z shell,集成了许多其他流行 shell 的特性。

所有 shell 都有内置命令,用以补充或替代核心工具集。打开 shell 的 man 说明页,找到“BUILT-INS”那一段,可以查看都有哪些内置命令。

每种 shell 都有它自己的特性和语法风格。我用过 csh、ksh 和 zsh,但我还是更喜欢 Bash。你可以多试几个,寻找更适合你的 shell,尽管这可能需要花些功夫。但幸运的是,切换不同 shell 很简单。

所有这些 shell 既是编程语言又是命令解释器。下面我们来快速浏览一下 Bash 中集成的编程结构和工具。

作为编程语言的 Bash

大多数场景下,系统管理员都会使用 Bash 来发送简单明了的命令。但 Bash 不仅可以输入单条命令,很多系统管理员可以编写简单的命令行程序来执行一系列任务,这些程序可以作为通用工具,能节省时间和精力。

编写 CLI 程序的目的是要提高效率(做一个“懒惰的”系统管理员)。在 CLI 程序中,你可以用特定顺序列出若干命令,逐条执行。这样你就不用盯着显示屏,等待一条命令执行完,再输入另一条,省下来的时间就可以去做其他事情了。

什么是“程序”?

自由在线计算机词典(FOLDOC)对于程序的定义是:“由计算机执行的指令,而不是运行它们的物理硬件。”普林斯顿大学的 WordNet 将程序定义为:“……计算机可以理解并执行的一系列指令……”维基百科上也有一条不错的关于计算机程序的条目。

总结下,程序由一条或多条指令组成,目的是完成一个具体的相关任务。对于系统管理员而言,一段程序通常由一系列的 shell 命令构成。Linux 下所有的 shell (至少我所熟知的)都有基本的编程功能,Bash 作为大多数 linux 发行版的默认 shell,也不例外。

本系列用 Bash 举例(因为它无处不在),假如你使用一个不同的 shell 也没关系,尽管结构和语法有所不同,但编程思想是相通的。有些 shell 支持某种特性而其他 shell 则不支持,但它们都提供编程功能。Shell 程序可以被存在一个文件中被反复使用,或者在需要的时候才创建它们。

简单 CLI 程序

最简单的命令行程序只有一或两条语句,它们可能相关,也可能无关,在按回车键之前被输入到命令行。程序中的第二条语句(如果有的话)可能取决于第一条语句的操作,但也不是必须的。

这里需要特别讲解一个标点符号。当你在命令行输入一条命令,按下回车键的时候,其实在命令的末尾有一个隐含的分号(;)。当一段 CLI shell 程序在命令行中被串起来作为单行指令使用时,必须使用分号来终结每个语句并将其与下一条语句分开。但 CLI shell 程序中的最后一条语句可以使用显式或隐式的分号。

一些基本语法

下面的例子会阐明这一语法规则。这段程序由单条命令组成,还有一个显式的终止符:

[student@studentvm1 ~]$ echo "Hello world." ;
Hello world.

看起来不像一个程序,但它确是我学习每个新编程语言时写下的第一个程序。不同语言可能语法不同,但输出结果是一样的。

让我们扩展一下这段微不足道却又无所不在的代码。你的结果可能与我的有所不同,因为我的家目录有点乱,而你可能是在 GUI 桌面中第一次登录账号。

[student@studentvm1 ~]$ echo "My home directory." ; ls ;
My home directory.
chapter25   TestFile1.Linux  dmesg2.txt  Downloads  newfile.txt  softlink1  testdir6
chapter26   TestFile1.mac    dmesg3.txt  file005    Pictures     Templates  testdir
TestFile1      Desktop       dmesg.txt   link3      Public       testdir    Videos
TestFile1.dos  dmesg1.txt    Documents   Music      random.txt   testdir1

现在是不是更明显了。结果是相关的,但是两条语句彼此独立。你可能注意到我喜欢在分号前后多输入一个空格,这样会让代码的可读性更好。让我们再运行一遍这段程序,这次不要带结尾的分号:

[student@studentvm1 ~]$ echo "My home directory." ; ls

输出结果没有区别。

关于变量

像所有其他编程语言一样,Bash 支持变量。变量是个象征性的名字,它指向内存中的某个位置,那里存着对应的值。变量的值是可以改变的,所以它叫“变~量”。

Bash 不像 C 之类的语言,需要强制指定变量类型,比如:整型、浮点型或字符型。在 Bash 中,所有变量都是字符串。整数型的变量可以被用于整数运算,这是 Bash 唯一能够处理的数学类型。更复杂的运算则需要借助 bc 这样的命令,可以被用在命令行编程或者脚本中。

变量的值是被预先分配好的,这些值可以用在命令行编程或者脚本中。可以通过变量名字给其赋值,但是不能使用 $ 符开头。比如,VAR=10 这样会把 VAR 的值设为 10。要打印变量的值,你可以使用语句 echo $VAR。变量名必须以文本(即非数字)开始。

Bash 会保存已经定义好的变量,直到它们被取消掉。

下面这个例子,在变量被赋值前,它的值是空(null)。然后给它赋值并打印出来,检验一下。你可以在同一行 CLI 程序里完成它:

[student@studentvm1 ~]$ echo $MyVar ; MyVar="Hello World" ; echo $MyVar ;

Hello World
[student@studentvm1 ~]$

注意:变量赋值的语法非常严格,等号(=)两边不能有空格。

那个空行表明了 MyVar 的初始值为空。变量的赋值和改值方法都一样,这个例子展示了原始值和新的值。

正如之前说的,Bash 支持整数运算,当你想计算一个数组中的某个元素的位置,或者做些简单的算术运算,这还是挺有帮助的。然而,这种方法并不适合科学计算,或是某些需要小数运算的场景,比如财务统计。这些场景有其它更好的工具可以应对。

下面是个简单的算术题:

[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1*Var2))"
Result = 63

好像没啥问题,但如果运算结果是浮点数会发生什么呢?

[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1/Var2))"
Result = 0
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var2/Var1))"
Result = 1
[student@studentvm1 ~]$

结果会被取整。请注意运算被包含在 echo 语句之中,其实计算在 echo 命令结束前就已经完成了,原因是 Bash 的内部优先级。想要了解详情的话,可以在 Bash 的 man 页面中搜索 “precedence”。

控制运算符

Shell 的控制运算符是一种语法运算符,可以轻松地创建一些有趣的命令行程序。在命令行上按顺序将几个命令串在一起,就变成了最简单的 CLI 程序:

command1 ; command2 ; command3 ; command4 ; . . . ; etc. ;

只要不出错,这些命令都能顺利执行。但假如出错了怎么办?你可以预设好应对出错的办法,这就要用到 Bash 内置的控制运算符, &&||。这两种运算符提供了流程控制功能,使你能改变代码执行的顺序。分号也可以被看做是一种 Bash 运算符,预示着新一行的开始。

&& 运算符提供了如下简单逻辑,“如果 command1 执行成功,那么接着执行 command2。如果 command1 失败,就跳过 command2。”语法如下:

command1 && command2

现在,让我们用命令来创建一个新的目录,如果成功的话,就把它切换为当前目录。确保你的家目录(~)是当前目录,先尝试在 /root 目录下创建,你应该没有权限:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir/ && cd $Dir
mkdir: cannot create directory '/root/testdir/': Permission denied
[student@studentvm1 ~]$

上面的报错信息是由 mkdir 命令抛出的,因为创建目录失败了。&& 运算符收到了非零的返回码,所以 cd 命令就被跳过,前者阻止后者继续运行,因为创建目录失败了。这种控制流程可以阻止后面的错误累积,避免引发更严重的问题。是时候讲点更复杂的逻辑了。

当一段程序的返回码大于零时,使用 || 运算符可以让你在后面接着执行另一段程序。简单语法如下:

command1 || command2

解读一下,“假如 command1 失败,执行 command2”。隐藏的逻辑是,如果 command1 成功,跳过 command2。下面实践一下,仍然是创建新目录:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$

正如预期,因为目录无法创建,第一条命令失败了,于是第二条命令被执行。

&&|| 两种运算符结合起来才能发挥它们的最大功效。请看下面例子中的流程控制方法:

前置 commands ; command1 && command2 || command3 ; 跟随 commands

语法解释:“假如 command1 退出时返回码为零,就执行 command2,否则执行 command3。”用具体代码试试:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$

现在我们再试一次,用你的家目录替换 /root 目录,你将会有权限创建这个目录了:

[student@studentvm1 ~]$ Dir=~/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
[student@studentvm1 testdir]$

command1 && command2 这样的控制语句能够运行的原因是,每条命令执行完毕时都会给 shell 发送一个返回码,用来表示它执行成功与否。默认情况下,返回码为 0 表示成功,其他任何正值表示失败。一些系统管理员使用的工具用值为 1 的返回码来表示失败,但其他很多程序使用别的数字来表示失败。

Bash 的内置变量 $? 可以显示上一条命令的返回码,可以在脚本或者命令行中非常方便地检查它。要查看返回码,让我们从运行一条简单的命令开始,返回码的结果总是上一条命令给出的。

[student@studentvm1 testdir]$ ll ; echo "RC = $?"
total 1264
drwxrwxr-x  2 student student   4096 Mar  2 08:21 chapter25
drwxrwxr-x  2 student student   4096 Mar 21 15:27 chapter26
-rwxr-xr-x  1 student student     92 Mar 20 15:53 TestFile1
drwxrwxr-x. 2 student student 663552 Feb 21 14:12 testdir
drwxr-xr-x. 2 student student   4096 Dec 22 13:15 Videos
RC = 0
[student@studentvm1 testdir]$

在这个例子中,返回码为零,意味着命令执行成功了。现在对 root 的家目录测试一下,你应该没有权限:

[student@studentvm1 testdir]$ ll /root ; echo "RC = $?"
ls: cannot open directory '/root': Permission denied
RC = 2
[student@studentvm1 testdir]$

本例中返回码是 2,表明非 root 用户没有权限进入这个目录。你可以利用这些返回码,用控制运算符来改变程序执行的顺序。

总结

本文将 Bash 看作一门编程语言,并从这个视角介绍了它的简单语法和基础工具。我们学习了如何将数据输出到 STDOUT,怎样使用变量和控制运算符。在本系列的下一篇文章中,将会重点介绍能够控制指令执行流程的逻辑运算符。


via: https://opensource.com/article/19/10/programming-bash-part-1

作者:David Both 选题:lujun9972 译者:jdh8383 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

本快速教程介绍了更新 Fedora Linux 安装的多种方法。

前几天,我安装了新发布的 Fedora 31。老实说,这是我第一次使用非 Ubuntu 发行版

安装 Fedora 之后,我做的第一件事就是尝试安装一些软件。我打开软件中心,发现该软件中心已“损坏”。 我无法从中安装任何应用程序。

我不确定我的系统出了什么问题。在团队内部讨论时,Abhishek 建议我先更新系统。我更新了,更新后一切恢复正常。更新 Fedora 系统后,软件中心也能正常工作了。

有时我们一直尝试解决我们所面临的问题,而忽略了对系统的更新。不管问题有多大或多小,为了避免它们,你都应该保持系统更新。

在本文中,我将向你展示更新 Fedora Linux 系统的多种方法。

  • 使用软件中心更新 Fedora
  • 使用命令行更新 Fedora
  • 从系统设置更新 Fedora

请记住,更新 Fedora 意味着安装安全补丁、更新内核和软件。如果要从 Fedora 的一个版本更新到另一个版本,这称为版本升级,你可以在此处阅读有关 Fedora 版本升级过程的信息

从软件中心更新 Fedora

软件中心

你很可能会收到通知,通知你有一些系统更新需要查看,你应该在单击该通知时启动软件中心。

你所要做的就是 —— 点击“更新”,并验证 root 密码开始更新。

如果你没有收到更新的通知,则只需启动软件中心并转到“更新”选项卡即可。现在,你只需要继续更新。

使用终端更新 Fedora

如果由于某种原因无法加载软件中心,则可以使用 dnf 软件包管理命令轻松地更新系统。

只需启动终端并输入以下命令即可开始更新(系统将提示你确认 root 密码):

sudo dnf upgrade

**dnf 更新 vs dnf 升级 **

你会发现有两个可用的 dnf 命令:dnf updatednf upgrade。这两个命令执行相同的工作,即安装 Fedora 提供的所有更新。那么,为什么要会有这两个呢,你应该使用哪一个?dnf update 基本上是 dnf upgrade 的别名。尽管 dnf update 可能仍然有效,但最好使用 dnf upgrade,因为这是真正的命令。

从系统设置中更新 Fedora

如果其它方法都不行(或者由于某种原因已经进入“系统设置”),请导航至“设置”底部的“详细信息”选项。

如上图所示,该选项中显示操作系统和硬件的详细信息以及一个“检查更新”按钮。你只需要单击它并提供 root 密码即可继续安装可用的更新。

总结

如上所述,更新 Fedora 系统非常容易。有三种方法供你选择,因此无需担心。

如果你按上述说明操作时发现任何问题,请随时在下面的评论部分告诉我。


via: https://itsfoss.com/update-fedora/

作者:Ankush Das 选题:lujun9972 译者:Morisun029 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Google Keyboard

操作鼠标、键盘和菜单会占用我们很多时间,这些可以使用键盘快捷键来节省时间。这不仅节省时间,还可以使用户更高效。

你是否意识到每次在打字时从键盘切换到鼠标需要多达两秒钟?如果一个人每天工作八小时,每分钟从键盘切换到鼠标一次,并且一年中大约有 240 个工作日,那么所浪费的时间(根据 Brainscape 的计算)为: [每分钟浪费 2 秒] x [每天 480 分钟] x 每年 240 个工作日 = 每年浪费 64 小时 这相当于损失了八个工作日,因此学习键盘快捷键将使生产率提高 3.3%(https://www.brainscape.com/blog/2011/08/keyboard-shortcuts-economy/)。

键盘快捷键提供了一种更快的方式来执行任务,不然就需要使用鼠标和/或菜单分多个步骤来完成。图 1 列出了 Ubuntu 18.04 Linux 和 Web 浏览器中一些最常用的快捷方式。我省略了非常有名的快捷方式,例如复制、粘贴等,以及不经常使用的快捷方式。读者可以参考在线资源以获得完整的快捷方式列表。请注意,Windows 键在 Linux 中被重命名为 Super 键。

常规快捷方式

下面列出了常规快捷方式。

打印屏幕和屏幕录像

以下快捷方式可用于打印屏幕或录制屏幕视频。

在应用之间切换

此处列出的快捷键可用于在应用之间切换。

平铺窗口

可以使用下面提供的快捷方式以不同方式将窗口平铺。

浏览器快捷方式

此处列出了浏览器最常用的快捷方式。大多数快捷键对于 Chrome/Firefox 浏览器是通用的。

组合键行为
Ctrl + T打开一个新标签。
Ctrl + Shift + T打开最近关闭的标签。
Ctrl + D添加一个新书签。
Ctrl + W关闭浏览器标签。
Alt + D将光标置于浏览器的地址栏中。
F5 或 Ctrl-R刷新页面。
Ctrl + Shift + Del清除私人数据和历史记录。
Ctrl + N打开一个新窗口。
Home滚动到页面顶部。
End滚动到页面底部。
Ctrl + J打开下载文件夹(在 Chrome 中)
F11全屏视图(切换效果)

终端快捷方式

这是终端快捷方式的列表。

你还可以在 Ubuntu 中配置自己的自定义快捷方式,如下所示:

  • 在 Ubuntu Dash 中单击设置。
  • 在“设置”窗口的左侧菜单中选择“设备”选项卡。
  • 在设备菜单中选择键盘标签。
  • 右面板的底部有个 “+” 按钮。点击 “+” 号打开自定义快捷方式对话框并配置新的快捷方式。

学习本文提到的三个快捷方式可以节省大量时间,并使你的工作效率更高。

引用

[Cohen, Andrew. How keyboard shortcuts could revive America’s economy; www.brainscape.com. [Online] Brainscape, 26 May 2017;](https://www.brainscape.com/blog/2011/08/keyboard-shortcuts-economy/)


via: https://opensourceforu.com/2019/11/keyboard-shortcuts-to-speed-up-your-work-in-linux/

作者:S Sathyanarayanan 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

介绍一下 bmon,这是一个监视和调试工具,可捕获网络统计信息并使它们易于理解。

bmon 是一种监视和调试工具,可在终端窗口中捕获网络统计信息,并提供了如何以易于理解的形式显示以及显示多少数据的选项。

要检查系统上是否安装了 bmon,请使用 which 命令:

$ which bmon
/usr/bin/bmon

获取 bmon

在 Debian 系统上,使用 sudo apt-get install bmon 安装该工具。

对于 Red Hat 和相关发行版,你可以使用 yum install bmonsudo dnf install bmon 进行安装。或者,你可能必须使用更复杂的安装方式,例如使用以下命令,这些命令首先使用 root 帐户或 sudo 来设置所需的 libconfuse

# wget https://github.com/martinh/libconfuse/releases/download/v3.2.2/confuse-3.2.2.zip
# unzip confuse-3.2.2.zip && cd confuse-3.2.2
# sudo PATH=/usr/local/opt/gettext/bin:$PATH ./configure
# make
# make install
# git clone https://github.com/tgraf/bmon.git &&ammp; cd bmon
# ./autogen.sh
# ./configure
# make
# sudo make install

前面五行会安装 libconfuse,而后面五行会获取并安装 bmon 本身。

使用 bmon

启动 bmon 的最简单方法是在命令行中键入 bmon。根据你正在使用的窗口的大小,你能够查看并显示各种数据。

显示区域的顶部将显示你的网络接口的统计信息:环回接口(lo)和可通过网络访问的接口(例如 eth0)。如果你的终端窗口只有区区几行高,下面这就是你可能会看到的所有内容,它将看起来像这样:

lo bmon 4.0
Interfaces                     x RX bps pps     %x TX bps pps     %
 >lo                           x      4B0      x0     0 0     4B        0
    qdisc none (noqueue) x      0 0      x      0 0
  enp0s25                      x    244B0      x1     0 0   470B        2
    qdisc none (fq_codel)      x      0 0      x      0 0   462B        2
q Increase screen height to see graphical statistics qq


q Press d to enable detailed statistics qq
q Press i to enable additional information qq
 Wed Oct 23 14:36:27 2019 Press ? for help

在此示例中,网络接口是 enp0s25。请注意列出的接口下方的有用的 “Increase screen height” 提示。拉伸屏幕以增加足够的行(无需重新启动 bmon),你将看到一些图形:

Interfaces                     x RX bps       pps     %x TX bps       pps     %
 >lo                           x      0         0      x      0         0
    qdisc none (noqueue)       x      0         0      x      0         0
  enp0s25                      x    253B        3      x   2.65KiB      6
    qdisc none (fq_codel)      x      0         0      x   2.62KiB      6
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
                              (RX Bytes/second)
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
         1   5   10   15   20   25   30   35   40   45   50   55   60
                              (TX Bytes/second)
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
    0.00 ............................................................
         1   5   10   15   20   25   30   35   40   45   50   55   60

但是请注意,该图形未显示值。这是因为它正在显示环回 “>lo” 接口。按下箭头键指向公共网络接口,你将看到一些流量。

Interfaces                     x RX bps       pps     %x TX bps       pps     %
  lo                           x      0         0      x      0         0
    qdisc none (noqueue)       x      0         0      x      0         0
 >enp0s25                      x    151B        2      x   1.61KiB      3
    qdisc none (fq_codel)      x      0         0      x   1.60KiB      3
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
       B                      (RX Bytes/second)
  635.00 ...............................|............................
  529.17 .....|.........................|....|.......................
  423.33 .....|................|..|..|..|..|.|.......................
  317.50 .|..||.|..||.|..|..|..|..|..|..||.||||......................
  211.67 .|..||.|..||.|..||||.||.|||.||||||||||......................
  105.83 ||||||||||||||||||||||||||||||||||||||......................
         1   5   10   15   20   25   30   35   40   45   50   55   60
     KiB                      (TX Bytes/second)
    4.59 .....................................|......................
    3.83 .....................................|......................
    3.06 ....................................||......................
    2.30 ....................................||......................
    1.53 |||..............|..|||.|...|.|||.||||......................
    0.77 ||||||||||||||||||||||||||||||||||||||......................
         1   5   10   15   20   25   30   35   40   45   50   55   60


q Press d to enable detailed statistics qq
q Press i to enable additional information qq
 Wed Oct 23 16:42:06 2019 Press ? for help

通过更改接口,你可以查看显示了网络流量的图表。但是请注意,默认值是按每秒字节数显示的。要按每秒位数来显示,你可以使用 bmon -b 启动该工具。

如果你的窗口足够大并按下 d 键,则可以显示有关网络流量的详细统计信息。你看到的统计信息示例如下所示。由于其宽度太宽,该显示分为左右两部分。

左侧:

RX        TX   │                  RX      TX   │
 Bytes          11.26MiB  11.26MiB│ Packets       25.91K  25.91K  │
 Collisions         -         0   │ Compressed        0       0   │
 Errors             0         0   │ FIFO Error        0       0   │
 ICMPv6             2         2   │ ICMPv6 Checksu    0       -   │
 Ip6 Broadcast      0         0   │ Ip6 Broadcast     0       0   │
 Ip6 Delivers       8         -   │ Ip6 ECT(0) Pac    0       -   │
 Ip6 Header Err     0         -   │ Ip6 Multicast     0     152B  │
 Ip6 Non-ECT Pa     8         -   │ Ip6 Reasm/Frag    0       0   │
 Ip6 Reassembly     0         -   │ Ip6 Too Big Er    0       -   │
 Ip6Discards        0         0   │ Ip6Octets       530B    530B  │
 Missed Error       0         -   │ Multicast         -       0   │
 Window Error       -         0   │                               │

右侧:

│                  RX      TX   │                  RX      TX
│ Abort Error       -       0   │ Carrier Error     -       0
│ CRC Error         0       -   │ Dropped           0       0
│ Frame Error       0       -   │ Heartbeat Erro    -
│ ICMPv6 Errors     0       0   │ Ip6 Address Er    0       -
│ Ip6 CE Packets    0       -   │ Ip6 Checksum E    0       -
│ Ip6 ECT(1) Pac    0       -   │ Ip6 Forwarded     -       0
│ Ip6 Multicast     0       2   │ Ip6 No Route      0       0
│ Ip6 Reasm/Frag    0       0   │ Ip6 Reasm/Frag    0       0
│ Ip6 Truncated     0       -   │ Ip6 Unknown Pr    0       -
│ Ip6Pkts           8       8   │ Length Error      0
│ No Handler        0       -   │ Over Error        0       -

如果按下 i 键,将显示网络接口上的其他信息。

左侧:

MTU                        1500 | Flags    broadcast,multicast,up |
Address       00:1d:09:77:9d:08 | Broadcast ff:ff:ff:ff:ff:ff     |
Family                   unspec | Alias                           |

右侧:

| Operstate                 up | IfIndex                   2 |
| Mode                 default | TXQlen                 1000 |
| Qdisc               fq_codel |

如果你按下 ? 键,将会出现一个帮助菜单,其中简要介绍了如何在屏幕上移动光标、选择要显示的数据以及控制图形如何显示。

要退出 bmon,输入 q,然后输入 y 以响应提示来确认退出。

需要注意的一些重要事项是:

  • bmon 会将其显示调整为终端窗口的大小
  • 显示区域底部显示的某些选项仅在窗口足够大可以容纳数据时才起作用
  • 除非你使用 -R(例如 bmon -R 5)来减慢显示速度,否则每秒更新一次显示

via: https://www.networkworld.com/article/3447936/viewing-network-bandwidth-usage-with-bmon.html

作者:Sandra Henry-Stocker 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

通过这份 Jenkins 分步教程,构建持续集成和持续交付(CI/CD)流水线。

在我的文章《使用开源工具构建 DevOps 流水线的初学者指南》中,我分享了一个从头开始构建 DevOps 流水线的故事。推动该计划的核心技术是 Jenkins,这是一个用于建立持续集成和持续交付(CI/CD)流水线的开源工具。

在花旗,有一个单独的团队为专用的 Jenkins 流水线提供稳定的主从节点环境,但是该环境仅用于质量保证(QA)、构建阶段和生产环境。开发环境仍然是非常手动的,我们的团队需要对其进行自动化以在加快开发工作的同时获得尽可能多的灵活性。这就是我们决定为 DevOps 建立 CI/CD 流水线的原因。Jenkins 的开源版本由于其灵活性、开放性、强大的插件功能和易用性而成为显而易见的选择。

在本文中,我将分步演示如何使用 Jenkins 构建 CI/CD 流水线。

什么是流水线?

在进入本教程之前,了解有关 CI/CD 流水线 pipeline 的知识会很有帮助。

首先,了解 Jenkins 本身并不是流水线这一点很有帮助。只是创建一个新的 Jenkins 作业并不能构建一条流水线。可以把 Jenkins 看做一个遥控器,在这里点击按钮即可。当你点击按钮时会发生什么取决于遥控器要控制的内容。Jenkins 为其他应用程序 API、软件库、构建工具等提供了一种插入 Jenkins 的方法,它可以执行并自动化任务。Jenkins 本身不执行任何功能,但是随着其它工具的插入而变得越来越强大。

流水线是一个单独的概念,指的是按顺序连接在一起的事件或作业组:

流水线 pipeline ”是可以执行的一系列事件或作业。

理解流水线的最简单方法是可视化一系列阶段,如下所示:

 title=

在这里,你应该看到两个熟悉的概念: 阶段 Stage 步骤 Step

  • 阶段:一个包含一系列步骤的块。阶段块可以命名为任何名称;它用于可视化流水线过程。
  • 步骤:表明要做什么的任务。步骤定义在阶段块内。

在上面的示例图中,阶段 1 可以命名为 “构建”、“收集信息”或其它名称,其它阶段块也可以采用类似的思路。“步骤”只是简单地说放上要执行的内容,它可以是简单的打印命令(例如,echo "Hello, World")、程序执行命令(例如,java HelloWorld)、shell 执行命令( 例如,chmod 755 Hello)或任何其他命令,只要通过 Jenkins 环境将其识别为可执行命令即可。

Jenkins 流水线以编码脚本的形式提供,通常称为 “Jenkinsfile”,尽管可以用不同的文件名。下面这是一个简单的 Jenkins 流水线文件的示例:

// Example of Jenkins pipeline script

pipeline {
  stages {
    stage("Build") {
      steps {
          // Just print a Hello, Pipeline to the console
          echo "Hello, Pipeline!"
          // Compile a Java file. This requires JDKconfiguration from Jenkins
          javac HelloWorld.java
          // Execute the compiled Java binary called HelloWorld. This requires JDK configuration from Jenkins
          java HelloWorld
          // Executes the Apache Maven commands, clean then package. This requires Apache Maven configuration from Jenkins
          mvn clean package ./HelloPackage
          // List the files in current directory path by executing a default shell command
          sh "ls -ltr"
      }
    }
   // And next stages if you want to define further...
  } // End of stages
} // End of pipeline

从此示例脚本很容易看到 Jenkins 流水线的结构。请注意,默认情况下某些命令(如 javajavacmvn)不可用,需要通过 Jenkins 进行安装和配置。 因此:

Jenkins 流水线是一种以定义的方式依次执行 Jenkins 作业的方法,方法是将其编码并在多个块中进行结构化,这些块可以包含多个任务的步骤。

好。既然你已经了解了 Jenkins 流水线是什么,我将向你展示如何创建和执行 Jenkins 流水线。在本教程的最后,你将建立一个 Jenkins 流水线,如下所示:

 title=

如何构建 Jenkins 流水线

为了便于遵循本教程的步骤,我创建了一个示例 GitHub 存储库和一个视频教程。

开始本教程之前,你需要:

  • Java 开发工具包(JDK):如果尚未安装,请安装 JDK 并将其添加到环境路径中,以便可以通过终端执行 Java 命令(如 java jar)。这是利用本教程中使用的 Java Web Archive(WAR)版本的 Jenkins 所必需的(尽管你可以使用任何其他发行版)。
  • 基本计算机操作能力:你应该知道如何键入一些代码、通过 shell 执行基本的 Linux 命令以及打开浏览器。

让我们开始吧。

步骤一:下载 Jenkins

导航到 Jenkins 下载页面。向下滚动到 “Generic Java package (.war)”,然后单击下载文件;将其保存在易于找到的位置。(如果你选择其他 Jenkins 发行版,除了步骤二之外,本教程的其余步骤应该几乎相同。)使用 WAR 文件的原因是它是个一次性可执行文件,可以轻松地执行和删除。

 title=

步骤二:以 Java 二进制方式执行 Jenkins

打开一个终端窗口,并使用 cd <your path> 进入下载 Jenkins 的目录。(在继续之前,请确保已安装 JDK 并将其添加到环境路径。)执行以下命令,该命令将 WAR 文件作为可执行二进制文件运行:

java -jar ./jenkins.war

如果一切顺利,Jenkins 应该在默认端口 8080 上启动并运行。

 title=

步骤三:创建一个新的 Jenkins 作业

打开一个 Web 浏览器并导航到 localhost:8080。除非你有以前安装的 Jenkins,否则应直接转到 Jenkins 仪表板。点击 “Create New Jobs”。你也可以点击左侧的 “New Item”。

 title=

步骤四:创建一个流水线作业

在此步骤中,你可以选择并定义要创建的 Jenkins 作业类型。选择 “Pipeline” 并为其命名(例如,“TestPipeline”)。单击 “OK” 创建流水线作业。

 title=

你将看到一个 Jenkins 作业配置页面。向下滚动以找到 “Pipeline” 部分。有两种执行 Jenkins 流水线的方法。一种方法是在 Jenkins 上直接编写流水线脚本,另一种方法是从 SCM(源代码管理)中检索 Jenkins 文件。在接下来的两个步骤中,我们将体验这两种方式。

步骤五:通过直接脚本配置并执行流水线作业

要使用直接脚本执行流水线,请首先从 GitHub 复制该 Jenkinsfile 示例的内容。选择 “Pipeline script” 作为 “Destination”,然后将该 Jenkinsfile 的内容粘贴到 “Script” 中。花一些时间研究一下 Jenkins 文件的结构。注意,共有三个阶段:Build、Test 和 Deploy,它们是任意的,可以是任何一个。每个阶段中都有一些步骤;在此示例中,它们只是打印一些随机消息。

单击 “Save” 以保留更改,这将自动将你带回到 “Job Overview” 页面。

 title=

要开始构建流水线的过程,请单击 “Build Now”。如果一切正常,你将看到第一个流水线(如下面的这个)。

 title=

要查看流水线脚本构建的输出,请单击任何阶段,然后单击 “Log”。你会看到这样的消息。

 title=

步骤六:通过 SCM 配置并执行流水线作业

现在,换个方式:在此步骤中,你将通过从源代码控制的 GitHub 中复制 Jenkinsfile 来部署相同的 Jenkins 作业。在同一个 GitHub 存储库中,通过单击 “Clone or download” 并复制其 URL 来找到其存储库 URL。

 title=

单击 “Configure” 以修改现有作业。滚动到 “Advanced Project Options” 设置,但这一次,从 “Destination” 下拉列表中选择 “Pipeline script from SCM” 选项。将 GitHub 存储库的 URL 粘贴到 “Repository URL” 中,然后在 “Script Path” 中键入 “Jenkinsfile”。 单击 “Save” 按钮保存。

 title=

要构建流水线,回到 “Task Overview” 页面后,单击 “Build Now” 以再次执行作业。结果与之前相同,除了多了一个称为 “Declaration: Checkout SCM” 的阶段。

 title=

要查看来自 SCM 构建的流水线的输出,请单击该阶段并查看 “Log” 以检查源代码控制克隆过程的进行情况。

 title=

除了打印消息,还能做更多

恭喜你!你已经建立了第一个 Jenkins 流水线!

“但是等等”,你说,“这太有限了。除了打印无用的消息外,我什么都做不了。”那没问题。到目前为止,本教程仅简要介绍了 Jenkins 流水线可以做什么,但是你可以通过将其与其他工具集成来扩展其功能。以下是给你的下一个项目的一些思路:

  • 建立一个多阶段的 Java 构建流水线,从以下阶段开始:从 Nexus 或 Artifactory 之类的 JAR 存储库中拉取依赖项、编译 Java 代码、运行单元测试、打包为 JAR/WAR 文件,然后部署到云服务器。
  • 实现一个高级代码测试仪表板,该仪表板将基于 Selenium 的单元测试、负载测试和自动用户界面测试,报告项目的运行状况。
  • 构建多流水线或多用户流水线,以自动化执行 Ansible 剧本的任务,同时允许授权用户响应正在进行的任务。
  • 设计完整的端到端 DevOps 流水线,该流水线可提取存储在 SCM 中的基础设施资源文件和配置文件(例如 GitHub),并通过各种运行时程序执行该脚本。

学习本文结尾处的任何教程,以了解这些更高级的案例。

管理 Jenkins

在 Jenkins 主面板,点击 “Manage Jenkins”。

 title=

全局工具配置

有许多可用工具,包括管理插件、查看系统日志等。单击 “Global Tool Configuration”。

 title=

增加附加能力

在这里,你可以添加 JDK 路径、Git、Gradle 等。配置工具后,只需将该命令添加到 Jenkinsfile 中或通过 Jenkins 脚本执行即可。

 title=

后继

本文为你介绍了使用酷炫的开源工具 Jenkins 创建 CI/CD 流水线的方法。要了解你可以使用 Jenkins 完成的许多其他操作,请在 Opensource.com 上查看以下其他文章:

你可能对我为你的开源之旅而写的其他一些文章感兴趣:


via: https://opensource.com/article/19/9/intro-building-cicd-pipelines-jenkins

作者:Bryant Son 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

使用 strace 跟踪用户进程和 Linux 内核之间的交互。

系统调用 system call 是程序从内核请求服务的一种编程方式,而 strace 是一个功能强大的工具,可让你跟踪用户进程与 Linux 内核之间的交互。

要了解操作系统的工作原理,首先需要了解系统调用的工作原理。操作系统的主要功能之一是为用户程序提供抽象机制。

操作系统可以大致分为两种模式:

  • 内核模式:操作系统内核使用的一种强大的特权模式
  • 用户模式:大多数用户应用程序运行的地方 用户大多使用命令行实用程序和图形用户界面(GUI)来执行日常任务。系统调用在后台静默运行,与内核交互以完成工作。

系统调用与函数调用非常相似,这意味着它们都接受并处理参数然后返回值。唯一的区别是系统调用进入内核,而函数调用不进入。从用户空间切换到内核空间是使用特殊的 trap) 机制完成的。

通过使用系统库(在 Linux 系统上又称为 glibc),大部分系统调用对用户隐藏了。尽管系统调用本质上是通用的,但是发出系统调用的机制在很大程度上取决于机器(架构)。

本文通过使用一些常规命令并使用 strace 分析每个命令进行的系统调用来探索一些实际示例。这些示例使用 Red Hat Enterprise Linux,但是这些命令运行在其他 Linux 发行版上应该也是相同的:

[root@sandbox ~]# cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.7 (Maipo)
[root@sandbox ~]#
[root@sandbox ~]# uname -r
3.10.0-1062.el7.x86_64
[root@sandbox ~]#

首先,确保在系统上安装了必需的工具。你可以使用下面的 rpm 命令来验证是否安装了 strace。如果安装了,则可以使用 -V 选项检查 strace 实用程序的版本号:

[root@sandbox ~]# rpm -qa | grep -i strace
strace-4.12-9.el7.x86_64
[root@sandbox ~]#
[root@sandbox ~]# strace -V
strace -- version 4.12
[root@sandbox ~]#

如果没有安装,运行命令安装:

yum install strace

出于本示例的目的,在 /tmp 中创建一个测试目录,并使用 touch 命令创建两个文件:

[root@sandbox ~]# cd /tmp/
[root@sandbox tmp]#
[root@sandbox tmp]# mkdir testdir
[root@sandbox tmp]#
[root@sandbox tmp]# touch testdir/file1
[root@sandbox tmp]# touch testdir/file2
[root@sandbox tmp]#

(我使用 /tmp 目录是因为每个人都可以访问它,但是你可以根据需要选择另一个目录。)

testdir 目录下使用 ls 命令验证该文件已经创建:

[root@sandbox tmp]# ls testdir/
file1  file2
[root@sandbox tmp]#

你可能每天都在使用 ls 命令,而没有意识到系统调用在其下面发挥的作用。抽象地来说,该命令的工作方式如下:

命令行工具 -> 从系统库(glibc)调用函数 -> 调用系统调用

ls 命令内部从 Linux 上的系统库(即 glibc)调用函数。这些库去调用完成大部分工作的系统调用。

如果你想知道从 glibc 库中调用了哪些函数,请使用 ltrace 命令,然后跟上常规的 ls testdir/命令:

ltrace ls testdir/

如果没有安装 ltrace,键入如下命令安装:

yum install ltrace

大量的输出会被堆到屏幕上;不必担心,只需继续就行。ltrace 命令输出中与该示例有关的一些重要库函数包括:

opendir("testdir/")                                  = { 3 }
readdir({ 3 })                                       = { 101879119, "." }
readdir({ 3 })                                       = { 134, ".." }
readdir({ 3 })                                       = { 101879120, "file1" }
strlen("file1")                                      = 5
memcpy(0x1665be0, "file1\0", 6)                      = 0x1665be0
readdir({ 3 })                                       = { 101879122, "file2" }
strlen("file2")                                      = 5
memcpy(0x166dcb0, "file2\0", 6)                      = 0x166dcb0
readdir({ 3 })                                       = nil
closedir({ 3 })                                         

通过查看上面的输出,你或许可以了解正在发生的事情。opendir 库函数打开一个名为 testdir 的目录,然后调用 readdir 函数,该函数读取目录的内容。最后,有一个对 closedir 函数的调用,该函数将关闭先前打开的目录。现在请先忽略其他 strlenmemcpy 功能。

你可以看到正在调用哪些库函数,但是本文将重点介绍由系统库函数调用的系统调用。

与上述类似,要了解调用了哪些系统调用,只需将 strace 放在 ls testdir 命令之前,如下所示。 再次,一堆乱码丢到了你的屏幕上,你可以按照以下步骤进行操作:

[root@sandbox tmp]# strace ls testdir/
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
brk(NULL)                               = 0x1f12000
<<< truncated strace output >>>
write(1, "file1  file2\n", 13file1  file2
)          = 13
close(1)                                = 0
munmap(0x7fd002c8d000, 4096)            = 0
close(2)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++
[root@sandbox tmp]#

运行 strace 命令后屏幕上的输出就是运行 ls 命令的系统调用。每个系统调用都为操作系统提供了特定的用途,可以将它们大致分为以下几个部分:

  • 进程管理系统调用
  • 文件管理系统调用
  • 目录和文件系统管理系统调用
  • 其他系统调用

分析显示到屏幕上的信息的一种更简单的方法是使用 strace 方便的 -o 标志将输出记录到文件中。在 -o 标志后添加一个合适的文件名,然后再次运行命令:

[root@sandbox tmp]# strace -o trace.log ls testdir/
file1  file2
[root@sandbox tmp]#

这次,没有任何输出干扰屏幕显示,ls 命令如预期般工作,显示了文件名并将所有输出记录到文件 trace.log 中。仅仅是一个简单的 ls 命令,该文件就有近 100 行内容:

[root@sandbox tmp]# ls -l trace.log
-rw-r--r--. 1 root root 7809 Oct 12 13:52 trace.log
[root@sandbox tmp]#
[root@sandbox tmp]# wc -l trace.log
114 trace.log
[root@sandbox tmp]#

让我们看一下这个示例的 trace.log 文件的第一行:

execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
  • 该行的第一个单词 execve 是正在执行的系统调用的名称。
  • 括号内的文本是提供给该系统调用的参数。
  • 符号 = 后的数字(在这种情况下为 0)是 execve 系统调用的返回值。

现在的输出似乎还不太吓人,对吧。你可以应用相同的逻辑来理解其他行。

现在,将关注点集中在你调用的单个命令上,即 ls testdir。你知道命令 ls 使用的目录名称,那么为什么不在 trace.log 文件中使用 grep 查找 testdir 并查看得到的结果呢?让我们详细查看一下结果的每一行:

[root@sandbox tmp]# grep testdir trace.log
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
[root@sandbox tmp]#

回顾一下上面对 execve 的分析,你能说一下这个系统调用的作用吗?

execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0

你无需记住所有系统调用或它们所做的事情,因为你可以在需要时参考文档。手册页可以解救你!在运行 man 命令之前,请确保已安装以下软件包:

[root@sandbox tmp]# rpm -qa | grep -i man-pages
man-pages-3.53-5.el7.noarch
[root@sandbox tmp]#

请记住,你需要在 man 命令和系统调用名称之间添加 2。如果使用 man man 阅读 man 命令的手册页,你会看到第 2 节是为系统调用保留的。同样,如果你需要有关库函数的信息,则需要在 man 和库函数名称之间添加一个 3

以下是手册的章节编号及其包含的页面类型:

  • 1:可执行的程序或 shell 命令
  • 2:系统调用(由内核提供的函数)
  • 3:库调用(在程序的库内的函数)
  • 4:特殊文件(通常出现在 /dev

使用系统调用名称运行以下 man 命令以查看该系统调用的文档:

man 2 execve

按照 execve 手册页,这将执行在参数中传递的程序(在本例中为 ls)。可以为 ls 提供其他参数,例如本例中的 testdir。因此,此系统调用仅以 testdir 作为参数运行 ls

execve - execute program

DESCRIPTION
       execve()  executes  the  program  pointed to by filename

下一个系统调用,名为 stat,它使用 testdir 参数:

stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0

使用 man 2 stat 访问该文档。stat 是获取文件状态的系统调用,请记住,Linux 中的一切都是文件,包括目录。

接下来,openat 系统调用将打开 testdir。密切注意返回的 3。这是一个文件描述符,将在以后的系统调用中使用:

openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3

到现在为止一切都挺好。现在,打开 trace.log 文件,并转到 openat 系统调用之后的行。你会看到 getdents 系统调用被调用,该调用完成了执行 ls testdir 命令所需的大部分操作。现在,从 trace.log 文件中用 grep 获取 getdents

[root@sandbox tmp]# grep getdents trace.log
getdents(3, /* 4 entries */, 32768)     = 112
getdents(3, /* 0 entries */, 32768)     = 0
[root@sandbox tmp]#

getdents 的手册页将其描述为 “获取目录项”,这就是你要执行的操作。注意,getdents 的参数是 3,这是来自上面 openat 系统调用的文件描述符。

现在有了目录列表,你需要一种在终端中显示它的方法。因此,在日志中用 grep 搜索另一个用于写入终端的系统调用 write

[root@sandbox tmp]# grep write trace.log
write(1, "file1  file2\n", 13)          = 13
[root@sandbox tmp]#

在这些参数中,你可以看到将要显示的文件名:file1file2。关于第一个参数(1),请记住在 Linux 中,当运行任何进程时,默认情况下会为其打开三个文件描述符。以下是默认的文件描述符:

  • 0:标准输入
  • 1:标准输出
  • 2:标准错误

因此,write 系统调用将在标准显示(就是这个终端,由 1 所标识的)上显示 file1file2

现在你知道哪个系统调用完成了 ls testdir/ 命令的大部分工作。但是在 trace.log 文件中其它的 100 多个系统调用呢?操作系统必须做很多内务处理才能运行一个进程,因此,你在该日志文件中看到的很多内容都是进程初始化和清理。阅读整个 trace.log 文件,并尝试了解 ls 命令是怎么工作起来的。

既然你知道了如何分析给定命令的系统调用,那么就可以将该知识用于其他命令来了解正在执行哪些系统调用。strace 提供了许多有用的命令行标志,使你更容易使用,下面将对其中一些进行描述。

默认情况下,strace 并不包含所有系统调用信息。但是,它有一个方便的 -v 冗余选项,可以在每个系统调用中提供附加信息:

strace -v ls testdir

在运行 strace 命令时始终使用 -f 选项是一种好的作法。它允许 strace 对当前正在跟踪的进程创建的任何子进程进行跟踪:

strace -f ls testdir

假设你只需要系统调用的名称、运行的次数以及每个系统调用花费的时间百分比。你可以使用 -c 标志来获取这些统计信息:

strace -c ls testdir/

假设你想专注于特定的系统调用,例如专注于 open 系统调用,而忽略其余部分。你可以使用-e 标志跟上系统调用的名称:

[root@sandbox tmp]# strace -e open ls testdir
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libcap.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libacl.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpcre.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libattr.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
file1  file2
+++ exited with 0 +++
[root@sandbox tmp]#

如果你想关注多个系统调用怎么办?不用担心,你同样可以使用 -e 命令行标志,并用逗号分隔开两个系统调用的名称。例如,要查看 writegetdents 系统调用:

[root@sandbox tmp]# strace -e write,getdents ls testdir
getdents(3, /* 4 entries */, 32768)     = 112
getdents(3, /* 0 entries */, 32768)     = 0
write(1, "file1  file2\n", 13file1  file2
)          = 13
+++ exited with 0 +++
[root@sandbox tmp]#

到目前为止,这些示例是明确地运行的命令进行了跟踪。但是,要跟踪已经运行并正在执行的命令又怎么办呢?例如,如果要跟踪用来长时间运行进程的守护程序,该怎么办?为此,strace 提供了一个特殊的 -p 标志,你可以向其提供进程 ID。

我们的示例不在守护程序上运行 strace,而是以 cat 命令为例,如果你将文件名作为参数,通常 cat 会显示文件的内容。如果没有给出参数,cat 命令会在终端上等待用户输入文本。输入文本后,它将重复给定的文本,直到用户按下 Ctrl + C 退出为止。

从一个终端运行 cat 命令;它会向你显示一个提示,并等待在那里(记住 cat 仍在运行且尚未退出):

[root@sandbox tmp]# cat

在另一个终端上,使用 ps 命令找到进程标识符(PID):

[root@sandbox ~]# ps -ef | grep cat
root      22443  20164  0 14:19 pts/0    00:00:00 cat
root      22482  20300  0 14:20 pts/1    00:00:00 grep --color=auto cat
[root@sandbox ~]#

现在,使用 -p 标志和 PID(在上面使用 ps 找到)对运行中的进程运行 strace。运行 strace 之后,其输出说明了所接驳的进程的内容及其 PID。现在,strace 正在跟踪 cat 命令进行的系统调用。看到的第一个系统调用是 read,它正在等待文件描述符 0(标准输入,这是运行 cat 命令的终端)的输入:

[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0,

现在,返回到你运行 cat 命令的终端,并输入一些文本。我出于演示目的输入了 x0x0。注意 cat 是如何简单地重复我输入的内容的。因此,x0x0 出现了两次。我输入了第一个,第二个是 cat 命令重复的输出:

[root@sandbox tmp]# cat
x0x0
x0x0

返回到将 strace 接驳到 cat 进程的终端。现在你会看到两个额外的系统调用:较早的 read 系统调用,现在在终端中读取 x0x0,另一个为 write,它将 x0x0 写回到终端,然后是再一个新的 read,正在等待从终端读取。请注意,标准输入(0)和标准输出(1)都在同一终端中:

[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0, "x0x0\n", 65536)                = 5
write(1, "x0x0\n", 5)                   = 5
read(0,

想象一下,对守护进程运行 strace 以查看其在后台执行的所有操作时这有多大帮助。按下 Ctrl + C 杀死 cat 命令;由于该进程不再运行,因此这也会终止你的 strace 会话。

如果要查看所有的系统调用的时间戳,只需将 -t 选项与 strace 一起使用:

[root@sandbox ~]#strace -t ls testdir/

14:24:47 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
14:24:47 brk(NULL)                      = 0x1f07000
14:24:47 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2530bc8000
14:24:47 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
14:24:47 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3

如果你想知道两次系统调用之间所花费的时间怎么办?strace 有一个方便的 -r 命令,该命令显示执行每个系统调用所花费的时间。非常有用,不是吗?

[root@sandbox ~]#strace -r ls testdir/

0.000000 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
0.000368 brk(NULL)                 = 0x1966000
0.000073 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb6b1155000
0.000047 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
0.000119 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3

总结

strace 实用程序非常有助于理解 Linux 上的系统调用。要了解它的其它命令行标志,请参考手册页和在线文档。


via: https://opensource.com/article/19/10/strace

作者:Gaurav Kamathe 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出