🖥️ 시스템 콜과 저수준 파일 I/O의 세계로 떠나는 모험! 🚀

안녕하세요, 프로그래밍 탐험가 여러분! 오늘 우리는 C 언어의 심장부로 들어가는 흥미진진한 여행을 떠나볼 거예요. 우리의 목적지는 바로 '시스템 콜'과 '저수준 파일 I/O'라는 신비로운 영역입니다. 이 여행을 통해 여러분은 컴퓨터의 깊은 곳에서 일어나는 마법 같은 일들을 이해하게 될 거예요. 😉

여러분, 혹시 재능넷(https://www.jaenung.net)이라는 재능 공유 플랫폼을 들어보셨나요? 이곳에서는 다양한 프로그래밍 지식을 공유하고 있답니다. 오늘 우리가 배울 내용도 재능넷의 '지식인의 숲' 메뉴에서 찾아볼 수 있을 거예요. 자, 이제 우리의 모험을 시작해볼까요? 🌟

🔍 시스템 콜: 운영체제와의 대화

먼저, '시스템 콜'이 무엇인지 알아볼까요? 시스템 콜은 우리의 프로그램이 운영체제와 대화하는 방법이에요. 마치 우리가 음식점에서 웨이터에게 주문을 하는 것처럼, 프로그램은 시스템 콜을 통해 운영체제에게 특별한 요청을 합니다.

시스템 콜은 다양한 종류가 있어요. 파일을 열거나 닫는 것, 메모리를 할당하는 것, 네트워크 통신을 하는 것 등 모두 시스템 콜을 통해 이루어집니다. 이제 우리가 주목할 것은 파일 관련 시스템 콜이에요.

📁 파일 관련 주요 시스템 콜

• open(): 파일을 열어요. 마치 책을 펴는 것과 같죠.
• read(): 파일에서 데이터를 읽어요. 책의 내용을 읽는 것과 비슷해요.
• write(): 파일에 데이터를 써요. 책에 메모를 하는 것과 같아요.
• close(): 파일을 닫아요. 다 읽은 책을 덮는 것과 같죠.

이 시스템 콜들은 C 언어에서 저수준 파일 I/O 함수로 제공됩니다. 이들은 운영체제와 직접 대화하기 때문에 '저수준'이라고 불려요. 마치 통역사 없이 외국인과 직접 대화하는 것과 같죠!

이 그림에서 볼 수 있듯이, 프로그램은 시스템 콜을 통해 운영체제에 요청을 보내고, 운영체제는 그 요청을 처리한 후 결과를 프로그램에 반환합니다. 이것이 바로 시스템 콜의 기본 작동 원리예요!

자, 이제 우리는 시스템 콜이 무엇인지, 그리고 어떻게 작동하는지 기본적인 이해를 했어요. 다음으로, 이 시스템 콜을 이용해 실제로 파일을 다루는 방법, 즉 저수준 파일 I/O에 대해 자세히 알아보도록 할까요? 🚀

📂 저수준 파일 I/O: 파일과의 직접 대화

저수준 파일 I/O는 마치 우리가 직접 파일과 대화를 나누는 것과 같아요. 고수준 I/O 함수들(예: fopen(), fclose(), fprintf(), fscanf() 등)과는 달리, 저수준 I/O 함수들은 운영체제와 더 가깝게 작동합니다. 이는 마치 통역사 없이 외국인과 직접 대화하는 것과 비슷하죠. 어렵지만, 더 빠르고 효율적일 수 있어요!

자, 이제 저수준 파일 I/O의 주요 함수들을 하나씩 살펴볼까요? 이 함수들은 마치 우리가 파일이라는 보물상자를 다루는 열쇠와 같아요! 🗝️

1. open() 함수: 파일 열기 🚪

int open(const char *pathname, int flags, mode_t mode);

open() 함수는 파일을 여는 데 사용됩니다. 마치 문을 열고 방에 들어가는 것과 같죠!

• pathname: 열고자 하는 파일의 경로
• flags: 파일을 어떻게 열 것인지 지정 (읽기 전용, 쓰기 전용, 읽기/쓰기 등)
• mode: 새 파일을 만들 때 사용되는 권한 설정

open() 함수는 성공하면 파일 디스크립터라는 정수값을 반환합니다. 이 값은 앞으로 이 파일을 가리키는 '손잡이' 역할을 하게 됩니다.

2. read() 함수: 파일 읽기 📖

ssize_t read(int fd, void *buf, size_t count);

read() 함수는 파일에서 데이터를 읽어옵니다. 마치 책의 내용을 읽는 것과 같아요!

• fd: 파일 디스크립터 (open()으로 얻은 값)
• buf: 읽은 데이터를 저장할 버퍼
• count: 읽고자 하는 바이트 수

read() 함수는 실제로 읽은 바이트 수를 반환합니다. 파일의 끝에 도달하면 0을, 오류가 발생하면 -1을 반환해요.

3. write() 함수: 파일 쓰기 ✍️

ssize_t write(int fd, const void *buf, size_t count);

write() 함수는 파일에 데이터를 씁니다. 책에 새로운 내용을 적는 것과 같죠!

• fd: 파일 디스크립터
• buf: 쓰고자 하는 데이터가 있는 버퍼
• count: 쓰고자 하는 바이트 수

write() 함수는 실제로 쓴 바이트 수를 반환합니다. 오류가 발생하면 -1을 반환해요.

4. close() 함수: 파일 닫기 🚪

int close(int fd);

close() 함수는 열린 파일을 닫습니다. 다 읽은 책을 덮는 것과 같아요!

• fd: 닫고자 하는 파일의 파일 디스크립터

close() 함수는 성공하면 0을, 실패하면 -1을 반환합니다.

이 네 가지 함수가 저수준 파일 I/O의 핵심이에요. 이들을 잘 사용하면, 여러분은 파일을 자유자재로 다룰 수 있게 될 거예요! 😊

이 그림은 저수준 파일 I/O의 전체적인 흐름을 보여줍니다. open()으로 시작해서, read()와 write()로 파일을 조작하고, 마지막으로 close()로 마무리하는 과정을 볼 수 있어요.

자, 이제 우리는 저수준 파일 I/O의 기본 함수들을 알아봤어요. 하지만 이것만으로는 부족해요. 이 함수들을 실제로 어떻게 사용하는지, 그리고 사용할 때 주의해야 할 점은 무엇인지 더 자세히 알아볼 필요가 있어요. 다음 섹션에서는 이 함수들을 실제로 사용하는 예제와 함께, 더 깊이 있는 내용을 다뤄볼 거예요. 준비되셨나요? 우리의 모험은 계속됩니다! 🚀

🔬 저수준 파일 I/O 실전 활용

이제 우리는 저수준 파일 I/O의 기본 함수들을 알게 되었어요. 하지만 실제로 이 함수들을 어떻게 사용하는지 궁금하지 않나요? 자, 이제 실전 예제를 통해 이 함수들을 어떻게 활용하는지 자세히 알아보겠습니다. 마치 요리 레시피를 따라 하듯이, 단계별로 살펴볼 거예요! 👨‍🍳👩‍🍳

📝 예제 1: 파일 생성 및 쓰기

먼저, 새 파일을 만들고 거기에 데이터를 쓰는 예제를 살펴볼까요?

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    int fd;
    char *text = "안녕하세요, 저수준 파일 I/O의 세계에 오신 것을 환영합니다!\n";
    
    // 파일 열기 (없으면 생성)
    fd = open("example.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("파일 열기 실패");
        return 1;
    }
    
    // 파일에 쓰기
    ssize_t bytes_written = write(fd, text, strlen(text));
    if (bytes_written == -1) {
        perror("파일 쓰기 실패");
        close(fd);
        return 1;
    }
    
    printf("%zd 바이트를 파일에 썼습니다.\n", bytes_written);
    
    // 파일 닫기
    if (close(fd) == -1) {
        perror("파일 닫기 실패");
        return 1;
    }
    
    return 0;
}
  

