Julia Evans 发布的文章

当编写程序时,我花费了大量时间在编写好的示例上。我从未见过有人写过关于如何写出好的示例,所以我就写了一下如何写出一份好的示例。

基础思路就是从你写的真实代码开始,然后删除不相关的细节,使其成为一个独立的例子,而不是无中生有地想出一些例子。

我将会谈论两种示例:基于真实案例的示例和奇怪的示例

好的示例是真实的

为了说明为什么好的案例应该是真实的,我们就先讨论一个不真实的案例。假设我们在试图解释 Python 的 lambda 函数(这只是我想到的第一个概念)。你可以举一个例子,使用 map 和 lambda 来让一组数字变为原先的两倍。

numbers = [1, 2, 3, 4]
squares = map(lambda x: x * x, numbers)

我觉得这个示例不是真实的,有如下两方面的原因:

  • 将一组数字作平方运算不是在真实的程序中完成的事,除非是欧拉项目或某种东西(更多的可能是针对列表的操作)
  • map 在 Python 中并不常用,即便是做这个我也更愿意写 [x*x for x in numbers]

一个更加真实的 Python lambdas 的示例是使用 sort 函数,就像这样:

children = [{"name": "ashwin", "age": 12}, {"name": "radhika", "age": 3}]
sorted_children = sorted(children, key=lambda x: x['age'])

但是这个示例是被精心设计的(为什么我们需要对这些孩子按照年龄进行排序呢?)。所以我们如何来做一个真实的示例呢?

如何让你的示例真实起来:看你所写实际代码

我认为最简单的来生成一个例子的方法就是,不是凭空出现一个例子(就像我用那个儿童的例子),而只是从真正的代码开始!

举一个例子吧,如果我要用 sort.+key 来编写一串 Python 代码,我会发现很多我按某个标准对列表进行排序的真实例子,例如:

  • tasks.sort(key=lambda task: task['completed_time'])
  • emails = reversed(sorted(emails, key=lambda x:x['receivedAt']))
  • sorted_keysizes = sorted(scores.keys(), key=scores.get)
  • shows = sorted(dates[date], key=lambda x: x['time']['performanceTime'])

在这里很容易看到一个规律——这些基本是按时间排序的!因此,你可以明白如何将按时间排序的某些对象(电子邮件、事件等)的简单实例轻松地放在一起。

现实的例子有助于“布道”你试图解释的概念

当我试图去解释一个想法(就好比 Python Lambdas)的时候,我通常也会试图说服读者,说这是值得学习的想法。Python lambdas 是如此的有用!当我去试图说服某个人 lambdas 是很好用的时候,让他想象一下 lambdas 如何帮助他们完成一项他们将要去做的任务或是以及一项他们以前做过的任务,对说服他会很有帮助。

从真实代码中提炼出示例可能需要很长时间

我给出如何使用 lambdasort 函数的解释例子是十分简单的,它并不需要花费我很长时间来想出来,但是将真实的代码提炼出为一个独立的示例则是会需要花费很长的时间!

举个例子,我想在这篇文章中融入一些奇怪的 CSS 行为的例子来说明创造一个奇怪的案例是十分有趣的。我花费了两个小时来解决我这周遇到的一个实际的问题,确保我理解 CSS 的实际情况,并将其变成一个小示例。

最后,它“仅仅”用了 五行 HTML 和一点点的 CSS 来说明了这个问题,看起来并不想是我花费了好多小时写出来的。但是最初它却是几百行的 JS/CSS/JavaScript,它需要花费很长时间来将所有的代码化为核心的很少的代码。

但我认为花点时间把示例讲得非常简单明了是值得的——如果有成百上千的人在读你的示例,你就节省了他们这么多时间!

就这么多了!

我觉得还有更多关于示例可以去讲的——几种不同类型的有用示例,例如:

  • 可以更多的改变人的思维而不是直接提供使用的惊喜读者的示例代码
  • 易于复制粘贴以用作初始化的示例

也许有一天我还会再写一些呢? :smiley:


via: https://jvns.ca/blog/2021/07/08/writing-great-examples/

作者:Julia Evans 选题:lujun9972 译者:zepoch 校对:turbokernel

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

昨天我和一些人在闲聊的时候,他们说他们并不真正了解栈是如何工作的,而且也不知道如何去查看栈空间。

这是一个快速教程,介绍如何使用 GDB 查看 C 程序的栈空间。我认为这对于 Rust 程序来说也是相似的。但我这里仍然使用 C 语言,因为我发现用它更简单,而且用 C 语言也更容易写出错误的程序。

我们的测试程序

这里是一个简单的 C 程序,声明了一些变量,从标准输入读取两个字符串。一个字符串在堆上,另一个字符串在栈上。

#include <stdio.h>
#include <stdlib.h>

int main() {
    char stack_string[10] = "stack";
    int x = 10;
    char *heap_string;

    heap_string = malloc(50);

    printf("Enter a string for the stack: ");
    gets(stack_string);
    printf("Enter a string for the heap: ");
    gets(heap_string);
    printf("Stack string is: %s\n", stack_string);
    printf("Heap string is: %s\n", heap_string);
    printf("x is: %d\n", x);
}

这个程序使用了一个你可能从来不会使用的极为不安全的函数 gets 。但我是故意这样写的。当出现错误的时候,你就知道是为什么了。

第 0 步:编译这个程序

我们使用 gcc -g -O0 test.c -o test 命令来编译这个程序。

-g 选项会在编译程序中将调式信息也编译进去。这将会使我们查看我们的变量更加容易。

-O0 选项告诉 gcc 不要进行优化,我要确保我们的 x 变量不会被优化掉。

第一步:启动 GDB

像这样启动 GDB:

$ gdb ./test

