Linux のファイル記述子と例

かつて、インタビューで、ディスクの容量が不足したためにサービスが壊れているのを見つけたらどうしますか、と尋ねられたことがあります。

もちろん、私はこの場所が何をしているのか見て、可能であればその場所を掃除すると答えました。
次にインタビュアーは、パーティションに空き領域がなく、すべての領域を占有するファイルも表示されない場合はどうなるのかと尋ねました。

これに対して、たとえば lsof コマンドを使用して、いつでも開いているファイル記述子を確認でき、どのアプリケーションが利用可能なスペースをすべて占有しているかを把握でき、データが必要かどうかに応じて状況に応じて行動できると述べました。 。

インタビュアーは最後の言葉で私の話を遮り、さらに質問を加えました。「データは必要ないとします。これは単なるデバッグ ログですが、デバッグを書き込めないためアプリケーションがダウンしています。」

「わかりました」と私は答えました。「アプリケーション構成でデバッグをオフにして、再起動できます。」
面接官は「いいえ、アプリケーションを再起動することはできません。メモリには重要なデータがまだあり、重要なクライアントはサービス自体に接続されているため、強制的に再接続することはできません。」と反論しました。

「わかりました」と私は言いました。「アプリケーションを再起動できず、データを気にしない場合は、ls にファイルが表示されなくても、ファイル記述子を介してこの開いているファイルをクリアできます。」ファイル システム上のコマンドです。」

面接官は満足していましたが、私はそうではありませんでした。

そこで私は、なぜ私の知識をテストする人はさらに深く調べようとしないのかと考えました。 しかし、結局のところデータが重要である場合はどうなるでしょうか? プロセスを再起動できず、同時にこのプロセスが空き領域のないパーティション上のファイル システムに書き込みを行った場合はどうなるでしょうか? すでに書き込まれたデータだけでなく、このプロセスが書き込んでいる、または書き込もうとしているデータも失われないとしたらどうなるでしょうか?

トゥジク

私のキャリアの初めに、私はユーザーに関する情報を保存する必要がある小さなアプリケーションを作成しようとしていました。 そこで私は、どうすればユーザーとそのデータを照合できるだろうかと考えました。 たとえば、私にはイワノフ・イワン・イワノビッチがい​​て、彼はいくつかのデータを持っていますが、どうすれば彼らと友達になることができますか？ 「トゥジク」という名前の犬がこの同じイワンのものであることを直接指摘できます。 しかし、もし彼が名前を変えて、イワンではなく、例えばオーリヤになったらどうなるでしょうか？ その後、私たちのオリヤ・イワノフナ・イワノワはもう犬を飼っていないことが判明し、私たちのトゥジクは依然として存在しないイワンに属します。 データベースはこの問題の解決に役立ち、各ユーザーに一意の識別子 (ID) が与えられ、私の Tuzik はこの ID (実際には単なるシリアル番号) に関連付けられていました。 したがって、tuzik の所有者は ID 番号 2 を持ち、ある時点で Ivan がこの ID の下にあり、その後 Olya も同じ ID の下になりました。 人類と畜産の問題は実質的に解決されました。

ファイル記述子

ファイルとそのファイルを操作するプログラムの問題は、犬と人間の問題とほぼ同じです。 ivan.txt という名前のファイルを開いて、tuzik という単語を書き始めたものの、最初の文字「t」だけをファイルに書き込むことができ、このファイルの名前が誰かによって、たとえば olya.txt に変更されたとします。 しかし、ファイルは同じなので、エースをそこに書き込みたいと思っています。 システムコールでファイルを開くたびに 開いた どのプログラミング言語でも、ファイルを指す一意の ID を取得します。この ID がファイル記述子です。 そして、このファイルを次に誰が何をするかはまったく問題ではありません。削除することも、名前を変更することも、所有者を変更することも、読み取りと書き込みの権利を剥奪することもできます。私は引き続きそのファイルにアクセスできます。なぜなら、ファイルを開いた時点で、私はそのファイルを読み書きする権利を持っていて、なんとかそのファイルで作業を開始できたので、それを続けなければならないことを意味します。

