[OSTEP] 39. Files and Directories

1. 파일과 디렉터리#

파일 시스템은 저장 장치를 다루기 위해 두 가지 핵심 추상화를 제공합니다.

1. 파일(File)
   읽고 쓸 수 있는 바이트의 선형 배열입니다. 각 파일은 저수준 이름인 inode 번호(i-number) 를 갖습니다. 운영체제는 파일이 텍스트인지 이미지인지 같은 의미를 해석하지 않고, 단지 바이트를 저장하고 다시 돌려주는 역할을 수행합니다.

2. 디렉터리(Directory)
   사용자 친화적 이름을 inode 번호에 매핑하는 (이름, inode 번호) 목록을 담는 특수한 파일입니다. 디렉터리도 inode 번호를 가지며, 디렉터리 안의 엔트리는 파일 또는 다른 디렉터리를 가리킵니다. 이 엔트리들이 연결되어 전체 디렉터리 트리(계층)를 이룹니다.

확장자 .c, .jpg 같은 표기는 관례에 가깝고, 파일 시스템이 강제하지 않는 경우가 일반적입니다.

2. 파일 생성과 입출력#

1
#include <fcntl.h>
2
#include <sys/stat.h>
3
#include <unistd.h>
4

5
int fd = open("foo",
6
              O_CREAT | O_WRONLY | O_TRUNC,
7
              S_IRUSR | S_IWUSR);
8
if (fd < 0) {
9
    /* error handling */
10
}

1
strace -o trace.txt cat foo

1
#include <sys/types.h>
2
#include <unistd.h>
3

4
off_t off = lseek(fd, 0, SEEK_END);
5
if (off == (off_t) -1) {
6
    /* error handling */
7
}

3. 열린 파일 엔트리 공유: fork와 dup#

오픈 파일 테이블 엔트리는 상황에 따라 공유될 수 있습니다. 이때 핵심은 오프셋도 함께 공유된다는 점입니다.

1
#include <assert.h>
2
#include <fcntl.h>
3
#include <stdio.h>
4
#include <sys/types.h>
5
#include <sys/wait.h>
6
#include <unistd.h>
7

8
int main(void) {
9
    int fd = open("shared.txt", O_RDONLY);
10
    assert(fd >= 0);
11

12
    pid_t pid = fork();
13
    assert(pid >= 0);
14

15
    if (pid == 0) {
16
        /* child: advance the shared offset */
17
        off_t off = lseek(fd, 10, SEEK_SET);
18
        assert(off == 10);
19
        _exit(0);
20
    } else {
21
        wait(NULL);
22

23
        /* parent: offset was changed by the child */
24
        off_t off = lseek(fd, 0, SEEK_CUR);
25
        printf("offset=%lld\n", (long long) off);
26
        close(fd);
27
    }
28
    return 0;
29
}

1
#include <assert.h>
2
#include <fcntl.h>
3
#include <stdio.h>
4
#include <unistd.h>
5

6
int main(void) {
7
    int fd1 = open("shared.txt", O_RDONLY);
8
    assert(fd1 >= 0);
9

10
    int fd2 = dup(fd1);
11
    assert(fd2 >= 0);
12

13
    /* advance offset via fd1 */
14
    off_t a = lseek(fd1, 5, SEEK_SET);
15
    assert(a == 5);
16

17
    /* observe the same offset via fd2 */
18
    off_t b = lseek(fd2, 0, SEEK_CUR);
19
    printf("offset(fd2)=%lld\n", (long long) b);
20

21
    close(fd2);
22
    close(fd1);
23
    return 0;
24
}

4. 영속성 보장: fsync#

write()가 즉시 저장 장치에 기록되는 것은 아닙니다. 일반적으로 파일 시스템은 성능을 위해 쓰기를 메모리에 버퍼링한 뒤 나중에 내려씁니다.

즉각적인 영속성이 필요하면 fsync(fd)를 사용합니다.

1
int fd = open("foo",
2
              O_CREAT | O_WRONLY | O_TRUNC,
3
              S_IRUSR | S_IWUSR);
4

5
write(fd, buffer, size);
6
fsync(fd);
7
close(fd);

여기서 자주 빠뜨리는 디테일이 하나 더 있습니다.

• 새 파일 생성, 이름 변경 등으로 디렉터리 엔트리가 바뀌면, 파일 내용만 fsync(fd) 해서는 부족할 수 있습니다.
• 이름이 들어 있는 디렉터리 자체도 fsync해야, 그 이름 변경이 영속적으로 반영되는 경우가 있습니다.