이 예제에서는 다음과 같은 과정을 거칩니다:

1. open() 함수로 파일을 엽니다. O_WRONLY (쓰기 전용), O_CREAT (파일이 없으면 생성), O_TRUNC (기존 내용 삭제) 플래그를 사용했어요.
2. write() 함수로 파일에 데이터를 씁니다.
3. close() 함수로 파일을 닫습니다.

📖 예제 2: 파일 읽기

이번에는 파일의 내용을 읽어오는 예제를 살펴볼까요?

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;
    
    // 파일 열기
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("파일 열기 실패");
        return 1;
    }
    
    // 파일 읽기
    while ((bytes_read = read(fd, buffer, BUFFER_SIZE)) > 0) {
        write(STDOUT_FILENO, buffer, bytes_read);
    }
    
    if (bytes_read == -1) {
        perror("파일 읽기 실패");
        close(fd);
        return 1;
    }
    
    // 파일 닫기
    if (close(fd) == -1) {
        perror("파일 닫기 실패");
        return 1;
    }
    
    return 0;
}
  

이 예제에서는:

1. open() 함수로 파일을 읽기 모드로 엽니다.
2. read() 함수로 파일의 내용을 읽습니다. 여기서는 while 루프를 사용해 파일 전체를 읽어요.
3. 읽은 내용을 표준 출력(화면)에 씁니다.
4. 마지막으로 close() 함수로 파일을 닫습니다.

🔄 예제 3: 파일 복사

이제 앞서 배운 내용을 종합해서, 한 파일의 내용을 다른 파일로 복사하는 예제를 만들어볼까요?

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

#define BUFFER_SIZE 4096

