System-Level I/O: 두 판 사이의 차이

youngwiki
← 이전 편집다음 편집 →
시각위키텍스트
181번째 줄: 181번째 줄:
* 네트워크 소켓을 읽고 쓰는 경우: 열린 파일이 네트워크 소켓에 해당한다면, 내부 버퍼 제약과 긴 네트워크 지연으로 인해 <code>read()</code>, <code>write()</code> 함수는 짧은 수치를 반환할 수 있다. 또한, 리눅스 파이프(pipe)를 <code>read()</code>, <code>write()</code> 함수로 호출할 때도 발생할 수 있다.
* 네트워크 소켓을 읽고 쓰는 경우: 열린 파일이 네트워크 소켓에 해당한다면, 내부 버퍼 제약과 긴 네트워크 지연으로 인해 <code>read()</code>, <code>write()</code> 함수는 짧은 수치를 반환할 수 있다. 또한, 리눅스 파이프(pipe)를 <code>read()</code>, <code>write()</code> 함수로 호출할 때도 발생할 수 있다.


==Robust I/O package==
==[[Robust I/O package]]==
자세한 내용은 [[Robust I/O package]] 문서를 참조하십시오.
'''RIO(Robust I/O)'''는 효율적이고 굳건한(robust) I/O를 제공하는 래퍼(wrapper) 함수들의 집합으로, 특히 short counts 문제에 취약한 응용 프로그램을 위해 사용된다. RIO는 두 가지 종류의 함수들을 제공한다.
'''RIO(Robust I/O)'''는 효율적이고 굳건한(robust) I/O를 제공하는 래퍼(wrapper) 함수들의 집합으로, 특히 short counts 문제에 취약한 응용 프로그램을 위해 사용된다. RIO는 두 가지 종류의 함수들을 제공한다.
* Unbuffered 입출력 함수: 해당 함수들은 메모리와 파일 사이에 데이터를 직접 전송하며, 응용 프로그램 수준의 버퍼링(application-level buffering)은 없다. 주로 네트워크로부터 binary 데이터를 읽고 쓸때에 유용하다.  
* Unbuffered 입출력 함수: 해당 함수들은 메모리와 파일 사이에 데이터를 직접 전송하며, 응용 프로그램 수준의 버퍼링(application-level buffering)은 없다. 주로 네트워크로부터 binary 데이터를 읽고 쓸때에 유용하다.  

2025년 4월 17일 (목) 17:22 판

상위 문서: 컴퓨터 시스템

개요

입출력(I/O)은 주기억장치(main memory)와 디스크 드라이브, 터미널, 네트워크와 같은 외부 장치(external devices) 사이에서 데이터를 복사하는 과정이다. 입력 연산(input operation)은 I/O 장치로부터 데이터를 주기억장치로 복사하고, 출력 연산(output operation)은 데이터를 주기억장치에서 장치로 복사한다.
해당 문서에서는 UNIX I/O와 표준 I/O의 일반적인 개념과, C 프로그램에서 이를 안정적으로 사용하는 방법을 설명한다.

UNIX I/O

리눅스 파일은 아래와 같은 m 바이트의 시퀸스로 구성된다. 

B1, B2, ..., Bk, ..., Bm-1

모든 I/O 장치들(예: 네트워크, 디스크, 터미널, 커널! 등)은 아래와 같이 파일로 모델링되며, 모든 I/O는 해당 파일들을 읽고 쓰는 방식으로 수행된다. 

/dev/sda2                       (/usrdiskpartition)
/dev/tty2                       (terminal)
/boot/vmlinuz-3.13.0-55-generic (kernel image)
/proc                           (kernel data structures)

I/O 장치들을 모두 파일로 매핑하는 방식 덕분에, 리눅스 커널은 UNIX I/O로 불리는 단순하고 저수준(low-level)의 인터페이스를 제공할 수 있다. 이를 통해 모든 I/O 작업들을 일관되고 통일된 방식으로 수행할 수 있다.

Files