즉, 데이터와 메타데이터를 함께 영속화하려면 파일과 디렉터리까지 포함해 순서를 설계해야 합니다.

5. 이름 변경과 원자성: rename#

mv는 내부적으로 rename(old, new)를 사용합니다.

1
#include <stdio.h>
2

3
int rc = rename("old_name", "new_name");
4
if (rc != 0) {
5
    /* error handling */
6
}

rename()은 보통 크래시에 대해 원자적으로 구현됩니다. 크래시가 나더라도 이름은 old 또는 new 중 하나로 남고, 중간 상태가 나타나지 않는다는 성질을 기대할 수 있습니다.

이 성질을 이용한 고전적 패턴이 있습니다. 파일을 안전하게 갱신할 때는 다음처럼 합니다.

1
#include <fcntl.h>
2
#include <sys/stat.h>
3
#include <unistd.h>
4

5
int fd = open("foo.txt.tmp",
6
              O_WRONLY | O_CREAT | O_TRUNC,
7
              S_IRUSR | S_IWUSR);
8

9
write(fd, buffer, size);
10
fsync(fd);
11
close(fd);
12

13
/* atomic name swap */
14
rename("foo.txt.tmp", "foo.txt");
15

16
/* for full durability, fsync the directory that contains foo.txt */

추가로 기억할 점도 있습니다.

• rename()은 같은 파일 시스템 내부에서의 원자적 변경을 전제로 합니다.
• 서로 다른 파일 시스템 간 이동은 복사 후 삭제로 구현되는 경우가 많고, 동일한 원자성을 기대하기 어렵습니다.

6. 메타데이터 읽기: stat#

파일의 내용 외에 크기, 권한, 소유자, 링크 수, 시간 정보 같은 것은 메타데이터입니다. 유닉스 계열에서는 stat()/fstat()로 조회합니다.

1
#include <stdio.h>
2
#include <sys/stat.h>
3

4
int main(void) {
5
    struct stat sb;
6
    if (stat("foo.txt", &sb) != 0) {
7
        return 1;
8
    }
9

10
    printf("size=%lld\n", (long long) sb.st_size);
11
    printf("inode=%lld\n", (long long) sb.st_ino);
12
    printf("nlink=%lld\n", (long long) sb.st_nlink);
13
    printf("mode=%o\n", (unsigned) sb.st_mode);
14

15
    return 0;
16
}

Figure 39.5는 struct stat의 대표 필드들을 보여줍니다. 플랫폼마다 필드 구성이 조금씩 다를 수 있지만, 핵심은 비슷합니다.

1
/* simplified view of struct stat (fields vary by platform) */
2
struct stat {
3
    dev_t     st_dev;     /* ID of device containing file */
4
    ino_t     st_ino;     /* inode number */
5
    mode_t    st_mode;    /* file type + permission bits */
6
    nlink_t   st_nlink;   /* hard link count */
7
    uid_t     st_uid;     /* user ID of owner */
8
    gid_t     st_gid;     /* group ID of owner */
9
    off_t     st_size;    /* total size, bytes */
10
    time_t    st_atime;   /* last access time */
11
    time_t    st_mtime;   /* last modification time */
12
    time_t    st_ctime;   /* last status change time */
13
};

7. 파일 삭제가 unlink인 이유#

유닉스에서 파일 삭제는 delete()가 아니라 unlink(path)입니다. 이유는 파일이 실제로는 두 가지로 구성되기 때문입니다.

• inode: 파일 메타데이터와 데이터 블록을 가리키는 저수준 구조
• 디렉터리 엔트리: 사람이 읽는 이름을 inode 번호에 연결하는 링크

즉 삭제는 이름과 inode의 연결을 끊는 작업이며, 그래서 unlink입니다.

1
ln file file2

8. 디렉터리 API#

1
#include <dirent.h>
2
#include <stdio.h>
3

4
int main(void) {
5
    DIR *dp = opendir(".");
6
    if (!dp) return 1;
7

8
    struct dirent *d;
9
    while ((d = readdir(dp)) != NULL) {
10
        printf("%lu %s\n",
11
               (unsigned long) d->d_ino,
12
               d->d_name);
13
    }
14
    closedir(dp);
15
    return 0;
16
}

9. 심볼릭 링크#

