主页 / user-233854

Zoltan K.'s questions

Martin Hope
Zoltan K.
Asked: 2024-06-23 20:14:29 +0800 CST
  • 6

问题 1:

使用systemctl status name.service，我得到的其中一行是：

CPU: 3.555s

但我找不到任何关于其含义的信息。

由于以秒为单位，我猜测这是 cgroup 消耗的总 CPU 时间，但我希望得到确认，或者有一个解释这一点的手册页。

问题2：

如果我的假设是正确的，那么结合以下行中 cgroup 的正常运行时间

Active: active (running) since Sun 2024-06-23 13:54:29 CEST; 12min ago

将给出这个过程所消耗的 CPU 时间的平均百分比，对吗？

systemd
Martin Hope
Zoltan K.
Asked: 2022-05-03 08:36:00 +0800 CST
  • 0

如果一个进程在被停止后得到一个信号会发生什么SIGSTOP？

我试图了解并很好地了解如何处理它。不幸的是，我只能找到对信号的简短描述，但没有特定用例的详细信息。

截至目前，我的理解是，虽然SIGSTOP有效：

  • SIGKILL将立即终止该进程
  • 其他信号将被收集起来，在 aSIGCONT上，暂停的信号将在进程中释放，就好像所有信号都在那个时刻发送一样
  • SIGCONT在处理 a , sa_mask, sa_flags's等之后的成束信号SA_RESTART时，将按正常方式应用

例如，如果有SIGSTOP-> SIGHUP->SIGCONT序列，则处理SIGHUP将暂停，直到SIGCONT收到 after 为止。

我不确定这是否正确。

我仍然对这些情况一无所知：

  1. 我仍然对聚集信号的顺序感到困惑。

    例如：SIGSTOP-> SIGHUP-> SIGTERM-> SIGCONT：将按照收到SIGHUP的SIGTERM顺序处理，还是按照任意顺序处理？

  2. 如果SIGSTOP在有效期间多次接收到相同的信号会发生什么？

    SIGSTOP-> SIGHUP-> SIGHUP->SIGCONT

  3. 会SIGSTOP中断正在运行的信号处理程序吗？如果信号正在等待处理，它们是否会保留到SIGCONT?

我在这些类似问题的答案中找到了一些答案，但我对上述事情仍然不清楚。

signals
Martin Hope
Zoltan K.
Asked: 2022-03-02 23:39:13 +0800 CST
  • 0

我有我的官方 Debian 存储库（比如repo1）。现在我从package X( repo2) 添加供应商的回购。软件包 X 不在官方 Debian 存储库中。当然，repo 2可以有一些重叠的包repo 1，比如package Y，有些甚至可能永远不会，并且需要package X运行（repo 1::package Yhas version 1.0，repo 2::package Yhas version 2.0）。

我想知道，何时package X从repo 2. 最好甚至阻止从 安装任何软件包repo 2，以避免它弄乱我的系统。

我目前的想法是限制repo2，所以只能package X从那里安装，但我不知道如何做到这一点。

为什么我可能想要这个：

  • 我可能不完全信任repo2，我想跟踪来自那里的包裹

  • 如果有包，除了package X来自之外repo2，并且我不允许安装这些包，它会中断package X，但这没问题，我可以在那时决定是否允许来自该来源的那些包，但我会有一个预知正在发生的事情

基本上我想apt告诉我，如果有任何其他内容，不是Package X从repo 2.

我考虑过的一些解决方案：

适当固定：

  • 我认为行不通，因为 if package Xrequires version 2.0of package Y, and repo1has version 1.0,repo 2将被使用，不管固定

调整Packages.gz来自repo 2：

  • 我不知道，这怎么可能实现
linux apt
Martin Hope
Zoltan K.
Asked: 2021-09-16 08:35:49 +0800 CST
  • 0
{
echo bla1
echo bla2 1>&2
} >>myfile 2>&1

echo这两个-s有什么区别吗？

我能想到的唯一区别是，如果echo bla2 2>&1保留来自 stderr 的无缓冲属性。

怎么样

{
echo bla1
echo bla2 1>&2 &
} >>myfile 2>&1

?

是不是一样

{
echo bla1
echo bla2 &
} >>myfile 2>&1

?

之后{...} >>myfile 2>&1fd1 和 fd2 本质上会变成同一个东西，还是它们会保留过去的任何东西？

编辑：

基于@ilkkachu 的答案，我尝试了以下方法：

perl -e 'print "foo"; sleep 2; print "bar\n"; sleep 2; print "bla"'
# ^^^line buffered
perl -e 'print "foo"; sleep 2; print "bar\n"; sleep 2; print "bla"' | cat
# ^^^block buffered
touch myfile; tail -f myfile &
perl -e 'print "foo"; sleep 2; print "bar\n"; sleep 2; print "bla"' >>myfile 2>&1
# ^^^block buffered
perl -e 'print STDERR "foo"; sleep 2; print STDERR "bar\n"; sleep 2; print STDERR "bla"'
# ^^^unbuffered
perl -e 'print STDERR "foo"; sleep 2; print STDERR "bar\n"; sleep 2; print STDERR "bla"' 2>&1 | cat
# ^^^unbuffered
perl -e 'print STDERR "foo"; sleep 2; print STDERR "bar\n"; sleep 2; print STDERR "bla"' >>myfile 2>&1
# ^^^unbuffered