각 리눅스 시스템 내에서의 역할을 나타내는 type을 가진다:

  • 일반 파일(regular file)은 임의의 데이터로 구성된다. 애플리케이션 들은 종종 일반 파일 들을 ASCII 혹은 유니코드 문자만을 포함하는 텍스트 파일(text file)과, 그 외의 모든 것을 포함하는 바이너리 파일(binary file) 을 구분하지만, 커널은 이를 구분하지 않는다. 따라서 UNIX I/O도 텍스트 파일과 바이너리 파일을 구분하지 않는다. 리눅스 텍스트 파일은 단순히 텍스트 라인들의 시퀸스(sequence of text lines)로 구성되며, 각 줄(text line)은 문자들의 시퀸스(sequence of characters)로 이루어지고 줄바꿈 문자('\n')[1]로 종료된다.
  • 디렉토리(directory)는 링크(link)들의 배열로 구성된 파일이며, 각 링크는 파일 이름을 파일(혹은 디렉토리)에 매핑한다. 각 디렉토리는 적어도 두 개의 항목을 가지고 있다. 먼저 .는 디렉토리 자신을 가리키는 링크이고, ..는 디렉토리 계층 구조에서 상위 디렉토리를 가리키는 링크이다. 디렉토리는 mkdir 명령어로 만들 수 있고, ls 명령어로 안의 내용을 볼 수 있으며, rmdir 명령어를 통해서 삭제할 수 있다.
  • 소켓(socket)은 네트워크를 통해 다른 프로세스와 통신하기 위해 사용되는 파일이다.

그외에도 named pipe, symbolic link, character and block deviced와 같은 여러 type들이 추가로 존재하나, 이에 대해서는 다루지 않느다.

Directory hierarchy

Figure 1. Portion of the Linux directory hierarchy
Figure 1. Portion of the Linux directory hierarchy

리눅스 커널은 모든 파일을 루트(root) 디렉터리 /로 고정된 단일 디렉터리 계층 구조 안에 조직한다. 시스템 내의 각 파일은 루트 디렉터리의 직계 또는 간접 후손(direct or indirect descendant)이다. Figure 1은 리눅스 시스템 내의 디렉토리 계층의 일부를 보여준다.
각 프로세스는 컨텍스트의 일부로 현재의 작업 디렉터리(current working directory)를 가지며, 이는 디렉토리 계층 내에서 현재 위치를 나타낸다. 이때, cd 명령어를 통해 셸(shell)의 현재 작업 디렉터리를 변경할 수 있다.

디렉더리 계층에서의 위치는 경로명(pathname) 으로 지정된다. 경로명은 /로 구분된 일련의 파일 이름들로 구성된 문자열이다.[2] 경로명은 두 가지 형태가 있다:

  • 절대 경로명(absolute pathname): /로 시작하며, 루트 디렉토리로부터의 경로를 나타낸다.
    • hello.c의 절대 경로명: /home/droh/hello.c
  • 상대 경로명(relative pathname): 파일 이름으로 시작하며, 현재 작업 디렉터리로부터의 경로를 나타낸다.
    • /home/droh가 현재 작업 디렉터리일 때 hello.c의 상대 경로명: ./hello.c
    • /home/bryant가 현재 작업 디렉터리일 때 hello.c의 상대 경로명: ../home/droh/hello.c

Opening and Closing Files

Opening files

애플리케이션은 close() 함수를 통해 커널에게 특정 파일을 열도록 요철하며, 해당 I/O 장치에 접근한다. 

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(char *filename, int flags, mode_t mode); //Returns: new file descriptor if OK, −1 on error

커널은 해당 파일 이름을 파일 디스크립터(file descriptor)[3]로 변환하고 그 디스크립터 번호를 반환한다. 반환되는 디스크립터는 항상 프로세스에서 현재 열려 있지 않은 가장 작은 디스크립터 번호이다. 이 디스크립터는 이후 파일에 대한 모든 연산에서 사용된다.[4] 위 close() 함수에서 flag 인자는 프로세스가 파일에 어떻게 접근하려는지를 나타내며, 이는 아래와 같다:

  • O_RDONLY: 읽기 전용
  • O_WRONLY: 쓰기 전용
  • O_RDWR: 읽기 및 쓰기