它打印出一些 GPL 信息,然后给出一个提示符。让我们在 main 函数这里设置一个断点:

(gdb) b main

然后我们就可以运行程序:

(gdb) b main
Starting program: /home/bork/work/homepage/test
Breakpoint 1, 0x000055555555516d in main ()

(gdb) run
Starting program: /home/bork/work/homepage/test

Breakpoint 1, main () at test.c:4
4   int main() {

好了,现在程序已经运行起来了。我们就可以开始查看栈空间了。

第二步:查看我们变量的地址

让我们从了解我们的变量开始。它们每个都在内存中有一个地址,我们可以像这样打印出来:

(gdb) p &x
$3 = (int *) 0x7fffffffe27c
(gdb) p &heap_string
$2 = (char **) 0x7fffffffe280
(gdb) p &stack_string
$4 = (char (*)[10]) 0x7fffffffe28e

因此,如果我们查看那些地址的堆栈,那我们应该能够看到所有的这些变量!

概念:栈指针

我们将需要使用栈指针,因此我将尽力对其进行快速解释。

有一个名为 ESP 的 x86 寄存器,称为“ 栈指针 stack pointer ”。 基本上,它是当前函数的栈起始地址。 在 GDB 中,你可以使用 $sp 来访问它。 当你调用新函数或从函数返回时,栈指针的值会更改。

第三步:在 main 函数开始的时候,我们查看一下在栈上的变量

首先,让我们看一下 main 函数开始时的栈。 现在是我们的堆栈指针的值:

(gdb) p $sp
$7 = (void *) 0x7fffffffe270

因此,我们当前函数的栈起始地址是 0x7fffffffe270,酷极了。

现在,让我们使用 GDB 打印出当前函数堆栈开始后的前 40 个字(即 160 个字节)。 某些内存可能不是栈的一部分,因为我不太确定这里的堆栈有多大。 但是至少开始的地方是栈的一部分。

我已粗体显示了 stack_stringheap_stringx 变量的位置,并改变了颜色:

  • x 是红色字体,并且起始地址是 0x7fffffffe27c
  • heap_string 是蓝色字体,起始地址是 0x7fffffffe280
  • stack_string 是紫色字体,起始地址是 0x7fffffffe28e

你可能会在这里注意到的一件奇怪的事情是 x 的值是 0x5555,但是我们将 x 设置为 10! 那是因为直到我们的 main 函数运行之后才真正设置 x ,而我们现在才到了 main 最开始的地方。

第三步:运行到第十行代码后,再次查看一下我们的堆栈

让我们跳过几行,等待变量实际设置为其初始化值。 到第 10 行时,x 应该设置为 10

首先我们需要设置另一个断点:

(gdb) b test.c:10
Breakpoint 2 at 0x5555555551a9: file test.c, line 11.

然后继续执行程序:

(gdb) continue
Continuing.

Breakpoint 2, main () at test.c:11
11      printf("Enter a string for the stack: ");

好的! 让我们再来看看堆栈里的内容! gdb 在这里格式化字节的方式略有不同,实际上我也不太关心这些(LCTT 译注:可以查看 GDB 手册中 x 命令,可以指定 c 来控制输出的格式)。 这里提醒一下你,我们的变量在栈上的位置:

  • x 是红色字体,并且起始地址是 0x7fffffffe27c
  • heap_string 是蓝色字体,起始地址是 0x7fffffffe280
  • stack_string 是紫色字体,起始地址是 0x7fffffffe28e

在继续往下看之前,这里有一些有趣的事情要讨论。

stack_string 在内存中是如何表示的

现在(第 10 行),stack_string 被设置为字符串stack。 让我们看看它在内存中的表示方式。

我们可以像这样打印出字符串中的字节(LCTT 译注:可以通过 c 选项直接显示为字符):

(gdb) x/10x stack_string
0x7fffffffe28e: 0x73    0x74    0x61    0x63    0x6b    0x00    0x00    0x00
0x7fffffffe296: 0x00    0x00

stack 是一个长度为 5 的字符串,相对应 5 个 ASCII 码- 0x730x740x610x630x6b0x73 是字符 s 的 ASCII 码。 0x74t 的 ASCII 码。等等...

同时我们也使用 x/1s 可以让 GDB 以字符串的方式显示:

(gdb) x/1s stack_string
0x7fffffffe28e: "stack"

heap_stringstack_string 有何不同

你已经注意到了 stack_stringheap_string 在栈上的表示非常不同:

  • stack_string 是一段字符串内容(stack
  • heap_string 是一个指针,指向内存中的某个位置

这里是 heap_string 变量在内存中的内容:

0xa0  0x92  0x55  0x55  0x55  0x55  0x00  0x00

这些字节实际上应该是从右向左读:因为 x86 是小端模式,因此,heap_string 中所存放的内存地址 0x5555555592a0

另一种方式查看 heap_string 中存放的内存地址就是使用 p 命令直接打印 :

(gdb) p heap_string
$6 = 0x5555555592a0 ""

整数 x 的字节表示

x 是一个 32 位的整数,可由 0x0a 0x00 0x00 0x00 来表示。

我们还是需要反向来读取这些字节(和我们读取 heap_string 需要反过来读是一样的),因此这个数表示的是 0x000000000a 或者是 0x0a,它是一个数字 10;

这就让我把把 x 设置成了 10

第四步:从标准输入读取

好了,现在我们已经初始化我们的变量,我们来看一下当这段程序运行的时候,栈空间会如何变化:

printf("Enter a string for the stack: ");
gets(stack_string);
printf("Enter a string for the heap: ");
gets(heap_string);

我们需要设置另外一个断点:

(gdb) b test.c:16
Breakpoint 3 at 0x555555555205: file test.c, line 16.

然后继续执行程序:

(gdb) continue
Continuing.

我们输入两个字符串,为栈上存储的变量输入 123456789012 并且为在堆上存储的变量输入 bananas;

让我们先来看一下 stack_string(这里有一个缓存区溢出)

(gdb) x/1s stack_string
0x7fffffffe28e: "123456789012"

这看起来相当正常,对吗?我们输入了 12345679012,然后现在它也被设置成了 12345679012(LCTT 译注:实测 gcc 8.3 环境下,会直接段错误)。

但是现在有一些很奇怪的事。这是我们程序的栈空间的内容。有一些紫色高亮的内容。

令人奇怪的是 stack_string 只支持 10 个字节。但是现在当我们输入了 13 个字符以后,发生了什么?

这是一个典型的缓冲区溢出,stack_string 将自己的数据写在了程序中的其他地方。在我们的案例中,这还没有造成问题,但它会使你的程序崩溃,或者更糟糕的是,使你面临非常糟糕的安全问题。

例如,假设 stack_string 在内存里的位置刚好在 heap_string 之前。那我们就可能覆盖 heap_string 所指向的地址。我并不确定 stack_string 之后的内存里有一些什么。但我们也许可以用它来做一些诡异的事情。

确实检测到了有缓存区溢出

当我故意写很多字符的时候:

 ./test
Enter a string for the stack: 01234567891324143
Enter a string for the heap: adsf
Stack string is: 01234567891324143
Heap string is: adsf
x is: 10
*** stack smashing detected ***: terminated
fish: Job 1, './test' terminated by signal SIGABRT (Abort)

这里我猜是 stack_string 已经到达了这个函数栈的底部,因此额外的字符将会被写在另一块内存中。

当你故意去使用这个安全漏洞时,它被称为“堆栈粉碎”,而且不知何故有东西在检测这种情况的发生。

我也觉得这很有趣,虽然程序被杀死了,但是当缓冲区溢出发生时它不会立即被杀死——在缓冲区溢出之后再运行几行代码,程序才会被杀死。 好奇怪!

这些就是关于缓存区溢出的所有内容。

现在我们来看一下 heap_string

我们仍然将 bananas 输入到 heap_string 变量中。让我们来看一下内存中的样子。

这是在我们读取了字符串以后,heap_string 在栈空间上的样子:

需要注意的是,这里的值是一个地址。并且这个地址并没有改变,但是我们来看一下指向的内存上的内容。

(gdb) x/10x 0x5555555592a0
0x5555555592a0: 0x62    0x61    0x6e    0x61    0x6e    0x61    0x73    0x00
0x5555555592a8: 0x00    0x00

看到了吗,这就是字符串 bananas 的字节表示。这些字节并不在栈空间上。他们存在于内存中的堆上。

堆和栈到底在哪里?

我们已经讨论过栈和堆是不同的内存区域,但是你怎么知道它们在内存中的位置呢?

每个进程都有一个名为 /proc/$PID/maps 的文件,它显示了每个进程的内存映射。 在这里你可以看到其中的栈和堆。

$ cat /proc/24963/maps
... lots of stuff omitted ...
555555559000-55555557a000 rw-p 00000000 00:00 0                          [heap]
... lots of stuff omitted ...
7ffffffde000-7ffffffff000 rw-p 00000000 00:00 0                          [stack]

需要注意的一件事是,这里堆地址以 0x5555 开头,栈地址以 0x7fffff 开头。 所以很容易区分栈上的地址和堆上的地址之间的区别。

像这样使用 gdb 真的很有帮助

这有点像旋风之旅,虽然我没有解释所有内容,但希望看到数据在内存中的实际情况可以使你更清楚地了解堆栈的实际情况。

我真的建议像这样来把玩一下 gdb —— 即使你不理解你在内存中看到的每一件事,我发现实际上像这样看到我程序内存中的数据会使抽象的概念,比如“栈”和“堆”和“指针”更容易理解。

更多练习

一些关于思考栈的后续练习的想法(没有特定的顺序):

  • 尝试将另一个函数添加到 test.c 并在该函数的开头创建一个断点,看看是否可以从 main 中找到堆栈! 他们说当你调用一个函数时“堆栈会变小”,你能在 gdb 中看到这种情况吗?
  • 从函数返回一个指向栈上字符串的指针,看看哪里出了问题。 为什么返回指向栈上字符串的指针是不好的?
  • 尝试在 C 中引起堆栈溢出,并尝试通过在 gdb 中查看堆栈溢出来准确理解会发生什么!
  • 查看 Rust 程序中的堆栈并尝试找到变量!
  • 噩梦课程 中尝试一些缓冲区溢出挑战。每个问题的答案写在 README 文件中,因此如果你不想被宠坏,请避免先去看答案。 所有这些挑战的想法是给你一个二进制文件,你需要弄清楚如何导致缓冲区溢出以使其打印出 flag 字符串。

via: https://jvns.ca/blog/2021/05/17/how-to-look-at-the-stack-in-gdb/

作者:Julia Evans 选题:lujun9972 译者:amwps290 校对:wxy

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

在过去的几天中,我编写了一个叫作 dnspeep 的小工具,它能让你看到你电脑中正进行的 DNS 查询,并且还能看得到其响应。它现在只有 250 行 Rust 代码

我会讨论如何去尝试它、能做什么、为什么我要编写它,以及当我在开发时所遇到的问题。

如何尝试

我构建了一些二进制文件,因此你可以快速尝试一下。

对于 Linux(x86):

wget https://github.com/jvns/dnspeep/releases/download/v0.1.0/dnspeep-linux.tar.gz
tar -xf dnspeep-linux.tar.gz
sudo ./dnspeep

对于 Mac:

wget https://github.com/jvns/dnspeep/releases/download/v0.1.0/dnspeep-macos.tar.gz
tar -xf dnspeep-macos.tar.gz
sudo ./dnspeep

它需要以 超级用户 root 身份运行,因为它需要访问计算机正在发送的所有 DNS 数据包。 这与 tcpdump 需要以超级身份运行的原因相同:它使用 libpcap,这与 tcpdump 使用的库相同。

如果你不想在超级用户下运行下载的二进制文件,你也能在 https://github.com/jvns/dnspeep 查看源码并且自行编译。

输出结果是什么样的

以下是输出结果。每行都是一次 DNS 查询和响应:

$ sudo dnspeep
query   name                 server IP      response
A       firefox.com          192.168.1.1    A: 44.235.246.155, A: 44.236.72.93, A: 44.236.48.31
AAAA    firefox.com          192.168.1.1    NOERROR
A       bolt.dropbox.com     192.168.1.1    CNAME: bolt.v.dropbox.com, A: 162.125.19.131

这些查询是来自于我在浏览器中访问的 neopets.com,而 bolt.dropbox.com 查询是因为我正在运行 Dropbox 代理,并且我猜它不时会在后台运行,因为其需要同步。

为什么我要开发又一个 DNS 工具?

之所以这样做,是因为我认为当你不太了解 DNS 时,DNS 似乎真的很神秘!

你的浏览器(和你电脑上的其他软件)一直在进行 DNS 查询,我认为当你能真正看到请求和响应时,似乎会有更多的“真实感”。

我写这个也把它当做一个调试工具。我想“这是 DNS 的问题?”的时候,往往很难回答。我得到的印象是,当尝试检查问题是否由 DNS 引起时,人们经常使用试错法或猜测,而不是仅仅查看计算机所获得的 DNS 响应。

你可以看到哪些软件在“秘密”使用互联网

我喜欢该工具的一方面是,它让我可以感知到我电脑上有哪些程序正使用互联网!例如,我发现在我电脑上,某些软件出于某些理由不断地向 ping.manjaro.org 发送请求,可能是为了检查我是否已经连上互联网了。

实际上,我的一个朋友用这个工具发现,他的电脑上安装了一些以前工作时的企业监控软件,但他忘记了卸载,因此你甚至可能发现一些你想要删除的东西。

如果你不习惯的话, tcpdump 会令人感到困惑

当我试图向人们展示他们的计算机正在进行的 DNS 查询时,我的第一感是想“好吧,使用 tcpdump”!而 tcpdump 确实可以解析 DNS 数据包!

例如,下方是一次对 incoming.telemetry.mozilla.org. 的 DNS 查询结果:

11:36:38.973512 wlp3s0 Out IP 192.168.1.181.42281 > 192.168.1.1.53: 56271+ A? incoming.telemetry.mozilla.org. (48)
11:36:38.996060 wlp3s0 In  IP 192.168.1.1.53 > 192.168.1.181.42281: 56271 3/0/0 CNAME telemetry-incoming.r53-2.services.mozilla.com., CNAME prod.data-ingestion.prod.dataops.mozgcp.net., A 35.244.247.133 (180)

绝对可以学着去阅读理解一下,例如,让我们分解一下查询:

192.168.1.181.42281 > 192.168.1.1.53: 56271+ A? incoming.telemetry.mozilla.org. (48)

  • A? 意味着这是一次 A 类型的 DNS 查询
  • incoming.telemetry.mozilla.org. 是被查询的名称
  • 56271 是 DNS 查询的 ID
  • 192.168.1.181.42281 是源 IP/端口
  • 192.168.1.1.53 是目的 IP/端口
  • (48) 是 DNS 报文长度

在响应报文中,我们可以这样分解:

56271 3/0/0 CNAME telemetry-incoming.r53-2.services.mozilla.com., CNAME prod.data-ingestion.prod.dataops.mozgcp.net., A 35.244.247.133 (180)

  • 3/0/0 是在响应报文中的记录数:3 个回答,0 个权威记录,0 个附加记录。我认为 tcpdump 甚至只打印出回答响应报文。
  • CNAME telemetry-incoming.r53-2.services.mozilla.comCNAME prod.data-ingestion.prod.dataops.mozgcp.net.A 35.244.247.133 是三个响应记录。
  • 56271 是响应报文 ID,和查询报文的 ID 相对应。这就是你如何知道它是对前一行请求的响应。

我认为,这种格式最难处理的是(作为一个只想查看一些 DNS 流量的人),你必须手动匹配请求和响应,而且它们并不总是相邻的行。这就是计算机擅长的事情!

因此,我决定编写一个小程序(dnspeep)来进行匹配,并排除一些我认为多余的信息。

我在编写时所遇到的问题

在撰写本文时,我遇到了一些问题:

  • 我必须给 pcap 包打上补丁,使其能在 Mac 操作系统上和 Tokio 配合工作(这个更改)。这是其中的一个 bug,花了很多时间才搞清楚,用了 1 行代码才解决 :smiley:
  • 不同的 Linux 发行版似乎有不同的 libpcap.so 版本。所以我不能轻易地分发一个动态链接 libpcap 的二进制文件(你可以 在这里 看到其他人也有同样的问题)。因此,我决定在 Linux 上将 libpcap 静态编译到这个工具中。但我仍然不太了解如何在 Rust 中正确做到这一点作,但我通过将 libpcap.a 文件复制到 target/release/deps 目录下,然后直接运行 cargo build,使其得以工作。
  • 我使用的 dns_parser carte 并不支持所有 DNS 查询类型,只支持最常见的。我可能需要更换一个不同的工具包来解析 DNS 数据包,但目前为止还没有找到合适的。
  • 因为 pcap 接口只提供原始字节(包括以太网帧),所以我需要 编写代码来计算从开头剥离多少字节才能获得数据包的 IP 报头。我很肯定我还遗漏了一些情形。

我对于给它取名也有过一段艰难的时光,因为已经有许多 DNS 工具了(dnsspy!dnssnoop!dnssniff!dnswatch!)我基本上只是查了下有关“监听”的每个同义词,然后选择了一个看起来很有趣并且还没有被其他 DNS 工具所占用的名称。

该程序没有做的一件事就是告诉你哪个进程进行了 DNS 查询,我发现有一个名为 dnssnoop 的工具可以做到这一点。它使用 eBPF,看上去很酷,但我还没有尝试过。

可能会有许多 bug

我只在 Linux 和 Mac 上简单测试了一下,并且我已知至少有一个 bug(不支持足够多的 DNS 查询类型),所以请在遇到问题时告知我!

尽管这个 bug 没什么危害,因为这 libpcap 接口是只读的。所以可能发生的最糟糕的事情是它得到一些它无法解析的输入,最后打印出错误或是崩溃。

编写小型教育工具很有趣

最近,我对编写小型教育的 DNS 工具十分感兴趣。

到目前为止我所编写的工具:

以前我尽力阐述已有的工具(如 digtcpdump)而不是编写自己的工具,但是经常我发现这些工具的输出结果让人费解,所以我非常关注以更加友好的方式来看这些相同的信息,以便每个人都能明白他们电脑正在进行的 DNS 查询,而不仅仅是依赖 tcmdump。


via: https://jvns.ca/blog/2021/03/31/dnspeep-tool/

作者:Julia Evans 选题:lujun9972 译者:wyxplus 校对:wxy

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

昨天我 在 Twitter 上询问大家用 strace 解决了什么问题?,和往常一样,大家真的是给出了自己的答案! 我收到了大约 200 个答案,然后花了很多时间手动将它们归为 9 类。

这些解决的问题都是关于寻找程序依赖的文件、找出程序卡住或慢的原因、或者找出程序失败的原因。这些总体上与我自己使用 strace 的内容相吻合,但也有一些我没有想到的东西!

我不打算在这篇文章里解释什么是 strace,但我有一本 关于它的免费杂志一个讲座 以及 很多博文

问题 1:配置文件在哪里?

最受欢迎的问题是“这个程序有一个配置文件,但我不知道它在哪里”。这可能也是我最常使用 strace 解决的问题,因为这是个很简单的问题。

这很好,因为一个程序有一百万种方法来记录它的配置文件在哪里(在手册页、网站上、--help等),但只有一种方法可以让它真正打开它(用系统调用!)。

问题 2:这个程序还依赖什么文件?

你也可以使用 strace 来查找程序依赖的其他类型的文件,比如:

问题 3:为什么这个程序会挂掉?

你有一个程序,它只是坐在那里什么都不做,这是怎么回事?这个问题特别容易回答,因为很多时候你只需要运行 strace -p PID,看看当前运行的是什么系统调用。你甚至不需要看几百行的输出。

答案通常是“正在等待某种 I/O”。“为什么会卡住”的一些可能的答案(虽然还有很多!):

  • 它一直在轮询 select()
  • 正在 wait() 等待一个子进程完成
  • 它在向某个没有响应的东西发出网络请求
  • 正在进行 write(),但由于缓冲区已满而被阻止。
  • 它在 stdin 上做 read(),等待输入。

有人还举了一个很好的例子,用 strace 调试一个卡住的 df 命令:“用 strace df -h 你可以找到卡住的挂载,然后卸载它”。

问题 4:这个程序卡住了吗?

这是上一个问题的变种:有时一个程序运行的时间比你预期的要长,你只是想知道它是否卡住了,或者它是否还在继续进行。

只要程序在运行过程中进行系统调用,用 strace 就可以超简单地回答这个问题:只需 strace 它,看看它是否在进行新的系统调用!

问题 5:为什么这个程序很慢?

你可以使用 strace 作为一种粗略的剖析工具:strace -t 会显示每次系统调用的时间戳,这样你就可以寻找大的漏洞,找到罪魁祸首。

以下是 Twitter 上 9 个人使用 strace 调试“为什么这个程序很慢?”的小故事。

  • 早在 2000 年,我帮助支持的一个基于 Java 的网站在适度的负载下奄奄一息:页面加载缓慢,甚至完全加载不出来。我们对 J2EE 应用服务器进行了测试,发现它每次只读取一个类文件。开发人员没有使用 BufferedReader,这是典型的 Java 错误。
  • 优化应用程序的启动时间……运行 strace 可以让人大开眼界,因为有大量不必要的文件系统交互在进行(例如,在同一个配置文件上反复打开/读取/关闭;在一个缓慢的 NFS 挂载上加载大量的字体文件,等等)。
  • 问自己为什么在 PHP 中从会话文件中读取(通常是小于 100 字节)非常慢。结果发现一些 flock 系统调用花了大约 60 秒。
  • 一个程序表现得异常缓慢。使用 strace 找出它在每次请求时,通过从 /dev/random 读取数据并耗尽熵来重新初始化其内部伪随机数发生器。
  • 我记得最近一件事是连接到一个任务处理程序,看到它有多少网络调用(这是意想不到的)。
  • strace 显示它打开/读取同一个配置文件数千次。
  • 服务器随机使用 100% 的 CPU 时间,实际流量很低。原来是碰到打开文件数限制,接受一个套接字时,得到 EMFILE 错误而没有报告,然后一直重试。
  • 一个工作流运行超慢,但是没有日志,结果它做一个 POST 请求花了 30 秒而超时,然后重试了 5 次……结果后台服务不堪重负,但是也没有可视性。
  • 使用 strace 注意到 gethostbyname() 需要很长时间才能返回(你不能直接看到 gethostbyname,但你可以看到 strace 中的 DNS 数据包)

问题 6:隐藏的权限错误

有时候程序因为一个神秘的原因而失败,但问题只是有一些它没有权限打开的文件。在理想的世界里,程序会报告这些错误(“Error opening file /dev/whatever: permission denied”),当然这个世界并不完美,所以 strace 真的可以帮助解决这个问题!

这其实是我最近使用 strace 做的事情。我使用了一台 AxiDraw 绘图仪,当我试图启动它时,它打印出了一个难以理解的错误信息。我 strace 它,结果发现我的用户没有权限打开 USB 设备。

问题 7:正在使用什么命令行参数?

有时候,一个脚本正在运行另一个程序,你想知道它传递的是什么命令行标志!

几个来自 Twitter 的例子。

  • 找出实际上是用来编译代码的编译器标志
  • 由于命令行太长,命令失败了

问题 8:为什么这个网络连接失败?

基本上,这里的目标是找到网络连接的域名 / IP 地址。你可以通过 DNS 请求来查找域名,或者通过 connect 系统调用来查找 IP。

一般来说,当 tcpdump 因为某些原因不能使用或者只是因为比较熟悉 strace 时,就经常会使用 strace 调试网络问题。

问题 9:为什么这个程序以一种方式运行时成功,以另一种方式运行时失败?

例如:

  • 同样的二进制程序在一台机器上可以运行,在另一台机器上却失败了
  • 可以运行,但被 systemd 单元文件生成时失败
  • 可以运行,但以 su - user /some/script 的方式运行时失败
  • 可以运行,作为 cron 作业运行时失败

能够比较两种情况下的 strace 输出是非常有用的。虽然我在调试“以我的用户身份工作,而在同一台计算机上以不同方式运行时却失败了”时,第一步是“看看我的环境变量”。

我在做什么:慢慢地建立一些挑战

我之所以会想到这个问题,是因为我一直在慢慢地进行一些挑战,以帮助人们练习使用 strace 和其他命令行工具。我的想法是,给你一个问题,一个终端,你可以自由地以任何方式解决它。

所以我的目标是用它来建立一些你可以用 strace 解决的练习题,这些练习题反映了人们在现实生活中实际使用它解决的问题。

就是这样!

可能还有更多的问题可以用 strace 解决,我在这里还没有讲到,我很乐意听到我错过了什么!

我真的很喜欢看到很多相同的用法一次又一次地出现:至少有 20 个不同的人回答说他们使用 strace 来查找配置文件。而且和以往一样,我觉得这样一个简单的工具(“跟踪系统调用!”)可以用来解决这么多不同类型的问题,真的很令人高兴。


via: https://jvns.ca/blog/2021/04/03/what-problems-do-people-solve-with-strace/

作者:Julia Evans 选题:lujun9972 译者:wxy 校对:wxy

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

在过去的几周里,我花了很多时间用 PyTorch 实现了一个 char-rnn 的版本。我以前从未训练过神经网络,所以这可能是一个有趣的开始。

这个想法(来自 循环神经网络的不合理效应)可以让你在文本上训练一个基于字符的 循环神经网络 recurrent neural network (RNN),并得到一些出乎意料好的结果。

不过,虽然没有得到我想要的结果,但是我还是想分享一些示例代码和结果,希望对其他开始尝试使用 PyTorch 和 RNN 的人有帮助。

这是 Jupyter 笔记本格式的代码:char-rnn in PyTorch.ipynb。你可以点击这个网页最上面那个按钮 “Open in Colab”,就可以在 Google 的 Colab 服务中打开,并使用免费的 GPU 进行训练。所有的东西加起来大概有 75 行代码,我将在这篇博文中尽可能地详细解释。

第一步:准备数据

首先,我们要下载数据。我使用的是 古登堡项目 Project Gutenberg 中的这个数据:Hans Christian Anderson’s fairy tales

!wget -O fairy-tales.txt

这个是准备数据的代码。我使用 fastai 库中的 Vocab 类进行数据处理,它能将一堆字母转换成“词表”,然后用这个“词表”把字母变成数字。

之后我们就得到了一个大的数字数组(training_set),我们可以用于训练我们的模型。

from fastai.text import *
text = unidecode.unidecode(open('fairy-tales.txt').read())
v = Vocab.create((x for x in text), max_vocab=400, min_freq=1)
training_set = torch.Tensor(v.numericalize([x for x in text])).type(torch.LongTensor).cuda()
num_letters = len(v.itos)

第二步:定义模型

这个是 PyTorch 中 LSTM 类的封装。除了封装 LSTM 类以外,它还做了三件事:

  1. 对输入向量进行 one-hot 编码,使得它们具有正确的维度。
  2. LSTM 层后一层添加一个线性变换,因为 LSTM 输出的是一个长度为 hidden_size 的向量,我们需要的是一个长度为 input_size 的向量这样才能把它变成一个字符。
  3. LSTM 隐藏层的输出向量(实际上有 2 个向量)保存成实例变量,然后在每轮运行结束后执行 .detach() 函数。(我很难解释清 .detach() 的作用,但我的理解是,它在某种程度上“结束”了模型的求导计算)(LCTT 译注:detach() 函数是将该张量的 requires_grad 参数设置为 False,即反向传播到该张量就结束。)
class MyLSTM(nn.Module):
    def __init__(self, input_size, hidden_size):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.h2o = nn.Linear(hidden_size, input_size)
        self.input_size=input_size
        self.hidden = None

    def forward(self, input):
        input = torch.nn.functional.one_hot(input, num_classes=self.input_size).type(torch.FloatTensor).cuda().unsqueeze(0)
        if self.hidden is None:
            l_output, self.hidden = self.lstm(input)
        else:
            l_output, self.hidden = self.lstm(input, self.hidden)
        self.hidden = (self.hidden[0].detach(), self.hidden[1].detach())

        return self.h2o(l_output)

这个代码还做了一些比较神奇但是不太明显的功能。如果你的输入是一个向量(比如 [1,2,3,4,5,6]),对应六个字母,那么我的理解是 nn.LSTM 会在内部使用沿时间反向传播更新隐藏向量 6 次。

第三步:编写训练代码

模型不会自己训练的!

我最开始的时候尝试用 fastai 库中的一个辅助类(也是 PyTorch 中的封装)。我有点疑惑因为我不知道它在做什么,所以最后我自己编写了模型训练代码。

下面这些代码(epoch() 方法)就是有关于一轮训练过程的基本信息。基本上就是重复做下面这几件事情:

  1. 往 RNN 模型中传入一个字符串,比如 and they ought not to teas。(要以数字向量的形式传入)
  2. 得到下一个字母的预测结果
  3. 计算 RNN 模型预测结果和真实的下一个字母之间的损失函数(e,因为 tease 这个单词是以 e 结尾的)
  4. 计算梯度(用 loss.backward() 函数)
  5. 沿着梯度下降的方向修改模型中参数的权重(用 self.optimizer.step() 函数)
class Trainer():
  def __init__(self):
      self.rnn = MyLSTM(input_size, hidden_size).cuda()
      self.optimizer = torch.optim.Adam(self.rnn.parameters(), amsgrad=True, lr=lr)
  def epoch(self):
      i = 0
      while i < len(training_set) - 40:
        seq_len = random.randint(10, 40)
        input, target = training_set[i:i+seq_len],training_set[i+1:i+1+seq_len]
        i += seq_len
        # forward pass
        output = self.rnn(input)
        loss = F.cross_entropy(output.squeeze()[-1:], target[-1:])
        # compute gradients and take optimizer step
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

使用 nn.LSTM 沿着时间反向传播,不要自己写代码

开始的时候我自己写代码每次传一个字母到 LSTM 层中,之后定期计算导数,就像下面这样:

for i in range(20):
    input, target = next(iter)
    output, hidden = self.lstm(input, hidden)
loss = F.cross_entropy(output, target)
hidden = hidden.detach()
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()

这段代码每次传入 20 个字母,每次一个,并且在最后训练了一次。这个步骤就被称为沿时间反向传播,Karpathy 在他的博客中就是用这种方法。

这个方法有些用处,我编写的损失函数开始能够下降一段时间,但之后就会出现峰值。我不知道为什么会出现这种现象,但之后我改为一次传入 20 个字符到 LSTM 之后(按 seq_len 维度),再进行反向传播,情况就变好了。

第四步:训练模型!

我在同样的数据上重复执行了这个训练代码大概 300 次,直到模型开始输出一些看起来像英文的文本。差不多花了一个多小时吧。

这种情况下我也不关注模型是不是过拟合了,但是如果你在真实场景中训练模型,应该要在验证集上验证你的模型。

第五步:生成输出!

最后一件要做的事就是用这个模型生成一些输出。我写了一个辅助方法从这个训练好的模型中生成文本(make_predsnext_pred)。这里主要是把向量的维度对齐,重要的一点是:

output = rnn(input)
prediction_vector = F.softmax(output/temperature)
letter = v.textify(torch.multinomial(prediction_vector, 1).flatten(), sep='').replace('_', ' ')

基本上做的事情就是这些:

  1. RNN 层为字母表中的每一个字母或者符号输出一个数值向量(output)。
  2. 这个 output 向量并不是一个概率向量,所以需要 F.softmax(output/temperature) 操作,将其转换为概率值(也就是所有数值加起来和为 1)。temperature 某种程度上控制了对更高概率的权重,在限制范围内,如果设置 temperature=0.0000001,它将始终选择概率最高的字母。
  3. torch.multinomial(prediction_vector) 用于获取概率向量,并使用这些概率在向量中选择一个索引(如 12)。
  4. v.textify12 转换为字母。

如果我们想要处理的文本长度为 300,那么只需要重复这个过程 300 次就可以了。

结果!

我把预测函数中的参数设置为 temperature = 1 得到了下面的这些由模型生成的结果。看起来有点像英语,这个结果已经很不错了,因为这个模型要从头开始“学习”英语,并且是在字符序列的级别上进行学习的。

虽然这些话没有什么含义,但我们也不知道到底想要得到什么输出。

“An who was you colotal said that have to have been a little crimantable and beamed home the beetle. “I shall be in the head of the green for the sound of the wood. The pastor. “I child hand through the emperor’s sorthes, where the mother was a great deal down the conscious, which are all the gleam of the wood they saw the last great of the emperor’s forments, the house of a large gone there was nothing of the wonded the sound of which she saw in the converse of the beetle. “I shall know happy to him. This stories herself and the sound of the young mons feathery in the green safe.”

“That was the pastor. The some and hand on the water sound of the beauty be and home to have been consider and tree and the face. The some to the froghesses and stringing to the sea, and the yellow was too intention, he was not a warm to the pastor. The pastor which are the faten to go and the world from the bell, why really the laborer’s back of most handsome that she was a caperven and the confectioned and thoughts were seated to have great made

下面这些结果是当 temperature=0.1 时生成的,它选择字符的方式更接近于“每次都选择出现概率最高的字符”。这就使得输出结果有很多是重复的。

ole the sound of the beauty of the beetle. “She was a great emperor of the sea, and the sun was so warm to the confectioned the beetle. “I shall be so many for the beetle. “I shall be so many for the beetle. “I shall be so standen for the world, and the sun was so warm to the sea, and the sun was so warm to the sea, and the sound of the world from the bell, where the beetle was the sea, and the sound of the world from the bell, where the beetle was the sea, and the sound of the wood flowers and the sound of the wood, and the sound of the world from the bell, where the world from the wood, and the sound of the

这段输出对这几个单词 beetlesconfectionerssunsea 有着奇怪的执念。

总结!

至此,我的结果远不及 Karpathy 的好,可能有一下几个原因:

  1. 没有足够多的训练数据。
  2. 训练了一个小时之后我就没有耐心去查看 Colab 笔记本上的信息。
  3. Karpathy 使用了两层LSTM,包含了更多的参数,而我只使用了一层。
  4. 完全是另一回事。

但我得到了一些大致说得过去的结果!还不错!


via: https://jvns.ca/blog/2020/11/30/implement-char-rnn-in-pytorch/

作者:Julia Evans 选题:lujun9972 译者:zhangxiangping 校对:wxy

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

大家好!今天是我搭建这个玩具项目的第 2 天。下面再来记录一下关于 Rails 的一些有趣的事情吧!

目标:做一个冰箱诗歌论坛

我想做一种无聊的标准网站来学习 Rails,并且其他人可以与之互动,就像一个论坛一样! 但如果人们真的可以在网站上打字,那就会产生各种各样的问题(如果他们是垃圾邮件发送者怎么办?又或者只是言语刻薄?)。

我想到的第一个想法是,可以让人们与网站互动,但实际上却不能在网站上打字,那就是一个“冰箱诗歌论坛”,只给你一组固定的字,你就可以随意组合。

所以,这就是我们的计划!

我这个项目的目标是想知道我是否能用 Rails 来做其他的小型网络项目(而不是像我通常做的那样,使用一些更基本的东西,比如 Flask,或者放弃后端,用 Javascript 来写所有东西)。

怎么把字拖来拖去呢?jQuery 的可拖放 UI!

我想让大家能够把文字拖动起来,但我又不想写很多 Javascript。结果发现这超级简单 —— 有一个 jQuery 库可以做到,它叫做 draggable!一开始,拖动并不成功。

一开始拖动在手机上是不行的,但是有一个技巧可以让 jQuery UI 在手机上工作,叫做 jQuery UI touch punch。下面是它的样子(有兴趣看工作原理的可以查看源码,代码很少)。

banana forest cake is

一个有趣的 Rails 功能:关联

我以前从来没有使用过关系型 ORM,对于 Rails,我很兴奋的一件事就是想看看使用 Active Record 是什么样子的!今天我了解了 Rails 的 ORM 功能之一:关联。如果你像我一样对 ORM 完全不了解的话,那就来看看是怎么回事吧。

在我的论坛中,我有:

  • 用户
  • 话题(我本来想把它叫做“线索”,但显然这在 Rails 中是一个保留词,所以现在叫做“话题”)。
  • 帖子

当显示一个帖子时,我需要显示创建该帖子的用户的用户名。所以我想我可能需要写一些代码来加载帖子,并为每个帖子加载用户,就像这样(在 Rails 中,Post.whereUser.find 将会运行 SQL 语句,并将结果转化为 Ruby 对象):

@posts = Post.where(topic_id: id)
@posts.each do |post|
    user = User.find(post.user_id)
    post.user = user
end

这还不够好,它要为每个帖子做一次单独的 SQL 查询!我知道有一个更好的方法,我发现它叫做关联。这个链接是来自 https://guides.rubyonrails.org 的指南,到目前为止,它对我很有帮助。

基本上我需要做的就是:

  1. User 模型中添加一行 has_many :post
  2. Post 模型中添加一行 belongs_to :user
  3. Rails 现在知道如何将这两个表连接起来,尽管我没有告诉它要连接到什么列上!我认为这是因为我按照它所期望的惯例命名了 posts 表中的 user_id 列。
  4. UserTopic 做完全相同的事情(一个主题也有很多帖子:has_many :posts)。

然后我加载每一个帖子和它的关联用户的代码就变成了只有一行! 就是这一行:

@posts = @topic.posts.order(created_at: :asc).preload(:user)

比起只有一行更重要的是,它不是单独做一个查询来获取每个帖子的用户,而是在 1 个查询中获取所有用户。显然,在 Rails 中,有一堆不同的方法来做类似的事情(预加载、急切加载、联接和包含?),我还不知道这些都是什么,但也许我以后会知道的。

一个有趣的 Rails 功能:脚手架!

Rails 有一个叫 rails 的命令行工具,它可以生成很多代码。例如,我想添加一个 Topic 模型/控制器。我不用去想在哪里添加所有的代码,可以直接运行

rails generate scaffold Topic title:text

并生成了一堆代码,这样我已经有了基本的端点来创建/编辑/删除主题(Topic)。例如,这是我的现在的主题控制器,其中大部分我没有写(我只写了高亮的 3 行)。我可能会删除很多内容,但是有一个起点,让我可以扩展我想要的部分,删除我不想要的部分,感觉还不错。

数据库迁移!

rails 工具还可以生成数据库迁移! 例如,我决定要删除帖子中的 title 字段。

下面是我要做的:

rails generate migration RemoveTitleFromPosts title:string
rails db:migrate

就是这样 —— 只要运行几个命令行咒语就可以了! 我运行了几个这样的迁移,因为我改变了对我的数据库模式的设想。它是相当直接的,到目前为止 —— 感觉很神奇。

当我试图在一列中的某些字段为空的地方添加一个“不为空”(not null)约束时,情况就变得有点有趣了 —— 迁移失败。但我可以修复违例的记录,并轻松地重新运行迁移。

今天就到这里吧!

明天,如果我有更多的进展,也许我会把它放在互联网上。


via: https://jvns.ca/blog/2020/11/10/day-2--rails-associations---dragging-divs-around/

作者:Julia Evans 选题:lujun9972 译者:wxy 校对:wxy

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