在 fd1 的情况下，根据输出类型调整缓冲。

在 fd2 的情况下，输出无关紧要。

{ echo -n foo; sleep 2; echo bar; sleep 2; echo -n bla; }
# ^^^unbuffered
{ echo -n foo; sleep 2; echo bar; sleep 2; echo -n bla; } | cat
# ^^^unbuffered
touch myfile; tail -f myfile &
{ echo -n foo; sleep 2; echo bar; sleep 2; echo -n bla; } >>myfile 2>&1
# ^^^unbuffered
{ echo -n foo 1>&2; sleep 2; echo bar 1>&2; sleep 2; echo -n bla 1>&2; }
# ^^^unbuffered
{ echo -n foo 1>&2; sleep 2; echo bar 1>&2; sleep 2; echo -n bla 1>&2; } | cat
# ^^^unbuffered
{ echo -n foo 1>&2; sleep 2; echo bar 1>&2; sleep 2; echo -n bla 1>&2; } >>myfile 2>&1
# ^^^unbuffered

似乎，echo总是刷新，不管输出去哪里。

实验重复了

{ printf foo; sleep 2; printf 'bar\n'; sleep 2; printf bla; }

同样，结果与 相同echo。

结果： 在上述情况下，缓冲是由作者决定的。

bash io-redirection
Martin Hope
Zoltan K.
Asked: 2021-09-13 02:36:45 +0800 CST
  • 2

我应该如何在 systemd 中执行此操作？

start unit.A
 started unit.A
start unit.B
 started unit.B

stop unit.A
 stopped unit.A
stop unit.B
 stopped unit.B

我知道After=/Before=会在启动/停止时像 AB -> BA 一样反向订购单位，但我需要 AB -> AB。

我的猜测是，我必须unit.A与unit.B类似的东西合并

unit.A.服务：

ExecStartPost=unit.A

并处理停止订购ExecStopPost=。

编辑：

似乎Upholds=and的组合PropagatesStopTo=可能会给我我想要的东西，或者非常接近，但事实证明，这些是添加的systemd version 249，但我必须让它在241/上运行247。

Upholds=我仍然对是否以及是否是正确的电话有学术兴趣，我是否PropagatesStopTo=可以访问systemd 249？

systemd start-stop-daemon
Martin Hope
Zoltan K.
Asked: 2021-09-03 10:51:46 +0800 CST
  • 1

我可以为陷阱处理程序中的 shell 脚本分配不同的退出状态吗？

通过反复试验，我发现调用退出状态exit是trap可以改变的。正常命令，无论失败还是成功，都不会改变退出状态。

现在我想知道，我是否可以依赖这种行为，或者是一些实现怪癖？

我一直试图在这方面找到一些文档，但无济于事。

测试脚本：

#!/bin/bash
function handler {
    # a successful command won't change script exit status
    echo handler, status=$1
    # badcommand won't change script exit status
    #badcommand
    # exit will change script exit status
    #exit 23
}
trap 'handler $?' EXIT
#badcommand

用法：

./trap_test.sh; echo status_out=$?
bash exit-status
Martin Hope
Zoltan K.
Asked: 2019-10-29 23:46:35 +0800 CST
  • 0

这是一个小实验：

t1=$(date +%s%N)
ta=0
for i in `seq 1 1000`
do
    t1a=$(date +%s%N)
    echo blabla
    t2a=$(date +%s%N)
    ((ta=ta+(t2a-t1a)))
done
t2=$(date +%s%N)
echo diffb: $((t2-t1))ns
echo diffba: $((t2a-t1a))ns

结果：

diffb: 2767264439ns # this is the overall result
diffba: 1482172ns # this is the aggregated result for the core

我现在可以看到人们在想：这显然是循环核心中的仪器。但不是。我在一个更复杂的循环中看到了这一点，其中包含 IO 操作、排序、uniq、if、cp ......经过几次运行后，整个循环的开销在 100x-1000x 之间！

但是，为了确定，我echo blabla用date +%s%N. 结果：

diffb: 3713962570ns
diffba: 2662492ns

这绝对不是仪器！

好的，那么试试这个：

a=0; while [[ $((a++)) -lt 1000 ]];

结果：

diffb: 3761656210ns
diffba: 1953502ns

我在这里想念什么吗？这里有什么明显的东西，为什么这些结果是错误的？还是我只是偶然发现了现实？Bash 循环的开销是全宇宙最高的？？

（我想优化代码，所以我开始测量基线，但似乎超出了优化范围。）

编辑：我做了其他事情，我将迭代次数从 1000 降至 500（我为此使用了 while 循环），结果：

diffb: 1886513017ns
diffba: 2328892ns

与之比较：

diffb: 3761656210ns
diffba: 1953502ns