또한, flags 인자는 추가적인 옵션을 제공하는 하나 이상의 비트 마스크(bit mask)와 OR 연산으로 결합될 수 있다.

  • O_CREAT: 파일이 존재하지 않으면 빈 파일을 새로 만든다.
  • O_TRUNC: 파일이 이미 존재하면 해당 파일을 빈 파일로 만든다.
  • O_APPEND: 쓰기 작업(write())을 할 때마다, 커널이 자동으로 파일의 맨 끝으로 이동해서 쓰게 한다.[5]

예를 들어, 이어 쓰고자 할 때, 파일을 쓰기 전용으로 여는 방법은 다음과 같다. 

fd = Open("foo.txt", O_WRONLY|O_APPEND, 0);

또한 모든 리눅스 프로세스는 생성되거나 시작하는 즉시 기본으로 열려있는 세개의 파일(디스크립터)를 가지고 있는데, 이는 다음 표와 같다:

이름 디스크립터 상수 역할
standard input 0 STDIN_FILENO 키보드 등에서 입력 받기
standard output 1 STDOUT_FILENO 화면(터미널)으로 출력하기
standard error 2 STDERR_FILENO 에러 메시지 출력하기

아래는 기본 디스크립터를 이용하여 터미널에서 1byte씩 읽고 출력하는 예제 프로그램이다. 

#include "csapp.h"
int main(void) {
    char c;
    while (Read(STDIN_FILENO, &c, 1) != 0)
        Write(STDOUT_FILENO, &c, 1);
    exit(0);
}

Colsing files

애플리케이션이 파일에 대한 접근을 마치면, close() 함수를 호출하여 해당 파일을 닫아달라고 커널에 요청한다: 

#include <unistd.h>
int close(int fd); //Returns: 0 if OK, −1 on error

커널은 위 함수의 호출 결과로 파일을 열 때 생성한 데이터 구조들을 해제하고, 디스크립터를 사용 가능한 디스크립터 풀로 되돌린다. 이때 이미 닫혀있는 디스크립터를 닫는 것은 오류이다. 또한 프로세스가 어떤 이유로든 종료되면, 커널은 열려있는 모든 파일들을 닫고 그 메모리 자원들을 해제한다.

Reading and Writing Files

Reading files

애플리케이션은 read() 함수를 호출하여 입력 연산을 수행한다: 

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t n); //Returns: number of bytes read if OK, 0 on EOF, −1 on error

read() 함수는 디스크립터 fd의 현재 파일 위치(current file position) k로부터 최대 n 바이트를 buf에 복사하고, 그 후에 k를 n만큼 증가시킨다. 이때 파일 크기가 m 바이트일 때, k≥m인 상태에서 읽기 연산을 수행하면 EOF(end of file) 상태가 발생한다.[6] 예를 들어 아래의 코드는 100바이트씩 계속 읽다가 더 이상 읽을 게 없으면, read() 함수는 EOF 상태이므로 0을 반환한다. 

int fd = open("myfile.txt", O_RDONLY);
char buf[100];
int n;
while ((n = read(fd, buf, 100)) > 0) {
    // 여기서 buf 안의 데이터를 사용함
}
if (n == 0) {
    //n == 0 이면 EOF 도달, n == -1이면 에러 종료
}

Writing files

애플리케이션은 write() 함수를 호출하여 쓰기 연산을 수행한다: 

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t n); //Returns: number of bytes written if OK, −1 on error

write() 함수는 buf 안에 있는 데이터에서 최대 n 바이트를 복사하여 fd에 해당하는 파일의 현재 파일 위치 k에 적고 k를 갱신한다. 예를 들어, 아래 코드는 "hello"라는 5바이트짜리 문자열을 파일 fd에 쓴다: 

char msg[] = "hello";
write(fd, msg, 5);

Changing the current file position

애플리케이션은 lseek 함수를 호출하여 현재의 파일 위치를 바꾼다: 