심볼릭 링크는 하드 링크의 제약을 풀기 위해 도입된 별도 파일 타입입니다.

• 심볼릭 링크 자체가 inode를 가지는 파일입니다.
• 링크 파일의 내용으로 대상 경로 문자열을 저장합니다.
• 대상이 삭제되면 링크는 깨진 경로를 가리키는 dangling 상태가 됩니다.

하드 링크는 일반적으로 다음 제약이 있습니다.

• 디렉터리에 하드 링크를 만들 수 없음(디렉터리 트리에 사이클이 생길 위험)
• 다른 파일 시스템 파티션을 가로질러 하드 링크를 만들 수 없음(inode 번호는 파일 시스템 내부에서만 유일)

심볼릭 링크는 이런 제약을 피해갈 수 있지만, 대신 dangling 문제를 갖습니다.

10. 권한 비트와 ACL#

유닉스는 파일을 공유하는 시스템이므로 접근 제어가 필요합니다.

11. 파일 시스템 만들기와 마운트#

디스크 파티션을 파일 시스템으로 초기화하려면 mkfs 계열 도구를 사용합니다. 그리고 그 파일 시스템을 현재 디렉터리 트리의 한 지점에 붙이는 작업이 mount입니다.

1
mount -t ext3 /dev/sda1 /home/users

마운트 이후에는 /home/users가 새 파일 시스템의 루트가 됩니다. 이 방식 덕분에 여러 종류의 파일 시스템(ext 계열, proc, sysfs, tmpfs, 네트워크 FS 등)을 하나의 트리로 통합해 일관된 이름 체계를 제공합니다.

12. 보안 관점 덤: TOCTTOU#

파일을 검사한 뒤 사용하기까지 시간 간격이 있으면, 그 사이 공격자가 대상을 바꿔치기할 수 있습니다. 이를 TOCTTOU(time of check to time of use) 문제라고 부릅니다.

파일을 열 때 플래그를 적절히 사용하고, 가능하면 경로 기반 검사보다 fd 기반 검사를 선호하는 방식으로 위험을 줄일 수 있습니다.

13. 요약#

• 파일은 바이트 배열이며, 저수준 이름으로 inode 번호를 갖습니다.
• 디렉터리는 (이름, inode 번호) 매핑 목록이며 트리를 이룹니다.
• fd는 프로세스별 핸들이고, 커널의 오픈 파일 테이블 엔트리를 가리킵니다. 오프셋은 그 엔트리에 저장됩니다.
• fork()와 dup()는 오픈 파일 테이블 엔트리를 공유하여 오프셋도 공유합니다.
• fsync()는 영속성을 강제하지만, 디렉터리까지 포함해 올바르게 쓰는 것이 중요합니다.
• rename()은 원자적 교체 패턴의 핵심 빌딩 블록입니다.
• unlink()는 이름과 inode의 연결을 끊는 호출이며, 링크 카운트가 0이 될 때 실제 해제가 발생합니다.
• 권한 비트와 ACL은 공유 환경에서 접근 제어를 제공합니다.
• mkfs와 mount는 여러 파일 시스템을 하나의 트리로 합칩니다.

다음 장부터는 이런 추상화가 디스크 위에 어떻게 구현되는지(VSFS 등)를 살펴봅니다.

14. 용어 정리#

• inode (i-number): 파일의 메타데이터와 데이터 블록 위치를 담는 영속 구조
• file descriptor (fd): 열린 파일을 가리키는 프로세스별 정수 핸들
• open file table: 열린 파일의 상태(오프셋, 권한, 참조 카운트 등)를 추적하는 커널 자료구조
• offset: 다음 read/write가 시작될 파일 내 위치
• lseek: 오프셋을 재설정하는 시스템 콜(자체로 디스크 I/O를 수행하지 않음)
• unlink: 디렉터리 엔트리를 제거해 이름과 inode의 연결을 끊는 시스템 콜
• hard link: 동일 inode를 가리키는 또 다른 이름
• symbolic link: 경로 문자열을 담는 별도 파일 타입의 링크
• fsync: 더티 데이터를 저장 장치로 강제 플러시하는 시스템 콜
• rename: 크래시에 대해 원자적으로 이름을 교체하는 시스템 콜
• mkfs, mount: 파일 시스템 생성과 트리 결합

Reference#

• Operating Systems: Three Easy Pieces - Chapter 39: Interlude: Files and Directories