int main(int argc, char *argv[]) {
    int fd_src, fd_dest;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read, bytes_written;
    
    if (argc != 3) {
        fprintf(stderr, "사용법: %s <원본 파일> <대상 파일>\n", argv[0]);
        return 1;
    }
    
    // 원본 파일 열기
    fd_src = open(argv[1], O_RDONLY);
    if (fd_src == -1) {
        perror("원본 파일 열기 실패");
        return 1;
    }
    
    // 대상 파일 열기 (없으면 생성)
    fd_dest = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd_dest == -1) {
        perror("대상 파일 열기 실패");
        close(fd_src);
        return 1;
    }
    
    // 파일 복사
    while ((bytes_read = read(fd_src, buffer, BUFFER_SIZE)) > 0) {
        bytes_written = write(fd_dest, buffer, bytes_read);
        if (bytes_written != bytes_read) {
            perror("파일 쓰기 실패");
            close(fd_src);
            close(fd_dest);
            return 1;
        }
    }
    
    if (bytes_read == -1) {
        perror("파일 읽기 실패");
        close(fd_src);
        close(fd_dest);
        return 1;
    }
    
    // 파일 닫기
    close(fd_src);
    close(fd_dest);
    
    printf("파일 복사가 완료되었습니다.\n");
    return 0;
}
  

이 예제는 앞서 배운 모든 것을 종합했어요:

1. 두 개의 파일을 엽니다. 하나는 읽기용, 다른 하나는 쓰기용이에요.
2. 원본 파일에서 데이터를 읽어 버퍼에 저장합니다.
3. 버퍼의 내용을 대상 파일에 씁니다.
4. 이 과정을 파일의 끝에 도달할 때까지 반복합니다.
5. 마지막으로 두 파일을 모두 닫습니다.

이렇게 우리는 저수준 파일 I/O의 기본적인 사용법을 배웠어요. 하지만 이게 전부가 아닙니다! 실제 프로그래밍에서는 더 복잡한 상황들을 만나게 될 거예요. 네, 계속해서 저수준 파일 I/O에 대해 더 깊이 있게 알아보겠습니다.

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDWR);
    if (fd == -1) {
        perror("파일 열기 실패");
        return 1;
    }

    // 파일의 끝으로 이동
    off_t end_pos = lseek(fd, 0, SEEK_END);
    printf("파일 크기: %ld 바이트\n", end_pos);

    // 파일의 시작에서 10바이트 위치로 이동
    lseek(fd, 10, SEEK_SET);

    char buffer[5];
    read(fd, buffer, 5);
    buffer[5] = '\0';
    printf("10번째 위치부터 5바이트: %s\n", buffer);

    close(fd);
    return 0;
}
  

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int fd = open("shared_file.txt", O_RDWR);
    if (fd == -1) {
        perror("파일 열기 실패");
        return 1;
    }

    struct flock fl = {
        .l_type = F_WRLCK,  // 쓰기 잠금
        .l_whence = SEEK_SET,
        .l_start = 0,
        .l_len = 0,  // 0은 파일 전체를 의미
    };

    printf("파일 잠금 시도...\n");
    if (fcntl(fd, F_SETLKW, &fl) == -1) {
        perror("파일 잠금 실패");
        close(fd);
        return 1;
    }

    printf("파일이 잠겼습니다. 작업을 수행합니다...\n");
    sleep(5);  // 작업 시뮬레이션

    // 잠금 해제
    fl.l_type = F_UNLCK;
    if (fcntl(fd, F_SETLK, &fl) == -1) {
        perror("파일 잠금 해제 실패");
    } else {
        printf("파일 잠금이 해제되었습니다.\n");
    }

    close(fd);
    return 0;
}
  

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    int fd = open("example.txt", O_RDWR);
    if (fd == -1) {
        perror("파일 열기 실패");
        return 1;
    }

    // 파일 크기 확인
    off_t file_size = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET);  // 파일 포인터를 다시 처음으로

    // 파일을 메모리에 매핑
    char *file_in_memory = mmap(NULL, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (file_in_memory == MAP_FAILED) {
        perror("mmap 실패");
        close(fd);
        return 1;
    }

    // 매핑된 메모리를 통해 파일 내용 수정
    char *text_to_write = "Hello, Memory-mapped file!";
    memcpy(file_in_memory, text_to_write, strlen(text_to_write));

    // 변경 사항을 디스크에 동기화
    if (msync(file_in_memory, file_size, MS_SYNC) == -1) {
        perror("msync 실패");
    }

    // 매핑 해제
    if (munmap(file_in_memory, file_size) == -1) {
        perror("munmap 실패");
    }

    close(fd);
    return 0;
}
  

int fd = open("secret.txt", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
  

#include <stdio.h>
#include <errno.h>

if (close(fd) == -1) {
    perror("파일 닫기 실패");
    printf("에러 번호: %d\n", errno);
}