#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence); //Returns: current file position if OK, -1 on error

lseek 함수는 fd에 해당하는 파일의 현재 파일 위치를 offset byte만큼 옮긴다. 이때 옮긴 위치에 기준을 잡기 위해서 아래 표에 정리되어 있는 whence 옵션이 사용된다:

옵션 설명
SEEK_SET Move from the start of the file
SEEK_CUR Move from the current position of the file
SEEK_END Move from the end of the file

아래는 lseek 함수가 사용된 코드의 예시이다. 

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main() {
    int fd = open("example.txt", O_RDWR); //파일 열기
    if (fd == -1) { //적절한 파일 디스크립터인지 확인
        perror("open");
        return 1;
    }
    off_t pos = lseek(fd, 0, SEEK_CUR); //pos에 현재 파일 위치 저장
    printf("Current position: %ld\n", pos);

    lseek(fd, 5, SEEK_SET); // 파일 시작에서 5바이트 앞으로 이동
    write(fd, "HELLO", 5);  // 파일 처음에서 5번째 바이트에 HELLO 덮어쓰기

    off_t end = lseek(fd, 0, SEEK_END); //현재 파일 위치를 파일의 끝으로 이동
    printf("File size: %ld bytes\n", end);

    close(fd); //파일 닫기
    return 0;
}

Short counts

어떤 상황에서는 read(), write() 함수가 요청받은 바이트(n)보다 적은 양을 전송하기도 한다. 이를 short counts라고 하며, 이는 오류를 의미하지 않는다. 이는 다음과 같은 상황일때 발생한다:

  • 읽기 도중 EOF를 만난 경우: 예를 들어, 현재 파일 위치로부터 남은 바이트가 20바이트뿐인 파일을 50바이트씩 읽고 있다고 하자. 이 경우 다음 read 호출은 20이라는 짧은 수치를 반환하고, 그 다음 호출은 0을 반환하여 EOF를 나타낸다.
  • 터미널에서 텍스트 줄을 읽는 경우: 열린 파일이 터미널(즉, 키보드와 디스플레이)과 연결되어 있다면, 각 read() 함수 호출은 한 줄의 텍스트만 전송하고, 이 줄의 크기만큼의 short counts를 반환한다.
  • 네트워크 소켓을 읽고 쓰는 경우: 열린 파일이 네트워크 소켓에 해당한다면, 내부 버퍼 제약과 긴 네트워크 지연으로 인해 read(), write() 함수는 짧은 수치를 반환할 수 있다. 또한, 리눅스 파이프(pipe)를 read(), write() 함수로 호출할 때도 발생할 수 있다.

Robust I/O package

자세한 내용은 Robust I/O package 문서를 참조하십시오. RIO(Robust I/O)는 효율적이고 굳건한(robust) I/O를 제공하는 래퍼(wrapper) 함수들의 집합으로, 특히 short counts 문제에 취약한 응용 프로그램을 위해 사용된다. RIO는 두 가지 종류의 함수들을 제공한다.

  • Unbuffered 입출력 함수: 해당 함수들은 메모리와 파일 사이에 데이터를 직접 전송하며, 응용 프로그램 수준의 버퍼링(application-level buffering)은 없다. 주로 네트워크로부터 binary 데이터를 읽고 쓸때에 유용하다.
  • Buffered 입력 함수: 해당 함수들은 표준 I/O 함수들(printf() 함수 등)이 제공하는 것과 유사하게 응용 프로그램 수준의 버퍼 내에 저장된(cached in an application- level buffer) binary 데이터들과 텍스트 라인들을 읽도록 한다.
    • 표준 I/O 함수들과는 달리, RIO buffered 함수들은 thread-safe하며, 동일한 파일 디스크립터에 대해서 임의로 교차적으로(interleaved) 사용이 될 수 있다. 예를 들어 파일 디스크립터로부터 텍스트 라인 몇 줄을 읽고, 그 다음에 binary 데이터를 읽고, 다시 텍스트 라인을 읽는 것이 가능하다.

