分类 技术 下的文章

Linus Torvalds 发布了 Linux 内核 4.12。你可以从这里直接下载相关的 deb 包来安装。或者,继续阅读本文,按下面的步骤安装新内核。

警告:Linux 内核是系统的关键元素。在某个硬件设备不正常工作时,可以尝试执行升级,新的内核可能会解决此问题。 但同样的,非必须地更新一个新的内核也可能导致不必要的回滚,例如,无网络连接, 没有声音,甚至是无法正常启动系统,所以安装一个新的内核,请正确认识风险。

最简单的安装任意内核方法 - 在Linux Mint 使用 UKUU

TerminalShekin@mylinuxmintpc~$sudo apt-add-repository -y ppa:teejee2008/ppa 
sudo apt-get update
sudo apt-get install ukuu

提醒:所有的 Nvidia/AMD 电脑用户, 在安装内核之前,建议切换到 free 版本的驱动。

如果决定删除内核 4.12,

  1. 首先,重启计算机,选择 GRUB 菜单中的旧内核启动。系统引导完成之后,通过以下命令删除新的内核:
  2. 然后,使用 UKUU 程序,或者命令:sudo apt purge linux-image-4.12-*
  3. 最后,更新 GRUB 或者 BURGsudo update-grub

在启动 GRUB 的时候,选择以前的 Linux 版本即可回到以前版本的内核。

Good Luck!!!


via: https://mintguide.org/system/798-install-linux-kernel-4-12-stable-on-linux-mint.html

作者:Shekin 译者:VicYu 校对:wxy

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

在这个三篇系列文章的第一篇文章中,我们将学习 图数据库 graph database 的基础知识,它支持了这地球上最大的一些数据池。

对于海量的各种非结构化信息来说,图数据库已经成为帮助收集、管理和搜索大量数据的技术。在这三篇系列文章中,我们将使用开源图数据库软件 Neo4j 来研究图数据库。

在本文中,我将向你展示图数据库的基础知识,帮助你快速了解概念模型。在第二篇中,我将向你展示如何启动 Neo4j 数据库,并使用内置的浏览器工具填充一些数据。而且,在本系列的最后一篇文章中,我们将探讨一些在开发工作中使用的 Neo4j 编程库。

掌握图数据库的概念模型是有用的,所以我们从那里开始。图数据库中只存储两种数据: 节点 node edge

  • 节点是实体:诸如人物、发票、电影、书籍或其他具体事物。这些有些等同于关系数据库中的记录或行。
  • 边名关系:连接节点的概念、事件或事物。在关系数据库中,这些关系通常存储在具有链接字段的数据库行中。在图数据库中,它们本身就是有用的,是可以以其自己的权限搜索的对象。

节点和边都可以拥有可搜索的属性。例如,如果你的节点代表人,他们可能拥有名字、性别、出生日期、身高等属性。而边的属性可能描述了两个人之间的关系何时建立,见面的情况或关系的性质。

这是一个帮助你可视化的图表:

 title=

在这张图中,你知道 Jane Doe 有一个新的丈夫 John;一个女儿(来自她以前的夫妻关系)Mary Smith 和朋友 Robert 和 Rhonda Roe。Roes 有一个儿子 Ryan,他正在与 Mary Smith 约会。

看看它怎么工作?每个节点代表一个独立于其他节点的人。你需要找到关于那个人的一切都可以存储在节点的属性中。边描述了人们之间的关系,这与你在程序中需要的一样多。

关系是单向的,且不能是无向的,但这没有问题。由于数据库可以以相同的速度遍历两个方向,并且方向可以忽略,你只需要定义一次此关系。如果你的程序需要定向关系,则可以自由使用它们,但如果双向性是暗含的,则不需要。

另外需要注意的是,图数据库本质上是无 schema 的。这与关系数据库不同,关系数据库每行都有一组列表,并且添加新的字段会给开发和升级带来很多工作。

每个节点都可以拥有一个 标签 label ;对于大多数程序你需要“输入”这个标签,是对典型的关系数据库中的表名的模拟。标签可以让你区分不同的节点类型。如果你需要添加新的标签或属性,修改程序来用它就行!

使用图数据库,你可以直接开始使用新的属性和标签,节点将在创建或编辑时获取它们。不需要转换东西;只需在你的代码中使用它们即可。在这里的例子中,你可以看到,我们知道 Jane 和 Mary 最喜欢的颜色和 Mary 的出生日期,但是别人没有(这些属性)。这个系统不需要知道它;用户可以在正常使用程序的过程中访问节点时为其添加信息(属性)。

作为一名开发人员,这是一个有用的特性。你可以将新的标签或属性添加到由节点处理的表单中并开始使用它,而不必进行数据库 schema 的修改。对于没有该属性的节点,将不显示任何内容。你可以使用任何一种类型的数据库来为表单进行编码,但是你可以放下在关系型数据库中要进行的许多后端工作了。

让我们添加一些新的信息:

 title=

这是一个新的节点类型,它代表一个位置,以及一些相关关系。现在我们看到 John Doe 出生在加利福尼亚州的 Petaluma,而他的妻子 Jane 则出生在德克萨斯州的 Grand Prairie。 他们现在住在得克萨斯州的赛普拉斯,因为 Jane 在附近的休斯顿工作。Ryan Roe 缺乏城市关系对数据库来说没有什么大不了的事情,我们不知道那些信息而已。当用户输入更多数据时,数据库可以轻松获取新数据并添加新数据,并根据需要创建新的节点和关系。

