bash - 这个其他版本的 bash fork 炸弹是如何工作的？

Question

我大致了解了如何 this common version

:(){ :|:& };:

bash fork 炸弹的工作原理。

但是，我看到了另一个版本(特别是 bash)

#!/bin/bash
$0 &
$0 &

关于 Wikipedia fork bomb article在 SO answer 中到 closed duplicate我上面提到的原始 fork 炸弹问题。

我正在寻找关于叉形炸弹的第二个(可能不太常见)版本如何工作的解释。我已经根据我目前对它的作用的理解对下面的代码进行了评论，但我并没有真正理解它是如何以其他版本的 bash fork 炸弹的方式实现无限递归的(可能是由于我对 bash 的理解不足流程和背景)。

#!/bin/bash    # Specifies the location of the executable
               # to use in executing this script.
$0 &           # Duplicates (executes a new instance
               # of) the current running process ('$0')
               # (which would be the invocation of bash used
               # to start running the script, right?)
               # and background it ('&').
$0 &           # Do the same as above, where $0 would be
               # equivalent to the initial call to bash
               # used to start the script, right? Or, would
               # it be the backgrounded call to bash from the
               # second line? I'm leaning towards the former.

编辑:我对脚本的修改理解(至少在我目前担心的抽象级别上)在下面以注释代码的形式出现。我将我最初的评论代码留给了 future 的观众，他们可能会和我有同样的最初误解。假设脚本位于 bomb.sh 中。

#!/bin/bash    # Script will execute using /bin/bash executable.
$0 &           # The current process (P) will spawn a child process (C1)
               # by invoking the command that spawned P
               # (/bin/bash ./bomb.sh). This makes the script recursive.
               # & allows processes to run in the background
               # (allowing process death and avoiding a potential
               # process limit).
$0 &           # Process P spawns a second child process (C2), also 
               # in the background, which gives us the exponential growth
               # (in base 2) that we want per level of recursion.

Answer 1

如果你把这个炸弹分解一下，它可能更有意义。将其更改为:

#!/bin/bash
$0

这个炸弹会一遍又一遍地生成 shell 脚本的新副本:

$ ps auxw | grep pts/2
sarnold   2410  0.0  0.1  24840  6340 pts/2    Ss   Nov17   0:01 bash
sarnold  17280  0.0  0.0  12296  1600 pts/2    S+   18:01   0:00 /bin/bash ./bomb.sh
sarnold  17281  0.0  0.0  12296  1600 pts/2    S+   18:01   0:00 /bin/bash ./bomb.sh
sarnold  17282  0.0  0.0  12296  1600 pts/2    S+   18:01   0:00 /bin/bash ./bomb.sh
sarnold  17283  0.0  0.0  12296  1596 pts/2    S+   18:01   0:00 /bin/bash ./bomb.sh
sarnold  17284  0.0  0.0  12296  1600 pts/2    S+   18:01   0:00 /bin/bash ./bomb.sh
...
$ ps auxw | grep pts/2 | wc -l
2077

每个旧的基本上都是“死的”——等待从被执行的 child 那里获得退出状态。当然，直到其中一个被执行的子进程由于进程限制而最终无法执行时，才会发生这种情况。 (这顺便提醒我，在进一步玩之前设置一个 nproc rlimit 可能是个好主意。)

所以这个进程树看起来是这样的:

1
 2
  3
   4
    5
     6

如果您将 & 添加到命令的末尾，您会看到较旧的代码可以最终被调度并终止。不过，新进程的形成速度同样快，因此这会导致相当大的流失，并有助于降低在产生最大数量的进程时结束的可能性。这棵树看起来更像这样:

1
 2
  3

    5
     6

       8

添加 second $0 & 行会使树看起来有点不同:

           1
        2     3
      4   5 6   7

除非它可能不会这个很好——第二个过程可能会开始第三个，而不是第一个开始第三个。它可能看起来非常困惑。

总的来说，每个“层”的大小都会是前一层的两倍，但是 execve(2) 只能如此频繁地调用——诀窍是这个炸弹会 可能 强制执行比更简单的炸弹更多的进程上下文切换，所有那些 TLB刷新将显着影响系统的性能。因为父进程在执行完两个子进程后基本上会随机消失，init(8) 将远更多的进程重新成为父进程。所有这些都会增加发送到 init(8) 进行清理的信号数量，这会使管理员更难登录并修复问题。