Unbuffered RIO Input and Output

응용 프로그램은 rio_readn()과 rio_writen() 함수를 호출하여 메모리와 파일 사이에 데이터를 직접 전송할 수 있다. 

#include "csapp.h"
ssize_t rio_readn(int fd, void *usrbuf, size_t n); 
//Returns: number of bytes transferred if OK, 0 on EOF, −1 on error
ssize_t rio_writen(int fd, void *usrbuf, size_t n);
//Returns: number of bytes transferred if OK, −1 on error

rio_readn()함수는 디스크립터 fd의 현재 파일 위치로부터 최대 n 바이트를 버퍼 usrbuf로 전송한다. 이때 rio_readn()함수는 EOF에 도달한 경우에만 short count를 반환할 수 있으며, 완전한 EOF인 경우[7]에는 0을 반환한다. rio_writen()함수는 버퍼 usrbuf에서 디스크립터 fd로 n 바이트를 전송한다. 이때 rio_writen()함수는 절대 short counts를 반환하지 않는다. 이때 두 함수는 같은 디스크립터 내에서 임의로 교차하여 사용할 수 있다. 아래는 rio_readn() 함수를 어떻게 구현하였는지 보여준다: 

ssize_t rio_readn(int fd, void *usrbuf, size_t n)
{
    size_t nleft = n; // 앞으로 읽어야할 byte의 수
    ssize_t nread; //지금까지 읽은 byte의 수
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nread = read(fd, bufp, nleft)) < 0) { /* read()는 한 번에 n 바이트를 못 읽을 수 있기 때문에 반복해서 읽음 */
            if (errno == EINTR)     /* 시그널 핸들러로 인해 인터럽트된 경우 */
                nread = 0;          /* 다시 read 호출 */
            else 
                return -1;          /* 그 외 오류일 경우 에러 리턴 */
        } else if (nread == 0) break;              /* read() 함수가 0 반환시 EOF 도달로 간주 */

        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);             /* 실제 읽은 바이트 수 리턴 (0 이상) */
}

위 코드는 파일 디스크립터 fd로부터 정확히 n 바이트를 usrbuf로 읽어오는 작업을 수행한다. 이때 read() 함수는 한번에 데이터를 원하는 만큼 읽어오지 못할 수 있으므로 반복하여 호출된다. 이때 시그널 인터럽트(EINTR)가 발생하면 읽기 작업을 재시도 하며, read() 함수가 0을 반환하면 EOF 도달로 간주하고 종료한다. 이를 통해서 rio_readn()함수는 실제로 읽은 바이트 수를 반환할 수 있다. 이때 read()함수는 다음과 같은 원인으로 인해서 데이터를 한번에 원하는 만큼 읽지 못할 수 있다.

  1. 커널 버퍼에 데이터가 부족한 경우
    • read(fd, buf, n)을 요청했는데 커널에 n보다 적은 양만 준비돼 있으면, read()는 그 준비된 양만큼만 읽고 바로 리턴한다.
  2. 시그널로 인한 인터럽트(errno == EINTR) 발생 시, read()는 실패(-1)하고 중단된다.
  3. stream device의 특성으로 인해서 부분적인 읽기가 일상적인 경우도 있다.
    • 디스크 파일은 read()함수를 사용시 보통 n바이트 다 읽힌다.
    • 하지만 네트워크 소켓, 파이프, 터미널 같은 stream 기반 장치는 read가 준비된 만큼만 읽고 종료하며, 이는 short counts의 원인이 된다.

위에서 1, 3번은 short counts의 가장 중요한 원인 중 하나이며, 다른 read()함수가 충분하지 못한 양을 읽는 이유도 대부분 short counts와 관련이 있다. 하지만 rio_readn() 함수의 구현 코드를 보면 알 수 있듯이 해당 함수는 short counts가 발생할 시 read()함수를 다시 호출하여, short_counts로부터 자유로워지도록 한다. 아래는 rio_readn()과 rio_writen() 함수를 어떻게 구현하였는지 보여준다: 

