예제가 포함된 Linux의 파일 설명자

한 번은 인터뷰 중에 디스크 공간 부족으로 인해 서비스가 작동하지 않는 경우 어떻게 하시겠습니까?라는 질문을 받았습니다.

물론 나는 이곳이 무엇을 차지하고 있는지 확인하고 가능하다면 그곳을 청소하겠다고 대답했습니다.
그런 다음 면접관은 파티션에 여유 공간이 없는데 공간을 모두 차지하는 파일이 표시되지 않으면 어떻게 되는지 물었습니다.

이에 대해 나는 항상 예를 ​​들어 lsof 명령을 사용하여 열린 파일 설명자를 보고 어떤 응용 프로그램이 사용 가능한 모든 공간을 차지했는지 이해한 다음 데이터가 필요한지 여부에 따라 상황에 따라 조치를 취할 수 있다고 말했습니다. .

면접관은 마지막 말에서 내 말을 가로막고 다음과 같은 질문을 덧붙였습니다. "데이터가 필요하지 않고 디버그 로그일 뿐인데 디버그를 작성할 수 없기 때문에 애플리케이션이 작동하지 않는다고 가정해 보겠습니다."

“알겠습니다. 애플리케이션 구성에서 디버그를 끄고 다시 시작하면 됩니다.”라고 나는 대답했습니다.
면접관은 다음과 같이 이의를 제기했습니다. "아니요. 애플리케이션을 다시 시작할 수 없습니다. 중요한 데이터는 여전히 메모리에 저장되어 있으며 중요한 클라이언트는 서비스 자체에 연결되어 있으므로 강제로 다시 연결할 수 없습니다."

“알겠습니다. 애플리케이션을 다시 시작할 수 없고 데이터가 우리에게 중요하지 않다면, ls 명령에서 볼 수 없더라도 파일 설명자를 통해 이 열린 파일을 간단히 지울 수 있습니다. 파일 시스템에 있습니다.”

면접관은 만족했지만 나는 그렇지 않았다.

그렇다면 내 지식을 시험하는 사람은 왜 더 깊이 파고들지 않는 걸까? 하지만 결국 데이터가 중요하다면 어떨까요? 프로세스를 다시 시작할 수 없고 프로세스가 여유 공간이 없는 파티션의 파일 시스템에 쓰는 경우 어떻게 됩니까? 이미 쓰여진 데이터뿐만 아니라 이 프로세스가 쓰거나 쓰려고 하는 데이터도 잃을 수 없다면 어떨까요?

투 익크

경력 초기에 저는 사용자 정보를 저장하는 데 필요한 작은 애플리케이션을 만들려고 했습니다. 그리고 나서 저는 어떻게 사용자를 그의 데이터와 일치시킬 수 있을지 생각했습니다. 예를 들어, Ivanov Ivan Ivanovich가 있고 그는 몇 가지 정보를 가지고 있지만 어떻게 그들과 친구가 될 수 있습니까? 나는 "Tuzik"이라는 개가 바로 이 Ivan의 소유라는 것을 직접적으로 지적할 수 있습니다. 그러나 그가 이름을 바꾸고 Ivan 대신 Olya가 된다면 어떻게 될까요? 그러면 우리 Olya Ivanovna Ivanova는 더 이상 개를 갖지 않을 것이며 우리 Tuzik은 여전히 ​​존재하지 않는 Ivan에 속할 것입니다. 각 사용자에게 고유한 식별자(ID)를 부여한 데이터베이스가 이 문제를 해결하는 데 도움이 되었고, 내 Tuzik은 실제로 일련번호에 불과한 이 ID에 연결되었습니다. 따라서 에이스의 소유자는 ID 번호 2를 가지고 있었고 어느 ​​시점에서 Ivan은 이 ID에 속했고 Olya는 동일한 ID에 속하게 되었습니다. 인류와 축산업의 문제는 실질적으로 해결되었습니다.

파일 설명자

파일의 문제와 이 파일을 사용하는 프로그램의 문제는 우리 개와 사람의 문제와 거의 같습니다. ivan.txt라는 파일을 열고 tuzik이라는 단어를 쓰기 시작했지만 파일에 첫 글자 "t"만 썼고 이 파일의 이름이 누군가에 의해 olya.txt로 바뀌었다고 가정해 보겠습니다. 하지만 파일은 그대로 남아 있고, 여전히 그 파일에 내 에이스를 기록하고 싶습니다. 시스템 호출로 파일을 열 때마다 열 수 어떤 프로그래밍 언어에서든 파일을 가리키는 고유 ID를 받습니다. 이 ID는 파일 설명자입니다. 다음에 이 파일을 어떻게, 누가 처리하는지 전혀 중요하지 않습니다. 파일을 삭제할 수도 있고, 이름을 바꿀 수도 있고, 소유자를 변경할 수도 있고, 읽기 및 쓰기 권한을 박탈할 수도 있습니다. 여전히 액세스할 수 있습니다. 파일을 열 때 파일을 읽거나 쓸 수 있는 권한이 있었고 작업을 시작할 수 있었기 때문에 계속해서 작업을 수행해야 합니다.

Linux에서 libc 라이브러리는 실행 중인 각 애플리케이션(프로세스)에 대해 번호가 3인 0,1,2개의 설명자 파일을 엽니다. 더 많은 정보는 링크에서 확인하실 수 있습니다 남자 스튜디오 и 남자 표준 출력