它确实似乎是循环开销，因为核心已经达到了一些非线性时序，可能是一些恒定的初始化，或者一些内核缓存的东西，等等。

bash
Martin Hope
Zoltan K.
Asked: 2019-10-26 07:02:09 +0800 CST
  • 6

我不明白：

脚本：WORKDIR/sh/script.sh

[ -e filename ]          \
&& echo filename         \
|| [ -e ../filename ]    \
&& echo ../filename      \
|| { echo 'ERROR: failed to find "filename"' 1>&2 ; exit -1; }

输出：

$ cd WORKDIR/sh
$ ./script.sh
../filename

$ cd WORKDIR
$ sh/script.sh
filename
../filename      # <---- WHY????

我的想法：

1

[ -e filename ]          \ -> false
&&                         -> skip this, it is already false
   echo filename         \ -> don't even try
|| [ -e ../filename ]    \ -> true
&& echo ../filename      \ -> true
||                         -> already true, skip the rest
   { echo 'ERROR: failed to find "filename"' 1>&2 ; exit -1; }

2

[ -e filename ]          \ -> true
&& echo filename         \ -> true
||                         -> already true, skip the rest
   [ -e ../filename ]    \
&& echo ../filename      \
|| { echo 'ERROR: failed to find "filename"' 1>&2 ; exit -1; }

版本：

bash --version
GNU bash, version 4.4.12(1)-release (x86_64-pc-linux-gnu)
bash
Martin Hope
Zoltan K.
Asked: 2019-04-02 04:29:14 +0800 CST
  • 4

如果我bind()是一个AF_INET套接字（用于 TCP 连接），那么稍后close()，当我运行我的程序时，我可能会遇到问题，因为尽管有close()，内核仍然可以拥有与打开的套接字关联的资源。

不过，我对 Unix Domain Sockets 的这个问题不是很清楚。

到目前为止我见过

  1. 我需要一个独特的路径来使用它bind()。调用时路径必须不存在，bind()文件将由bind(). （但是，它可能在文件系统中可见也可能不可见。如果路径以特殊字符开头，则文件不会出现在文件系统中\0。）

  2. 如果文件不是unlink()-ed，即使在关闭之后，内核也会保留相关的资源，并且套接字是完全正常的。

问题：

由于任何一个close()或unlink()单独一个都不能使 Unix 域套接字消失，他们两个都会可靠地完成这个技巧/触发内核放弃与套接字相关的所有资源吗？

如果两者都被调用，我是否可能会遇到reuseaddr错误？close()unlink()

编辑（在评论和回答之后）：

因此，绑定的 AF_LOCAL 套接字看起来像这样：

unix_domain_socket_inode
-> binded to a socket
-> associated with a file (path)

unix_domain_socket_inode只要：

  1. 某些东西使它保持打开状态（套接字未关闭），或
  2. 它有关联的路径

如果只有 1. 为真，我们有一个打开的套接字和一个 inode，一切正常。

如果只有 2. 为真，因为 inode 有与之关联的路径，内核无法清理它，但它也不起作用，因为它缺少处理传入连接的套接字资源。它甚至不会是一个普通的文件，只是一个繁忙的工作套接字的过去荣耀的死壳。

在 AF_INET 连接的情况下，地址重用问题是提高可用性的设计选择。

在 AF_LOCAL 的情况下，剩余文件是先前设计选择的产物，这会阻止内核本身在调用时自动清理它在 1 go 中创建的文件close()。没有相关的隐藏机制，因此内核希望在close()调用 a 后保留此资源。

unix-sockets
Martin Hope
Zoltan K.
Asked: 2019-02-04 05:32:03 +0800 CST
  • 2

我想知道，如果分配的 tmpfs 空间多于物理内存 - 并且它们已被填满，会发生什么。

更详细：

假设我有 4GB RAM，4GB 交换空间。

mount -o size=4G -t tmpfs tmpfs /mnt1
mount -o size=4G -t tmpfs tmpfs /mnt2
mount -o size=4G -t tmpfs tmpfs /mnt3

据我了解，没有问题，因为这些设备实际上并没有分配它们从一开始就分配的内存。

现在我开始写这些：

cat /dev/zero >/mnt1/bla &
cat /dev/zero >/mnt2/bla &
cat /dev/zero >/mnt3/bla &

和...

问题：

我想知道，系统应该如何处理这个问题？

我没有在上面找到任何东西，但是当我多次挂载 tmpfs 时，我是在后台一遍又一遍地挂载同一个设备，还是创建了不同的、完全独立的设备实例？

我是否以某种方式阻止了我的系统崩溃，或者我可以自由地这样做吗？

在将 tmpfs 分配给 /tmp 时，我开始思考的根本原因：

  1. 一种方法是直接安装，
  2. 另一种是在/dev/shm创建一个文件，然后绑定挂载它。

如果没有限制分配 tmpfs 空间，2. - 绑定安装 - 如果我想广泛使用 tmpfs，但不想花太多时间思考我的行为的后果，这可能是一个本质上更安全的选择。

tmpfs