ssize_t rio_writen(int fd, void *usrbuf, size_t n)
{
    size_t nleft = n; //버퍼에 저장해야할 바이트 수
    ssize_t nwritten; //버퍼에 저장한 바이트 수
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nwritten = write(fd, bufp, nleft)) <= 0) { /* write() 함수도 일부만 쓸 수 있으므로 반복하여 호출한다. */
            if (errno == EINTR)     /* 시그널 핸들러로 인해 인터럽트된 경우 */
                nwritten = 0;       /* 다시 write 호출 */
            else
                return -1;          /* 그 외 오류일 경우 에러 리턴 */
        }
        nleft -= nwritten;
        bufp += nwritten;
    }
    return n;
}

위 코드는 사용자 버퍼 usrbuf의 내용을 fd에 정확히 n 바이트만큼 쓰는 작업을 수행한다. 이때 write()함수가 일부분만 쓸 수 있기 때문에 반복하여 호출된다. 이때 시그널 인터럽트(EINTR)가 발생하면 쓰기 작업을 재시도한다. write는 EOF 개념이 없기 때문에 EOF의 경우는 고려하지 않는다.
write()함수가 요청받은 바이트 수 만큼 한번에 쓰지 못하는 경우는 주로 시스템 버퍼가 다 찼을 때 발생한다. OS가 write 요청을 받으면 쓸 데이터를 커널 내부의 출력 버퍼에 저장한다. 하지만 네트워크 소켓이나 파이프의 출력 버퍼는 용량이 제한적이므로, 요청한 쓸 바이트 크기보다 현재 남아있는 출력 버퍼의 크기가 작은 경우, 해당 버퍼의 크기까지만 쓰고 리턴할 수 있다. 하지만 위 코드를 보면 알 수 있듯이, rio_writen()함수는 이러한 문제에서 자유롭다. 즉, 특별한 에러가 발생하지 않는 이상, 요청받은 n 바이트를 모두 쓰는 것을 보장한다.

Buffered RIO Input Functions

Buffered RIO 입력 함수들은 내부 메모리 버퍼에 부분적으로 캐시된 파일로부터 텍스트 라인과 binary 데이터를 효율적으로 읽는 함수들이다. 아래는 buffered RIO 입력 함수들이다: 

#include "csapp.h"
void rio_readinitb(rio_t *rp, int fd); //Returns: nothing
//Returns: number of bytes read if OK, 0 on EOF, −1 on error
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);

rio_readinitb(rio_t *rp, int fd) 함수에서 rp는 내부에 입력 버퍼와 상태 정보를 가지는 인자이다. Figure 2는 rio_t 구조체의 내부 구조를 보여준다. rio_t 구조체는 아래와 같은 3가지 필드가 존재한다:

  • rio_buf: 버퍼 전체
  • rio_bufptr: 현재 읽기 위치 (unread 시작점)
  • rio_cnt: unread 바이트 수

또한 Figure 2에서 buffer에 속하지만, alread used도, unused도 아닌 공간은 아직 read() 호출로 채워지지 않은 남은 버퍼 공간을 의미한다. 따라서, rio_readinitb() 함수를 호출할 경우에는 내부 버퍼를 초기화하고 디스크립터인 fd와 해당 버퍼를 연결시키는 역할을 한다. 이는 rio_readlineb나 rio_readnb 함수를 사용하기 위해서는 어떤 디스크립터로부터 읽을 지와, 버퍼를 어디에 두어야 할지를 지정해야 하기 때문에 사용된다.
rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 함수는 다음 한 줄을 읽고, usrbuf에 이를 복사한다. 이때 문자열의 끝에는 항상 '\0' 문자를 붙여 C 문자열 처럼 usrbuf를 다룰 수 있도록 한다. 이때, 복사하는 바이트의 수는 최대 maxlen-1 바이트로 제한되며, 그 이상의 줄은 잘리고, usrbuf의 끝 원소는 '\0'이 차지한다.
rio_readnb(rio_t *rp, void *usrbuf, size_t n) 함수는 내부 버퍼에서 n 바이트까지 읽어서 usrbuf에 복사한다. 아래는 rio_readinitb() 함수가 어떻게 구현되는지를 보여준다. 