了解节点和边应该足以让你开始使用图形数据库。如果你像我一样,已经在考虑如何在一个图中重组你的程序。在本系列的下一篇文章中,我将向你展示如何安装 Neo4j、插入数据,并进行一些基本的搜索。


via: https://opensource.com/article/17/7/fundamentals-graph-databases-neo4j

作者:Ruth Holloway 译者:geekpi 校对:wxy

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

在之前的文章中,我提到过 ss,它是 iproute2 包附带的另一个工具,允许你查询 socket 的有关统计信息。可以完成 netstat 同样的任务,但是,ss 稍微快一点而且命令更简短。

直接输入 ss,默认会显示与 netstat 同样的内容,并且输入类似的参数可以获取你想要的类似输出。例如:

$ ss -t
State       Recv-Q Send-Q       Local Address:Port                        Peer Address:Port
ESTAB       0      0                127.0.0.1:postgresql                     127.0.0.1:48154
ESTAB       0      0            192.168.0.136:35296                      192.168.0.120:8009
ESTAB       0      0            192.168.0.136:47574                     173.194.74.189:https
[…]

ss -t 只显示 TCP 连接。ss -u 用于显示 UDP 连接,-l 参数只会显示监听的端口,而且可以进一步过滤到任何想要的信息。

我并没有测试所有可用参数,但是你甚至可以使用 -K 强制关闭 socket。

ss 真正耀眼的地方是其内置的过滤能力。让我们列出所有端口为 22(ssh)的连接:

$ ss state all sport = :ssh
Netid State      Recv-Q Send-Q     Local Address:Port                      Peer Address:Port
tcp   LISTEN     0      128                    *:ssh                                  *:*
tcp   ESTAB      0      0          192.168.0.136:ssh                      192.168.0.102:46540
tcp   LISTEN     0      128                   :::ssh                                 :::*

如果只想看已建立的 socket(排除了 listeningclosed ):

$ ss state connected sport = :ssh
Netid State      Recv-Q Send-Q     Local Address:Port                      Peer Address:Port
tcp   ESTAB      0      0          192.168.0.136:ssh                      192.168.0.102:46540

类似的,可以列出指定的 host 或者 ip 段。例如,列出到达 74.125.0.0/16 子网的连接,这个子网属于 Google:

$ ss state all dst 74.125.0.0/16
Netid State      Recv-Q Send-Q     Local Address:Port                      Peer Address:Port
tcp   ESTAB      0      0          192.168.0.136:33616                   74.125.142.189:https
tcp   ESTAB      0      0          192.168.0.136:42034                    74.125.70.189:https
tcp   ESTAB      0      0          192.168.0.136:57408                   74.125.202.189:https

ss与 iptables 的语法非常相同,如果已经熟悉了其语法,ss 非常容易上手。也可以安装 iproute2-doc 包, 通过 /usr/share/doc/iproute2-doc/ss.html 获得完整文档。

还不快试试! 你就可以知道它有多棒。无论如何,让我输入的字符越少我越高兴。


via: https://insights.ubuntu.com/2017/07/25/ss-another-way-to-get-socket-statistics/

作者:Mathieu Trudel-Lapierre 译者:VicYu 校对:wxy

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

Linux 的帮助手册其实拥有很多有用的信息,而且比你想象中更容易使用

我们通常通过 google 来查询 Linux 中的命令说明,但是其实还有一个更好的办法:那就是通过 Linux 自带的 man 帮助页来查询命令详尽完整的使用说明。

man 页面的历史本身比 Linux 还长,可以追溯到 Unix 早期那个年代。 通过这个 Wikipedia 可以知道,Dennis Ritchie 和 Ken Thompson 在 1971 年写了第一个 man 帮助页,那个年代的计算器使用的还是像烤箱一样的计算机,个人电脑还未出世。man 帮助页也有它自己的一套设计精炼的语法,和 Unix 与 Linux 一样,man 帮助页也不是一成不变的,它就像 Linux 内核一样不停地发展更新。

Man 帮助页通过数字标识符来分成不同类型的内容:

  1. 一般用户命令
  2. 系统调用命令
  3. 库函数
  4. 特殊的文件和驱动程序
  5. 文件格式
  6. 游戏和屏保
  7. 杂项
  8. 系统管理命令和守护进程

尽管如此,用户一般也不需要知道他们想查询的命令是属于哪一个类型的。

这些文件格式化的方式在当今许多用户看来有点古怪。因为最开始他们是用 trooff 的方式,通过 PostScript 打印机来打印,所以包含了头部和布局方面的格式化信息。在 Linux 中,取而代之使用了一种叫做 groff) 的方法。

在我的 Fedora 系统中,man 帮助页相关的文件存储在 /usr/share/man 下的子目录中(比如 man1 存储第一部分的命令),还有进一步的子目录用于存储 man 帮助页的翻译。

如果你在 Shell 中查找 man 命令的 man 帮助页,你时间看到将是 gzip 工具压缩的 man.1.gz 文件。想要查询 man 帮助页,需要输入类似如下命令:

man man

这个例子会显示 man 命令的 man 帮助页,这将先解压 man 帮助页文件,然后解释格式化指令并用 less 显示结果,所以导航操作和在 less 中一样。