• 파일 설명자 0은 STDIN이라고 하며 응용 프로그램 입력과 연결됩니다.
• 파일 설명자 1은 STDOUT이라고 하며 응용 프로그램에서 인쇄 명령과 같은 데이터를 출력하는 데 사용됩니다.
• 파일 설명자 2는 STDERR이라고 하며 응용 프로그램에서 오류 메시지를 출력하는 데 사용됩니다.

프로그램에서 읽거나 쓰기 위해 파일을 여는 경우 첫 번째 무료 ID를 얻게 되며 번호 3이 됩니다.

PID를 아는 경우 모든 프로세스에 대한 파일 설명자 목록을 볼 수 있습니다.

예를 들어 bash 콘솔을 열고 프로세스의 PID를 살펴보겠습니다.

[user@localhost ]$ echo $$
15771

두 번째 콘솔에서 다음을 실행해 보겠습니다.

[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하지만 여전히 조작할 수 있습니다. 예를 들어 두 번째 콘솔에서 실행합니다.

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

그리고 첫 번째 콘솔에서 우리는 볼 수 있습니다

[user@localhost ]$ hello world

리디렉션 및 파이프

예를 들어 두 프로세스를 연결하는 파이프를 통해 bash를 포함한 모든 프로세스에서 이러한 3개의 설명자 파일을 쉽게 재정의할 수 있습니다.

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

다음을 사용하여 이 명령을 직접 실행할 수 있습니다. 추적 -f 내부에서 무슨 일이 일어나고 있는지 알아보겠습니다. 간략하게 말씀 드리겠습니다.

PID 15771을 사용하는 상위 bash 프로세스는 명령을 구문 분석하고 실행하려는 명령 수를 정확히 이해합니다. 우리의 경우에는 cat과 sleep이라는 두 가지 명령이 있습니다. Bash는 두 개의 하위 프로세스를 생성하고 이를 하나의 파이프로 병합해야 한다는 것을 알고 있습니다. 전체적으로 bash에는 2개의 하위 프로세스와 XNUMX개의 파이프가 필요합니다.

Bash는 하위 프로세스를 생성하기 전에 시스템 호출을 실행합니다. 파이프 임시 파이프 버퍼에서 새 파일 설명자를 수신하지만 이 버퍼는 아직 두 하위 프로세스를 연결하지 않습니다.

상위 프로세스의 경우 이미 파이프가 있는 것처럼 보이지만 아직 하위 프로세스는 없습니다.

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는 두 개의 하위 프로세스를 생성하며 세 가지 프로세스는 다음과 같습니다.

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 프로세스에서 시스템 호출 듀2, STDOUT 파일 설명자 번호 1을 파이프를 가리키는 파일 설명자로 변경합니다. 이 경우에는 번호 3입니다. 따라서 PID 9004를 사용하는 첫 번째 하위 프로세스가 STDOUT에 쓰는 모든 내용은 자동으로 파이프 버퍼에 저장됩니다.

PID 9005의 두 번째 하위 프로세스에서 bash는 dup2를 사용하여 파일 설명자 STDIN 번호 0을 변경합니다. 이제 PID 9005의 두 번째 bash가 읽을 모든 내용은 파이프에서 읽혀집니다.

그 후에는 3번과 4번 파일 설명자가 더 이상 사용되지 않으므로 하위 프로세스에서도 닫힙니다.

파일 설명자 255는 의도적으로 무시합니다. 이는 bash 자체에서 내부 목적으로 사용되며 하위 프로세스에서도 닫힙니다.

다음으로, PID 9004를 가진 첫 번째 하위 프로세스에서 bash는 시스템 호출을 사용하여 시작합니다. 임원 명령줄에서 지정한 실행 파일입니다. 이 경우에는 /usr/bin/cat입니다.

PID가 9005인 두 번째 하위 프로세스에서 bash는 우리가 지정한 두 번째 실행 파일(이 경우 /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

보시다시피, 우리 파이프의 고유 번호는 두 프로세스 모두 동일합니다. 따라서 우리는 동일한 부모를 가진 두 개의 다른 프로세스 사이에 연결이 있습니다.

Bash가 사용하는 시스템 호출에 익숙하지 않은 분들을 위해 strace를 통해 명령을 실행하고 내부적으로 무슨 일이 일어나고 있는지 확인하는 것이 좋습니다. 예를 들면 다음과 같습니다.

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

디스크 공간이 부족하고 프로세스를 다시 시작하지 않고 데이터를 저장하려고 하는 문제로 돌아가 보겠습니다. 초당 약 1MB를 디스크에 쓰는 작은 프로그램을 작성해 보겠습니다. 또한 어떤 이유로 디스크에 데이터를 쓸 수 없는 경우 이를 무시하고 잠시 후에 다시 데이터 쓰기를 시도합니다. 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개의 표준 파일 설명자와 우리가 열었던 하나를 더 가지고 있습니다. 파일 크기를 확인해 보겠습니다.

[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 플래그를 사용하면 각 쓰기마다 운영 체제가 파일 크기를 확인하고 파일의 맨 끝에 데이터를 쓰며 이를 원자적으로 수행합니다. 이를 통해 여러 스레드나 프로세스가 동일한 파일에 쓸 수 있습니다. 하지만 우리 코드에서는 이 플래그를 사용하지 않습니다. 추가 쓰기를 위해 파일을 여는 경우에만 트렁크 이후 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 비트는 숫자 값으로 대체됩니다. 이렇게 하려면 커널 소스를 엽니다. 예를 들어 여기에 어떤 플래그가 무엇을 담당하는지 살펴보세요.

#O_WRONLY 00000001 정의
#O_CREAT 00000100 정의
#O_TRUNC 00001000 정의

모든 값을 하나로 결합하면 00001101을 얻습니다.

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

원격서버 원격서버.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