void rio_readinitb(rio_t *rp, int fd)
{
    rp->rio_fd = fd;
    rp->rio_cnt = 0; //read()로 rio_buf에 데이터를 채우면 rio_cnt는 그 바이트 수만큼 설정된다.(내부 버퍼 내의 읽을 정보량)
    rp->rio_bufptr = rp->rio_buf; //내부 버퍼인 rio_buf 안에서, 다음에 읽을 위치를 가리킨다.(내부 버퍼 내의 현재 파일 위치)
}

위 코드에서는 빈 읽기 버퍼를 설정하고, 파일 디스크립터를 해당 버퍼와 연결하는 역할을 한다. 또한 rio_readnb()와 rio_readnb() 함수가 어떻게 구현되는지 알기 위해서는 먼저 rio_read() 함수가 어떻게 구현되는지에 대해서 먼저 알아야 한다. 

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;
    while (rp->rio_cnt <= 0) { // "cnt <= 0"는 내부 버퍼에 읽을 데이터가 없다는 것을 의미
        rp->rio_cnt = read(rp->rio_fd, rp->rio_buf,sizeof(rp->rio_buf)); //read()로 디스크립터에서 rio_buf에 읽어옴
        if (rp->rio_cnt < 0) { //read() 함수가 실패한 경우
            if (errno != EINTR) //시그널로 인터럽트된 경우 (EINTR) → 무시하고 다시 시도.
                return -1;
        }
        else if (rp->rio_cnt == 0)  //read()가 0을 반환하면 → EOF, 더 이상 읽을 게 없음.
            return 0;
        else
            rp->rio_bufptr = rp->rio_buf; //성공적으로 읽었다면, 내부 포인터를 버퍼의 시작 위치로 초기화
    }

    /* min(n, rp->rio_cnt) 만큼 바이트들을 내부 버퍼에서 usrbuf로 옮긴다. */
    cnt = n;
    if (rp->rio_cnt < n)
        cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt; //rp의 내부 버퍼의 현재 파일 위치를 복사한 바이트 수 만큼 이동시킨다.
    rp->rio_cnt -= cnt; //rp의 내부 버퍼의 현재 파일 위치를 복사한 바이트 수 만큼 읽을 수 있는 바이트 수는 줄어든다.
    return cnt;
}

위 함수를 보면 알 수 있듯이, rio_read() 함수는 read() 함수의 버퍼링된 버전이다. 따라서 해당 함수는 short counts를 반환할 수 있으며, 이는 오류가 아니다. 단지 해당 버퍼 내에 남아있는 바이트의 수(rio_cnt)가 요청받은 바이트 수보다 부족했음을 의미할 뿐이다. 응용 프로그램 입장에서는 rio_read() 함수는 Linux의 read() 함수와 동일한 의미를 가진다:

  • 에러 시 -1을 반환하고 errno를 설정한다.
  • EOF 시 0을 반환한다.
  • 요청한 바이트 수가 버퍼에 남은 바이트 수를 초과할 경우에는 short counts를 반환한다.

두 함수가 유사하므로, read로 대체하여 다양한 종류의 buffered 입력 함수들을 쉽게 구축할 수 있다. 아래는 rio_readnb() 함수를 구현한 코드이다: 

ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n)
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nread = rio_read(rp, bufp, nleft)) < 0) return -1; /* errno set by read() */
        else if (nread == 0) break; /* EOF */

        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);      /* Return >= 0 */
}