所有的 man 帮助页都应该显示这些子段落:NameSynopsisDescriptionExamplesSeeAlso。有些还会添加一些额外的子段落,比如 OptionsExitStatusEnvironmentBugsFilesAuthorReportingBugsHistoryCopyright

详细说明一个 man 帮助页

为了更详细地介绍一个典型的 man 帮助页,就用 ls 命令的帮助页来分析吧,在 Name 分段下,我们可以看到如下内容:

ls - list directory contents

它会简要地告诉我 ls 这条命令的作用.

Synopsis 分段下,我们可以看到如下的内容:

ls [OPTION]... [FILE]…

任何在中括号中的元素都是可选的。你可以只输入 ls 命令,后面不接任何参数。参数后面的省略号表示你可以添加任意多个彼此兼容的参数,以及许多文件名。对于 [FILE] 参数,你可以指定具体的目录名,或者可以使用通配符 *,比如这个例子,它会显示 Documents 文件夹下的 .txt 文件:

ls Documents/*.txt

Description 分段下, 我们可以看到关于这条命令更加详细的信息,还有关于这条命令各个参数作用的详细介绍的列表,比如说 ls 命令第一个选项 -a 参数,它的作用是显示包括隐藏文件/目录在内的所有文件:

-a, --all 

如果我们想用这些参数,要么用它们的别名,比如 -a,要么用它们的全名,比如 --all(两条中划线)。然而并不是所有参数都有全名和别名(比如 --author 只有一种),而且两者的名字并不总是相互关联的(-F--classify)。当你想用多个参数时,要么以空格隔开,要么共用一个连字符 -,在连字符后连续输入你需要的参数(不要添加空格)。比如下面两个等价的例子:

ls -a -d -l
ls -adl

但是 tar 这个命令有些例外,由于一些历史遗留原因,当参数使用别名时可以不用添加连字符 -,因此以下两种命令都是合法的:

tar -cvf filearchive.tar thisdirectory/

tar cvf filearchive.tar thisdirectory/

lsDescription 分段后是 AuthorReporting BugsCopyrightSee Also 等分段。

See Also 分段会提供一些相关的 man 帮助页,没事的话可以看看。毕竟除了命令外还有许多其他类型的 man 帮助页。

有一些命令不是系统命令,而是 Bash 特有的,比如 aliascd。这些 Bash 特有的命令可以在 BASH\_BUILTINS man 帮助页中查看,和上面的比起来它们的描述更加精炼,不过内容都是类似的。

其实通过 man 帮助页让你可以获得大量有用的信息,特别是当你想用一个已经很久没用过的命令,需要复习下这条命令的作用时。这个时候 man 帮助页饱受非议的简洁性反而对你来说是更好的。


作者简介:

Greg Pittman - Greg 是住在肯塔基州路易斯维尔的一位退休神经学家,但是却对计算机和编程保持着长久的兴趣,从二十世纪六十年代就开始捣腾 Fortran IV 了。随着 Linux 和开源软件的到来,更加激起了他去学习的兴趣并投身于这项事业中,并成为 Scribus 组织的一员。


via: https://opensource.com/article/17/7/using-man-pages

作者:Greg Pittman 译者:吴霄/toyijiu 校对:wxy

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

到目前为止,你已经偶尔听到了关于 dwarves、调试信息、一种无需解析就可以理解源码方式。今天我们会详细介绍源码级的调试信息,作为本指南后面部分使用它的准备。

系列文章索引

随着后面文章的发布,这些链接会逐渐生效。

  1. 准备环境
  2. 断点
  3. 寄存器和内存
  4. Elves 和 dwarves
  5. 源码和信号
  6. 源码级逐步执行
  7. 源码级断点
  8. 调用栈展开
  9. 读取变量
  10. 下一步

ELF 和 DWARF 简介

ELF 和 DWARF 可能是两个你没有听说过,但可能大部分时间都在使用的组件。ELF(Executable and Linkable Format,可执行和可链接格式)是 Linux 系统中使用最广泛的目标文件格式;它指定了一种存储二进制文件的所有不同部分的方式,例如代码、静态数据、调试信息以及字符串。它还告诉加载器如何加载二进制文件并准备执行,其中包括说明二进制文件不同部分在内存中应该放置的地点,哪些位需要根据其它组件的位置固定(重分配)以及其它。在这些博文中我不会用太多篇幅介绍 ELF,但是如果你感兴趣的话,你可以查看这个很好的信息图该标准

DWARF是通常和 ELF 一起使用的调试信息格式。它不一定要绑定到 ELF,但它们两者是一起发展的,一起工作得很好。这种格式允许编译器告诉调试器最初的源代码如何和被执行的二进制文件相关联。这些信息分散到不同的 ELF 部分,每个部分都衔接有一份它自己的信息。下面不同部分的定义,信息取自这个稍有过时但非常重要的 DWARF 调试格式简介

  • .debug_abbrev .debug_info 部分使用的缩略语
  • .debug_aranges 内存地址和编译的映射
  • .debug_frame 调用帧信息
  • .debug_info 包括 DWARF 信息条目 DWARF Information Entries (DIEs)的核心 DWARF 数据
  • .debug_line 行号程序
  • .debug_loc 位置描述
  • .debug_macinfo 宏描述
  • .debug_pubnames 全局对象和函数查找表
  • .debug_pubtypes 全局类型查找表
  • .debug_ranges DIEs 的引用地址范围
  • .debug_str .debug_info 使用的字符串列表
  • .debug_types 类型描述

我们最关心的是 .debug_line.debug_info 部分,让我们来看一个简单程序的 DWARF 信息。

int main() {
    long a = 3;
    long b = 2;
    long c = a + b;
    a = 4;
}

DWARF 行表

如果你用 -g 选项编译这个程序,然后将结果传递给 dwarfdump 执行,在行号部分你应该可以看到类似这样的东西:

.debug_line: line number info for a single cu
Source lines (from CU-DIE at .debug_info offset 0x0000000b):

            NS new statement, BB new basic block, ET end of text sequence
            PE prologue end, EB epilogue begin
            IS=val ISA number, DI=val discriminator value
<pc>        [lno,col] NS BB ET PE EB IS= DI= uri: "filepath"
0x00400670  [   1, 0] NS uri: "/home/simon/play/MiniDbg/examples/variable.cpp"
0x00400676  [   2,10] NS PE
0x0040067e  [   3,10] NS
0x00400686  [   4,14] NS
0x0040068a  [   4,16]
0x0040068e  [   4,10]
0x00400692  [   5, 7] NS
0x0040069a  [   6, 1] NS
0x0040069c  [   6, 1] NS ET

前面几行是一些如何理解 dump 的信息 - 主要的行号数据从以 0x00400670 开头的行开始。实际上这是一个代码内存地址到文件中行列号的映射。NS 表示地址标记一个新语句的开始,这通常用于设置断点或逐步执行。PE 表示函数序言(LCTT 译注:在汇编语言中,function prologue 是程序开始的几行代码,用于准备函数中用到的栈和寄存器)的结束,这对于设置函数断点非常有帮助。ET 表示转换单元的结束。信息实际上并不像这样编码;真正的编码是一种非常节省空间的排序程序,可以通过执行它来建立这些行信息。

那么,假设我们想在 variable.cpp 的第 4 行设置断点,我们该怎么做呢?我们查找和该文件对应的条目,然后查找对应的行条目,查找对应的地址,在那里设置一个断点。在我们的例子中,条目是:

0x00400686  [   4,14] NS

假设我们想在地址 0x00400686 处设置断点。如果你想尝试的话你可以在已经编写好的调试器上手动实现。

反过来也是如此。如果我们已经有了一个内存地址 - 例如说,一个程序计数器值 - 想找到它在源码中的位置,我们只需要从行表信息中查找最接近的映射地址并从中抓取行号。

DWARF 调试信息

.debug_info 部分是 DWARF 的核心。它给我们关于我们程序中存在的类型、函数、变量、希望和梦想的信息。这部分的基本单元是 DWARF 信息条目(DWARF Information Entry),我们亲切地称之为 DIEs。一个 DIE 包括能告诉你正在展现什么样的源码级实体的标签,后面跟着一系列该实体的属性。这是我上面展示的简单事例程序的 .debug_info 部分:

.debug_info

COMPILE_UNIT<header overall offset = 0x00000000>:
< 0><0x0000000b>  DW_TAG_compile_unit
                    DW_AT_producer              clang version 3.9.1 (tags/RELEASE_391/final)
                    DW_AT_language              DW_LANG_C_plus_plus
                    DW_AT_name                  /super/secret/path/MiniDbg/examples/variable.cpp
                    DW_AT_stmt_list             0x00000000
                    DW_AT_comp_dir              /super/secret/path/MiniDbg/build
                    DW_AT_low_pc                0x00400670
                    DW_AT_high_pc               0x0040069c

LOCAL_SYMBOLS:
< 1><0x0000002e>    DW_TAG_subprogram
                      DW_AT_low_pc                0x00400670
                      DW_AT_high_pc               0x0040069c
                      DW_AT_frame_base            DW_OP_reg6
                      DW_AT_name                  main
                      DW_AT_decl_file             0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
                      DW_AT_decl_line             0x00000001
                      DW_AT_type                  <0x00000077>
                      DW_AT_external              yes(1)
< 2><0x0000004c>      DW_TAG_variable
                        DW_AT_location              DW_OP_fbreg -8
                        DW_AT_name                  a
                        DW_AT_decl_file             0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
                        DW_AT_decl_line             0x00000002
                        DW_AT_type                  <0x0000007e>
< 2><0x0000005a>      DW_TAG_variable
                        DW_AT_location              DW_OP_fbreg -16
                        DW_AT_name                  b
                        DW_AT_decl_file             0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
                        DW_AT_decl_line             0x00000003
                        DW_AT_type                  <0x0000007e>
< 2><0x00000068>      DW_TAG_variable
                        DW_AT_location              DW_OP_fbreg -24
                        DW_AT_name                  c
                        DW_AT_decl_file             0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
                        DW_AT_decl_line             0x00000004
                        DW_AT_type                  <0x0000007e>
< 1><0x00000077>    DW_TAG_base_type
                      DW_AT_name                  int
                      DW_AT_encoding              DW_ATE_signed
                      DW_AT_byte_size             0x00000004
< 1><0x0000007e>    DW_TAG_base_type
                      DW_AT_name                  long int
                      DW_AT_encoding              DW_ATE_signed
                      DW_AT_byte_size             0x00000008

第一个 DIE 表示一个编译单元(CU),实际上是一个包括了所有 #includes 和类似语句的源文件。下面是带含义注释的属性:

DW_AT_producer   clang version 3.9.1 (tags/RELEASE_391/final)    <-- 产生该二进制文件的编译器
DW_AT_language   DW_LANG_C_plus_plus                             <-- 原编程语言
DW_AT_name       /super/secret/path/MiniDbg/examples/variable.cpp  <-- 该 CU 表示的文件名称
DW_AT_stmt_list  0x00000000                                      <-- 跟踪该 CU 的行表偏移
DW_AT_comp_dir   /super/secret/path/MiniDbg/build                  <-- 编译目录
DW_AT_low_pc     0x00400670                                      <-- 该 CU 的代码起始
DW_AT_high_pc    0x0040069c                                      <-- 该 CU 的代码结尾

其它的 DIEs 遵循类似的模式,你也很可能推测出不同属性的含义。

现在我们可以根据新学到的 DWARF 知识尝试和解决一些实际问题。

当前我在哪个函数?

假设我们有一个程序计数器值然后想找到当前我们在哪一个函数。一个解决该问题的简单算法:

for each compile unit:
    if the pc is between DW_AT_low_pc and DW_AT_high_pc:
        for each function in the compile unit:
            if the pc is between DW_AT_low_pc and DW_AT_high_pc:
                return function information

这对于很多目的都有效,但如果有成员函数或者内联(inline),就会变得更加复杂。假如有内联,一旦我们找到其范围包括我们的程序计数器(PC)的函数,我们需要递归遍历该 DIE 的所有孩子检查有没有内联函数能更好地匹配。在我的代码中,我不会为该调试器处理内联,但如果你想要的话你可以添加该功能。

如何在一个函数上设置断点?

再次说明,这取决于你是否想要支持成员函数、命名空间以及类似的东西。对于简单的函数你只需要迭代遍历不同编译单元中的函数直到你找到一个合适的名字。如果你的编译器能够填充 .debug_pubnames 部分,你可以更高效地做到这点。

一旦找到了函数,你可以在 DW_AT_low_pc 给定的内存地址设置一个断点。不过那会在函数序言处中断,但更合适的是在用户代码处中断。由于行表信息可以指定序言的结束的内存地址,你只需要在行表中查找 DW_AT_low_pc 的值,然后一直读取直到被标记为序言结束的条目。一些编译器不会输出这些信息,因此另一种方式是在该函数第二行条目指定的地址处设置断点。

假如我们想在我们示例程序中的 main 函数设置断点。我们查找名为 main 的函数,获取到它的 DIE:

< 1><0x0000002e>    DW_TAG_subprogram
                      DW_AT_low_pc                0x00400670
                      DW_AT_high_pc               0x0040069c
                      DW_AT_frame_base            DW_OP_reg6
                      DW_AT_name                  main
                      DW_AT_decl_file             0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
                      DW_AT_decl_line             0x00000001
                      DW_AT_type                  <0x00000077>
                      DW_AT_external              yes(1)

这告诉我们函数从 0x00400670 开始。如果我们在行表中查找这个,我们可以获得条目:

0x00400670  [   1, 0] NS uri: "/super/secret/path/MiniDbg/examples/variable.cpp"

我们希望跳过序言,因此我们再读取一个条目:

0x00400676  [   2,10] NS PE

Clang 在这个条目中包括了序言结束标记,因此我们知道在这里停止,然后在地址 0x00400676 处设一个断点。

我如何读取一个变量的内容?

读取变量可能非常复杂。它们是难以捉摸的东西,可能在整个函数中移动、保存在寄存器中、被放置于内存、被优化掉、隐藏在角落里,等等。幸运的是我们的简单示例是真的很简单。如果我们想读取变量 a 的内容,我们需要看它的 DW_AT_location 属性:

DW_AT_location              DW_OP_fbreg -8

这告诉我们内容被保存在以栈帧基(base of the stack frame)偏移为 -8 的地方。为了找到栈帧基,我们查找所在函数的 DW_AT_frame_base 属性。

DW_AT_frame_base            DW_OP_reg6

System V x86\_64 ABI 我们可以知道 reg6 在 x86 中是帧指针寄存器。现在我们读取帧指针的内容,从中减去 8,就找到了我们的变量。如果我们知道它具体是什么,我们还需要看它的类型:

< 2><0x0000004c>      DW_TAG_variable
                        DW_AT_name                  a
                        DW_AT_type                  <0x0000007e>

如果我们在调试信息中查找该类型,我们得到下面的 DIE:

< 1><0x0000007e>    DW_TAG_base_type
                      DW_AT_name                  long int
                      DW_AT_encoding              DW_ATE_signed
                      DW_AT_byte_size             0x00000008

这告诉我们该类型是 8 字节(64 位)有符号整型,因此我们可以继续并把这些字节解析为 int64_t 并向用户显示。

当然,类型可能比那要复杂得多,因为它们要能够表示类似 C++ 的类型,但是这能给你它们如何工作的基本认识。

再次回到帧基(frame base),Clang 可以通过帧指针寄存器跟踪帧基。最近版本的 GCC 倾向于使用 DW_OP_call_frame_cfa,它包括解析 .eh_frame ELF 部分,那是一个我不会去写的另外一篇完全不同的文章。如果你告诉 GCC 使用 DWARF 2 而不是最近的版本,它会倾向于输出位置列表,这更便于阅读:

DW_AT_frame_base            <loclist at offset 0x00000000 with 4 entries follows>
 low-off : 0x00000000 addr  0x00400696 high-off  0x00000001 addr 0x00400697>DW_OP_breg7+8
 low-off : 0x00000001 addr  0x00400697 high-off  0x00000004 addr 0x0040069a>DW_OP_breg7+16
 low-off : 0x00000004 addr  0x0040069a high-off  0x00000031 addr 0x004006c7>DW_OP_breg6+16
 low-off : 0x00000031 addr  0x004006c7 high-off  0x00000032 addr 0x004006c8>DW_OP_breg7+8

位置列表取决于程序计数器所处的位置给出不同的位置。这个例子告诉我们如果程序计数器是在 DW_AT_low_pc 偏移量为 0x0 的位置,那么帧基就在和寄存器 7 中保存的值偏移量为 8 的位置,如果它是在 0x10x4 之间,那么帧基就在和相同位置偏移量为 16 的位置,以此类推。

休息一会

这里有很多的信息需要你的大脑消化,但好消息是在后面的几篇文章中我们会用一个库替我们完成这些艰难的工作。理解概念仍然很有帮助,尤其是当出现错误或者你想支持一些你使用的 DWARF 库所没有实现的 DWARF 概念时。

如果你想了解更多关于 DWARF 的内容,那么你可以从这里获取其标准。在写这篇博客时,刚刚发布了 DWARF 5,但更普遍支持 DWARF 4。


via: https://blog.tartanllama.xyz/c++/2017/04/05/writing-a-linux-debugger-elf-dwarf/

作者:Simon Brand 译者:ictlyh 校对:wxy

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

Libral 为系统资源和服务提供了一个统一的管理 API ,其可以作为脚本管理任务和构建配置管理系统的坚实基础。

 title=

作为继承了 Unix 的传统的 Linux 操作系统,其并没有一个综合的系统管理 API 接口,相反,管理操作是通过多种特定用途的工具和 API 来实现的,其每一个都有自己约定和特有的风格。这就使得编写一个哪怕是简单的系统管理任务的脚本也很困难、很脆弱。

举个例子来说,改变 “app” 用户的登录 shell 要运行 usermod -s /sbin/nologin app。这个命令通常没有问题,只是当系统上没有 “app” 用户时就不行了。为了解决这个例外错误,具有创新精神的脚本编写者也许要这样写:

grep -q app /etc/passwd \
  && usermod -s /sbin/nologin app \
  || useradd ... -s /sbin/nologin app

这样,当 “app” 用户存在于系统中时,会执行更改登录 shell 的操作;而当此用户不存在时,就会创建此用户。不幸的是,这种编写系统管理任务脚本的方式是不适合的:对于每一种资源来说都会有一套不同的工具,而且每个都有其不同的使用惯例;不一致性和经常出现的不完备的错误报告将会使错误的处理变得困难;再者也会因为工具自身的特性引发的故障而导致执行失败。

实际上,以上所举的例子也是不正确的:grep 并不是用来查找 “app” 用户的,它只能在文件 /etc/passwd 的一些行中简单的查找是否有字符串 “app”,在大多数情况下它或许可以工作,但是也可能会在最关键的时刻出错。

很显然,那些执行简单任务的脚本管理工具,很难成为大型管理系统的基础。认识到这一点,现有的配置管理系统,比如 Puppet、Chef 及 Ansible,围绕基本的操作系统资源的管理竭尽全力的建立其内部 API 就是明智之举。这些资源抽象是内部 API,其与所需的相应工具密切相关。但这不仅导致大量的重复性工作,也为尝试一个新创新的管理工具设置了强大的障碍。

在创建虚拟机或者容器镜像这一领域,这种障碍就变得非常明显:比如在创建镜像的过程中,就要么需要回答关于它们的简单问题,要么需要对其进行简单的更改才行。但是工具全都需要特别处理,那些所遇到的问题和更改需要用脚本逐个处理。因此,镜像构建要么依靠特定的脚本,要么需要使用(和安装)一个相当强大的配置管理系统。

Libral 将为管理工具和任务提供一个可靠的保证,通过对系统资源提供一个公用的管理 API,并使其可以通过命令行工具 ralsh 使用,它允许用户按照相同的方法查询和修改系统资源,并有可预见的错误报告。对以上的举例来说,可以通过命令 ralsh -aq user app 检查 “app” 用户是否存在;通过 ralsh -aq package foo 检查 “foo” 软件包是否已经安装;一般情况下,可以通过命令 ralsh -aq TYPE NAME 检查 ”NAME“ 是否是 ”TYPE“ 类型的资源。类似的,要创建或更改已存在的用户,可以运行:

ralsh user app home=/srv/app shell=/sbin/nologin

以及,要在文件 /etc/hosts 创建和修改条目,可以运行命令:

ralsh hostmyhost.example.com ip=10.0.0.1 \
  host_aliases=myhost,apphost

以这种方式运行,“ralsh” 的使用者事实上完全隔离在那两个命令内部的不同运行工作机制之外:第一个命令需要适当的调用命令 useradd 或者 usermod,而第二个需要在 /etc/hosts 文件中进行编辑。而对于该用户来说,他们似乎都采取同样的模型:“确保资源处于我所需要的状态。”

怎样获取和使用 Libral 呢?

Libral 可以在这个 git 仓库找到并下载。其核心是由 C++ 编写的,构建它的说明可以在该仓库中找到,不过只是在你想要为 Libral 的 C++ 核心做贡献的时候才需要看它。Libral 的网站上包含了一个 预构建的 tarball,可以用在任何使用 “glibc 2.12” 或者更高版本的 Linux 机器上。可以使用该 “tarball” 的内容进一步探究 ralsh ,以及开发新的提供者(provider),它使得 Libral 具备了管理新类型资源的能力。

在下载解压 tarball 后,在目录 ral/bin 下能找到 ralsh 命令。运行不需要任何参数的 ralsh 命令就会列举出来 Libral 的所有资源类型。利用 --help 选项可以打印输出关于 ralsh 的更多说明。

与配置管理系统的关系

知名的配置管理系统,如 Puppet、Chef 及 Ansible,解决了一些 Libral 所解决的同样的问题。将 Libral 与它们的区分开的主要是它们所做工作和 Libral 不同。配置管理系统被构建来处理跨大量节点管理各种事物的多样性和复杂性。而另一方面 Libral 旨在提供一个定义明确的低级别的系统管理 API ,独立于任何特定的工具,可用于各种各样的编程语言。

通过消除大型配置管理系统中包含的应用程序逻辑,Libral 从前面介绍里提及的简单的脚本任务,到作为构建复杂的管理应用的构建块,它在如何使用方面是非常灵活的。专注与这些基础层面也使其保持很小,目前不到 2.5 MB,这对于资源严重受限的环境,如容器和小型设备来说是一个重要考虑因素。

Libral API

在过去的十年里,Libral API 是在实现配置管理系统的经验下指导设计的,虽然它并没有直接绑定到它们其中任何一个应用上,但它考虑到了这些问题,并规避了它们的缺点。

在 API 设计中四个重要的原则:

  • 期望的状态
  • 双向性
  • 轻量级抽象
  • 易于扩展

基于期望状态的管理 API,举个例子来说,用户表示当操作执行后希望系统看起来是什么状态,而不是怎样进入这个状态,这一点什么争议。双向性使得使用(读、写)相同的 API 成为可能,更重要的是,相同的资源可以抽象成读取现有状态和强制修改成这种状态。轻量级抽象行为确保能容易的学习 API 并能快速的使用;过去在管理 API 上的尝试过度加重了学习建模框架的使用者的负担,其中一个重要的因素是他们的接受力缺乏。

最后,它必须易于扩展 Libral 的管理功能,这样用户可以教给 Libral 如何管理新类型的资源。这很重要,因为人们也许要管理的资源可能很多(而且 Libral 需要在适当时间进行管理),再者,因为即使是完全成熟的 Libral 也总是存在达不到用户自定义的管理需求。

目前与 Libral API 进行交互的主要方式是通过 ralsh 命令行工具。它也提供了底层的 C++ API ,不过其仍处在不断的演变当中,主要的还是为简单的脚本任务做准备。该项目也提供了为 CRuby 提供语言绑定,其它语言也在陆续跟进。

未来 Libral 还将提供一个提供远程 API 的守护进程,它可以做为管理系统的基础服务,而不需要在管理节点上安装额外的代理。这一点,加上对 Libral 管理功能的定制能力,可以严格控制系统的哪些方面可以管理,哪些方面要避免干扰。

举个例子来说,一个仅限于管理用户和服务的 Libral 配置会避免干扰到在节点上安装的包。当前任何现有的配置管理系统都不可能控制以这种方式管理的内容;尤其是,需要对受控节点进行任意的 SSH 访问也会将该系统暴露不必要的意外和恶意干扰。

Libral API 的基础是由两个非常简单的操作构成的:“get” 用来检索当前资源的状态,“set” 用来设置当前资源的状态。理想化地实现是这样的,通过以下步骤:

provider.get(names) -> List[resource]
provider.set(List[update]) -> List[change]

“provider” 是要知道怎样管理的一种资源的对象,就像用户、服务、软件包等等,Libral API 提供了一种查找特定资源的 管理器 provider 的方法。

“get” 操作能够接收资源名称列表(如用户名),然后产生一个资源列表,其本质来说是利用散列的方式列出每种资源的属性。这个列表必须包含所提供名称的资源,但是可以包含更多内容,因此一个简单的 “get” 的实现可以忽略名称并列出所有它知道的资源。

“set” 操作被用来设置所要求的状态,并接受一个更新列表。每个更新可以包含 “update.is”,其表示当前状态的资源,“update.should” 表示被资源所期望的状态。调用 “set” 方法将会让更新列表中所提到的资源成为 “update.should” 中指示的状态,并列出对每个资源所做的更改。

ralsh 下,利用 ralsh user root 能够重新获得 “root” 用户的当前状态;默认情况下,这个命令会产生一个用户可读的输出,就像 Puppet 中一样,但是 ralsh 支持 --json 选项,可以生成脚本可以使用的 JSON 输出。用户可读的输出是:

# ralsh user root
user::useradd { 'root':
  ensure  => 'present',
  comment => 'root',
  gid     => '0',
  groups  => ['root'],
  home    => '/root',
  shell   => '/bin/bash',
  uid     => '0',
}

类似的,用户也可以用下面的形式修改:

# ralsh user root comment='The superuser'
user::useradd { 'root':
  ensure  => 'present',
  comment => 'The superuser',
  gid     => '0',
  groups  => ['root'],
  home    => '/root',
  shell   => '/bin/bash',
  uid     => '0',
}
comment(root->The superuser)

ralsh 的输出列出了 “root” 用户的新状态和被改变的 comment 属性,以及修改了什么内容(在这种情形下单指 comment 属性)。下一秒运行相同的命令将产生同样的输出,但是不会提示修改,因为没有需要修改的内容。

编写 管理器 provider

ralsh 编写新的管理器(provider) 是很容易的,也花费不了多少工夫,但是这一步骤是至关重要的。正因为如此,ralsh 提供了大量的调用约定,使得可以根据管理器所能提供的能力而调整其实现复杂性成为可能。管理器可以使用遵循特定调用约定的外部脚本,也可以以 C++ 实现并内置到 Libral 里面。到目前为止,有三种调用约定:

  • simple 调用约定是编写 shell 脚本用为管理器。
  • JSON 调用约定意味着可以利用 Ruby 或者 Python 脚本语言编写管理器。
  • 内部 C++ API[8 可以被用来实现原生的管理器。

强烈建议使用 “simple” 或者 “JSON” 调用约定开始开发管理器。GitHub 上的 simple.prov 文件包含了一个简单的 shell 管理器框架,应该很容易的替换为你自己的管理器。python.prov 文件包含了利用 Python编写的 JSON 管理器框架。

利用高级脚本语言编写的管理器存在一个问题是,对于这些语言,在当前运行 Libral 的系统上需要包含所有的支持库在内运行环境。在某些情况下,这不是一个障碍;举例子来说,基于 “yum” 的包管理的管理器需要 Python 被安装在当前的系统上,因为 “yum” 就是用 Python 开发的。

然而在很多时候,无法预期一种 Bourne shell(Bash)之外的设计语言能够安装到所有的管理系统上。通常,管理器的编写者需要一个更加强大的脚本编译环境是实际需要。然而事与愿违,绑定一个完整的 Ruby 或 Python 作为解释器来运行将会增加 Libral 的大小超出了实际使用环境对资源的限制。另一方面,通常选择 Lua 或者 JavaScript 作为可嵌入的脚本编辑语言是不适应这种环境的,因为大多数的管理器的编写者不熟悉他们,通常情况下需要做大量的工作才能满足系统管理的实际需求。

Libral 绑定了一个 mruby 版本,一个小的、嵌入在 Ruby 的版本,提供给管理器的编写者一个稳定的基础以及功能强大的可实现的程序设计语言。mruby 是 Ruby 语言的一个完整实现,尽管其减少了大量的标准库支持。与 Libral 绑定的 mruby 包含了 Ruby 用于脚本编辑管理任务的大多数的重要标准库,其将基于管理器编写者的需求随着时间的推移得到加强。Libral 的 mruby 绑定了 API 适配器使编写管理器更适合 JSON 约定,比如它包含了简单的工具(如编译修改结构体文件的 Augeas)来解决解析和输出 JSON 的约定。mruby.prov 文件包含了利用 mruby 编写的 JSON 管理器框架实例。

下一步工作

Libral 最关键的是下一步要使其增加广泛的可用性——从 预编译的 tarball 对于开发管理器的起步和深入是一个不错的方法,但是 Libral 也需要打包到主流的发行版上,并在上面可以找到。同样的,Libral 强大的功能取决于它附带的管理器的集合,及需要被扩展覆盖一组核心管理功能。Libral 的网站上包含了一个 todo 列表列出了管理器的最迫切需求。

现在有多种方法能够提高不同用途的 Libral 的可用性:从编写更多程序语言的绑定,举例来说,Python 或者 Go;到使 ralsh 更容易在 shell 脚本中使用,除了现有的可读输出和 JSON 输出之外,可以很轻松的在 shell 脚本中格式化输出。在大规模的管理中使用 Libral 也能够在增加上面讨论过的远程 API 而得到改良,Libral 利用像 SSH 这样的传输工具实现更好的支持批量安装要求为各种架构提供预编译的 tarball,并且脚本基于所发现的目标系统架构选择正确的包。

Libral 和它的 API、它的性能能够不断地进化发展;一个有趣的可能性是为 API 增加提醒能力,这样做可以向系统报告资源在超出它的范围发生的变化。Libral 面临的挑战是保持小型化、轻量级和良好定义的工具,来对抗不断增加的用例和管理性能——我希望每一个读者都能成为这个挑战之旅的一部分。

如果这让你很好奇,我很想听听你的想法,可以用拉取请求的方式,也可以是增强请求方式,亦或者报告你对 ralsh 体验经验。

(题图:Internet Archive Book Images,修改:Opensource.com. CC BY-SA 4.0)


作者简介:

David Lutterkort - 戴维是一个 Puppet 的软件工程师,他曾经参与的项目有 Direct Puppet 和最好的供给工具 Razor。他是 Puppet 最早的编著者之一,也是配置编辑工具 Augeas 的主要作者。


via: https://opensource.com/article/17/5/intro-libral-systems-management-library-linux

作者:David Lutterkort 译者:stevenzdg988 校对:wxy

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