Linux では、libc ライブラリは、実行中のアプリケーション (プロセス) ごとに、番号 3、0,1,2、XNUMX の XNUMX つの記述子ファイルを開きます。 詳細についてはリンクをご覧ください 男標準 и 男の標準出力

• ファイル記述子 0 は STDIN と呼ばれ、アプリケーション入力に関連付けられます。
• ファイル記述子 1 は STDOUT と呼ばれ、印刷コマンドなどの出力アプリケーションによって使用されます。
• ファイル記述子 2 は STDERR という名前で、アプリケーションがエラー メッセージを出力するために使用します。

プログラム内で読み取りまたは書き込みのためにファイルを開いた場合、おそらく最初の無料 ID が取得され、これが 3 番目になります。

PID がわかっている場合は、プロセスのファイル記述子のリストを表示できます。

たとえば、bash でコンソールを開いてプロセスの PID を確認してみましょう。

[user@localhost ]$ echo $$
15771

XNUMX 番目のコンソールで次を実行します。

[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

この記事の枠組み内では、番号 255 のファイル記述子は無視しても問題ありません。これは、リンクされたライブラリではなく、bash 自体によって必要に応じて開かれたものです。

これで、3 つの記述子ファイルすべてが擬似端末デバイスに関連付けられました。 / dev / ptsただし、たとえば XNUMX 番目のコンソールで実行するなど、引き続き操作できます。

[user@localhost ]$ echo "hello world" > /proc/15771/fd/0

そして最初のコンソールに表示されるのは、

[user@localhost ]$ hello world

リダイレクトとパイプ

これら 3 つの記述子ファイルは、bash を含む任意のプロセスで、たとえば XNUMX つのプロセスを接続するパイプ (パイプ) を通じて簡単にオーバーライドできます。

[user@localhost ]$ cat /dev/zero | sleep 10000

このコマンドは自分で実行できます strace -f 内部で何が起こっているのか見てみましょう。しかし、それは手短にします。

PID 15771 の親 bash プロセスはコマンドを解析し、実行するコマンドの数を正確に理解します。この場合、そのうちの 2 つは cat と sleep です。 Bash は、XNUMX つの子プロセスを作成し、それらを XNUMX つのパイプにマージする必要があることを認識しています。 合計すると、bash には XNUMX つの子プロセスと XNUMX つのパイプが必要になります。

子プロセスを作成する前に、bash はシステム コールを実行します。 パイプ そして、一時パイプバッファーで新しいファイル記述子を受け取りますが、このバッファーはまだ XNUMX つの子プロセスをいかなる方法でも接続していません。

親プロセスの場合、パイプはすでに存在しているように見えますが、子プロセスはまだありません。

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

次に、システムコールを使用して、 bash は XNUMX つの子プロセスを作成します。XNUMX つのプロセスは次のようになります。

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
PID    command
9004  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21
PID    command
9005  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21

clone はすべてのファイル記述子とともにプロセスを複製するため、それらは親プロセスと子プロセスで同じになることを忘れないでください。 PID 15771 の親プロセスのタスクは子プロセスを監視することなので、子プロセスからの応答を待つだけです。

したがって、パイプは必要なく、番号 3 と 4 でファイル記述子を閉じます。

PID 9004 の最初の bash 子プロセスでは、システム コール dup2は、STDOUT ファイル記述子の番号 1 を、パイプを指すファイル記述子に変更します。この場合は番号 3 です。したがって、PID 9004 の最初の子プロセスが STDOUT に書き込むものはすべて、自動的にパイプ バッファーに入ります。

PID 9005 の 2 番目の子プロセスでは、ファイルを STDIN 記述子番号 0 に bash dup9005s します。これで、PID XNUMX の XNUMX 番目の bash が読み取るものはすべてパイプから読み取られます。

その後、番号 3 と 4 のファイル記述子も使用されなくなったため、子プロセスで閉じられます。

ファイル記述子 255 は意図的に無視します。これは bash 自体によって内部的に使用され、子プロセスでも閉じられます。

次に、PID 9004 の最初の子プロセスで、bash がシステム コールで開始されます。 exec コマンドラインで指定した実行可能ファイル。この場合は /usr/bin/cat です。

PID 9005 の XNUMX 番目の子プロセスでは、bash は指定した XNUMX 番目の実行可能ファイル (この場合は /usr/bin/sleep) を実行します。

exec システム コールは、open 呼び出しの実行時に O_CLOEXEC フラグを使用してファイル記述子が開かれていない限り、ファイル記述子を閉じません。 この例では、実行可能ファイルを実行した後、現在のファイル記述子がすべて保存されます。

コンソールでチェックインすると、次のようになります。

[user@localhost ]$ pgrep -P 15771
9004
9005
[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
[user@localhost ]$ ls -lah /proc/9004/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
l-wx------ 1 user user 64 Oct  7 15:57 1 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lr-x------ 1 user user 64 Oct  7 15:57 3 -> /dev/zero
[user@localhost ]$ ls -lah /proc/9005/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lr-x------ 1 user user 64 Oct  7 15:57 0 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
[user@localhost ]$ ps -up 9004
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9004  0.0  0.0 107972   620 pts/21   S+   15:57   0:00 cat /dev/zero
[user@localhost ]$ ps -up 9005
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9005  0.0  0.0 107952   360 pts/21   S+   15:57   0:00 sleep 10000

ご覧のとおり、パイプの一意の番号は両方のプロセスで同じです。 したがって、同じ親を持つ XNUMX つの異なるプロセス間に接続が存在します。

bash が使用するシステム コールに詳しくない人には、次のように strace を通じてコマンドを実行し、内部で何が起こっているかを確認することを強くお勧めします。

strace -s 1024 -f bash -c "ls | grep hello"

ディスク容量が不足し、プロセスを再起動せずにデータを保存しようとする問題に戻りましょう。 1 秒あたり約 XNUMX メガバイトの速度でディスクに書き込む小さなプログラムを書いてみましょう。 さらに、何らかの理由でデータをディスクに書き込めなかった場合は、これを無視して、すぐに再度データの書き込みを試みます。 この例では Python を使用していますが、他のプログラミング言語を使用することもできます。

[user@localhost ]$ cat openforwrite.py 
import datetime
import time

mystr="a"*1024*1024+"n"
with open("123.txt", "w") as f:
    while True:
        try:
            f.write(str(datetime.datetime.now()))
            f.write(mystr)
            f.flush()
            time.sleep(1)
        except:
            pass

プログラムを実行してファイル記述子を確認します。

[user@localhost ]$ python openforwrite.py &
[1] 3762
[user@localhost ]$ ps axuf | grep [o]penforwrite
user  3762  0.0  0.0 128600  5744 pts/22   S+   16:28   0:00  |   _ python openforwrite.py
[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt

ご覧のとおり、3 つの標準ファイル記述子と、開いたもう XNUMX つのファイル記述子があります。 ファイルサイズを確認してみましょう。

[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 117M Oct  7 16:30 123.txt

データが書き込まれた後、ファイルに対する権限を変更しようとします。

[user@localhost ]$ sudo chown root: 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 168M Oct  7 16:31 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 172M Oct  7 16:31 123.txt

ユーザーにはファイルに書き込む権限がないにもかかわらず、データがまだ書き込まれていることがわかります。 それを削除してみましょう:

[user@localhost ]$ sudo rm 123.txt 
[user@localhost ]$ ls 123.txt
ls: cannot access 123.txt: No such file or directory

データはどこに書き込まれますか? そして、そもそもそれらは書かれていますか？ 私たちは以下をチェックします:

[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt (deleted)

はい、ファイル記述子はまだ存在しており、このファイル記述子を古いファイルと同様に操作でき、読み取り、クリーンアップ、コピーできます。

ファイルサイズを見てください:

[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5   19923457   2621522 /home/user/123.txt

ファイル サイズは 19923457 です。ファイルをクリアしようとしています:

[user@localhost ]$ truncate -s 0 /proc/31083/fd/3
[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5  136318390   2621522 /home/user/123.txt

ご覧のとおり、ファイル サイズは増加するだけで、トランクは機能しませんでした。 システムコールに関するドキュメントに移りましょう 開いた。 ファイルを開くときに O_APPEND フラグを使用すると、書き込みのたびに、オペレーティング システムがファイル サイズをチェックしてファイルの最後にデータを書き込み、それをアトミックに実行します。 これにより、複数のスレッドまたはプロセスが同じファイルに書き込むことができます。 ただし、コードではこのフラグを使用しません。 ファイルを書き込み用に開いた場合にのみ、trunk の後の lsof で異なるファイル サイズが確認できます。つまり、コードでは、

with open("123.txt", "w") as f:

私たちは置かなければなりません

with open("123.txt", "a") as f:

「w」フラグでチェックする

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3

そして「a」フラグ付き

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_APPEND, 0666) = 3

すでに実行中のプロセスをプログラミングする

多くの場合、プログラマはプログラムを作成およびテストするときに、デバッガ (GDB など) またはアプリケーションのさまざまなレベルのログを使用します。 Linux は、変数の値の変更、ブレークポイントの設定など、すでに実行中のプログラムを実際に作成および変更する機能を提供します。

ファイルを書き込むためのディスク領域の不足に関する最初の質問に戻って、問題をシミュレートしてみましょう。

パーティション用のファイルを作成して、別のドライブとしてマウントしましょう。

[user@localhost ~]$ dd if=/dev/zero of=~/tempfile_for_article.dd bs=1M count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00525929 s, 2.0 GB/s
[user@localhost ~]$

ファイルシステムを作成してみましょう。

[user@localhost ~]$ mkfs.ext4 ~/tempfile_for_article.dd
mke2fs 1.42.9 (28-Dec-2013)
/home/user/tempfile_for_article.dd is not a block special device.
Proceed anyway? (y,n) y
...
Writing superblocks and filesystem accounting information: done
[user@localhost ~]$

ファイルシステムをマウントしてみましょう。

[user@localhost ~]$ sudo mount ~/tempfile_for_article.dd /mnt/
[sudo] password for user: 
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  172K  7.9M   3% /mnt

所有者と一緒にディレクトリを作成します。

[user@localhost ~]$ sudo mkdir /mnt/logs
[user@localhost ~]$ sudo chown user: /mnt/logs

プログラム内でのみ書き込み用にファイルを開いてみましょう。

with open("/mnt/logs/123.txt", "w") as f:

打ち上げ

[user@localhost ]$ python openforwrite.py 

数秒待っています

[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

したがって、この記事の冒頭で説明した問題が発生しました。 空き容量 0、占有率 100%。

問題の状況に応じて、失うことができない非常に重要なデータを記録しようとしていることを思い出します。 その際、プロセスを再起動せずにサービスを修正する必要があります。

まだディスク領域があるが、別のパーティション、たとえば /home にあるとします。

コードを「オンザフライで再プログラム」してみましょう。

すべてのディスク容量を消費したプロセスの PID を確認します。

[user@localhost ~]$ ps axuf | grep [o]penfor
user 10078 27.2  0.0 128600  5744 pts/22   R+   11:06   0:02  |   _ python openforwrite.py

gdb を使用してプロセスに接続する

[user@localhost ~]$ gdb -p 10078
...
(gdb) 

開いているファイル記述子を見てみましょう。

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt

興味のある番号 3 のファイル記述子に関する情報を調べます。

(gdb) shell cat /proc/10078/fdinfo/3
pos:    8189952
flags:  0100001
mnt_id: 482

Python がどのようなシステム コールを行うかを念頭に置き (上記の strace を実行してオープン コールを見つけたところを参照)、コードを処理してファイルを開くときに、プロセスに代わって自分たちでも同じことを行いますが、O_WRONLY|O_CREAT| が必要です。 O_TRUNC ビットは数値に置き換えられます。 これを行うには、次のようなカーネル ソースを開きます。 ここで どのフラグが何を担当しているかを確認します

#define O_WRONLY 00000001
#define O_CREAT 00000100
#define O_TRUNC 00001000

すべての値を 00001101 つに結合すると、XNUMX が得られます

gdb から呼び出しを実行する

(gdb) call open("/home/user/123.txt", 00001101,0666)
$1 = 4

したがって、番号 4 の新しいファイル記述子と、別のパーティションに新しい開いているファイルを取得しました。次を確認してください。

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

私たちはパイプを使った例、つまり bash がファイル記述子を変更する方法を覚えており、dup2 システムコールについてはすでに学習しています。

あるファイル記述子を別のファイル記述子に置き換えようとしています

(gdb) call dup2(4,3)
$2 = 3

私たちはチェックします：

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /home/user/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

ファイル記述子 4 は必要ないので閉じます。

(gdb) call close (4)
$1 = 0

そしてgdbを終了します

(gdb) quit
A debugging session is active.

    Inferior 1 [process 10078] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 10078

新しいファイルを確認する:

[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 5.1M Oct  8 11:18 /home/user/123.txt
[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 7.1M Oct  8 11:18 /home/user/123.txt

ご覧のとおり、データは新しいファイルに書き込まれます。古いファイルを確認します。

[user@localhost ~]$ ls -lah /mnt/logs/123.txt 
-rw-rw-r-- 1 user user 7.9M Oct  8 11:08 /mnt/logs/123.txt

データは失われず、アプリケーションは動作し、ログは新しい場所に書き込まれます。

物事をもう少し難しくしましょう

データは重要ですが、どのパーティションにもディスク容量がなく、ディスクに接続できないと想像してください。

私たちができることは、データをパイプなどのどこかにリダイレクトし、netcat などのプログラムを通じてパイプからネットワークにデータをリダイレクトすることです。
mkfifo コマンドを使用して名前付きパイプを作成できます。 ファイル システムに空き領域がない場合でも、ファイル システム上に疑似ファイルが作成されます。

アプリケーションを再起動して、次のことを確認します。

[user@localhost ]$ python openforwrite.py 
[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 72.9  0.0 128600  5744 pts/22   R+   11:27   0:20  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

ディスク領域はありませんが、そこに名前付きパイプを正常に作成できます。

[user@localhost ~]$ mkfifo /mnt/logs/megapipe
[user@localhost ~]$ ls -lah /mnt/logs/megapipe 
prw-rw-r-- 1 user user 0 Oct  8 11:28 /mnt/logs/megapipe

次に、このパイプに入るすべてのデータを何らかの方法でネットワーク経由で別のサーバーにラップする必要があります。これには同じ netcat が適しています。

Remote-server.example.com サーバーで、次を実行します。

[user@localhost ~]$ nc -l 7777 > 123.txt 

問題のサーバー上で、別のターミナルで実行します。

[user@localhost ~]$ nc remote-server.example.com 7777 < /mnt/logs/megapipe 

これで、パイプに入るすべてのデータは自動的に netcat の stdin に送られ、ポート 7777 でネットワークに送信されます。

私たちがしなければならないのは、この名前付きパイプへのデータの書き込みを開始することだけです。

すでに実行中のアプリケーションがあります。

[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 99.8  0.0 128600  5744 pts/22   R+   11:27 169:27  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt

ファイルはすでに存在しており、クリアする必要がないため、すべてのフラグのうち O_WRONLY のみが必要です。

[user@localhost ~]$ gdb -p 5946
...
(gdb) call open("/mnt/logs/megapipe", 00000001,0666)
$1 = 4
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call dup2(4,3)
$2 = 3
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call close(4)
$3 = 0
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
(gdb) quit
A debugging session is active.

    Inferior 1 [process 5946] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 5946

リモートサーバーremote-server.example.comの確認

[user@localhost ~]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 38M Oct  8 14:21 123.txt

データが来ています。問題のあるサーバーを確認します

[user@localhost ~]$ ls -lah /mnt/logs/
total 7.9M
drwxr-xr-x 2 user user 1.0K Oct  8 11:28 .
drwxr-xr-x 4 root     root     1.0K Oct  8 10:55 ..
-rw-rw-r-- 1 user user 7.9M Oct  8 14:17 123.txt
prw-rw-r-- 1 user user    0 Oct  8 14:22 megapipe

データが保存され、問題が解決されました。

この機会を利用して、Degiro の同僚にご挨拶させていただきます。
Radio-T ポッドキャストを聞いてください。

すべて良いです。

宿題として、次のコマンドを実行した場合に cat プロセスと sleep プロセスのファイル記述子に何が含まれるかを考えてみることを提案します。

[user@localhost ~]$ cat /dev/zero 2>/dev/null| sleep 10000

出所： habr.com