위 코드에서 알 수 있듯이, rio_readnb() 함수는 구조상으로 rio_readn() 함수와 동일하다. 다만 내부 버퍼에 파일의 내용을 저장한 뒤, 내부 버퍼에서 해당 내용을 끌어 쓸 뿐이다. 아래는 rio_readlineb() 함수를 구현한 코드이다: 

ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
    int n, rc;
    char c, *bufp = usrbuf;

    for (n = 1; n < maxlen; n++) { //최대 maxlen-1 바이트 까지만 읽음
        if ((rc = rio_read(rp, &c, 1)) == 1) {
            *bufp++ = c;
            if (c == '\n') { //개행 문자를 만나면 반복문 종료
                n++;
                break;
            }
        } else if (rc == 0) {         /* 예외 케이스 처리 */
            if (n == 1) return 0;     /* 완전한 EOF이므로 0을 반환함 */
            else break;               /* 몇몇 바이트를 읽었으나, 더 이상 읽을 데이터가 없음 */
        } else return -1;             /* Error */
    }

    *bufp = 0;    //usrbuf의 마지막 원소는 항상 '\0' 문자 사용
    return n - 1; //실제로 읽은 바이트의 수를 반환
}

마찬가지로 rio_readlineb() 함수 또한 거의 동일한 메커니즘을 사용하는 것을 볼 수 있다. 다만 read_nb() 함수와 마찬가지로, 내부 버퍼에 파일의 내용을 저장한 뒤, 내부 버퍼에서 해당 내용을 끌어 쓸 뿐이다.

이때 궁금증이 들 수 있다. rio_readn()과 rio_readnb()는 사실상 같은 역할을 하는 함수이지만, 왜 같은 일을 하는 함수가 두 개나 존재하는가? 핵심적인 차이는 내부 버퍼를 사용하는지의 여부이다. rio_read() 함수는 내부 버퍼를 사용하지 않고, 데이터를 읽고자 할 때마다 매번 read() 함수를 호출한다. 따라서 해당 함수는 stream에서 연속적으로 binary 데이터를 다룰 때 적함한 함수이다.
하지만, rio_readbn() 함수는 내부 버퍼를 따로 가지고 있으며, 사용자가 원하는 만큼 꺼내 사용하는 함수이다. 따라서 read() 함수는 오직 내부 버퍼를 채울 때만 수행된다. 따라서, 해당 함수는 텍스트 라인과 binary 데이터가 동시에 사용된 파일을 다룰 때 유리하다. 또한 해당 함수는 caching을 사용하므로 더욱 빠르다는 장점이 있다. 이때, bufferd 입력 함수는 unbufferd 함수와는 섞어서 사용할 수 없다. 그 이유는 buffered 함수가 내부 버퍼를 다룰 때 이미 fd를 이용하여 파일에 접근하므로, unbuffered 함수가 동작할 때는 현재 파일 위치가 예상치 못하게 변해 있을 수 있기 때문이다. 따라서 buffered 입력 함수를 사용하고자 할 때는 동일한 buffered 입력 함수와만 교차해서 사용하여야 한다. 아래 코드는 RIO 함수의 사용 예시를 보여준다. 

int main(int argc, char **argv)
{
    int n;
    rio_t rio;
    char buf[MAXLINE];

    Rio_readinitb(&rio, STDIN_FILENO);
    while ((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0)
        Rio_writen(STDOUT_FILENO, buf, n);
    exit(0);
}

위에서는 STDIN을 한줄 씩 읽어들인 다음, 이를 내부 버퍼에 저장한 후 STDOUT에 출력하는 간단한 예시이다. 이때 rio_writen() 함수가 사용되었다.

각주

  1. ↑ 줄 바꿈 문자는 0x0a에 해당하며, 이는 ASCII 값과 동일하다.
  2. ↑ 이때 경로명은 /으로 시작할 수도, 안할 수도 있다.
  3. ↑ 0 이상의 정수이다
  4. ↑ 커널은 열려있는 파일에 대한 모든 정보를 추적하고 관리하나, 애플리케이션은 디스크립터만을 추적한다.
  5. ↑ 기존 내용을 덮어 쓰지 않고 이어 쓰고자 할 때 이용한다.
  6. ↑ 파일 끝에는 명시적인 EOF 문자는 존재하지 않는다.
  7. ↑ 읽기 작업을 시작하자마자 EOF인 경우에 해당한다.
원본 주소 "https://junhoahn.kr/junyoung/index.php?title=System-Level_I/O&oldid=2099"