Enterprise

IO_URING A web server with 'liburing'

'liburing'를 이용한 웹 서버 프로그램

우리는 select(2), poll(2) 및 epoll(7)이 로컬/일반 파일에 대한 작업을 항상 준비 상태로 보고하기 때문에 libuv(NodeJS를 지원하는 라이브러리)와 같은 라이브러리는 파일 I/O를 처리하기 위해 별도의 스레드 풀을 사용한다는 점을 소개 부분에서 논의했습니다. 'io_uring'의 가장 큰 장점 중 하나는 단일하고 깔끔한 통일성을 제공하며, 무엇보다도 다양한 유형의 I/O에 대해 효율적인 인터페이스를 제공한다는 것입니다.

이 예에서는 추가 작업인 accept()와 'io_uring'을 사용하여 이를 수행하는 방법을 살펴보겠습니다. readv() 및 writev()에 대한 작업을 수행하면 간단한 웹 서버를 작성할 수 있습니다! 이 웹 서버는 다양한 Linux 프로세스 모델과 이들 모델의 성능을 서로 비교하기 위해 작성한 기사 시리즈에 포함된 프로그램인 ZeroHTTPd용으로 작성한 코드를 기반으로 합니다. 나는 'io_uring' 인터페이스만 사용하도록 ZeroHTTPd를 다시 작성했습니다.

다음은 ZeroHTTPd를 통해 제공되는 인덱스 페이지입니다.

#include <stdio.h>
#include <netinet/in.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <liburing.h>
#include <sys/stat.h>
#include <fcntl.h>

#define SERVER_STRING           "Server: zerohttpd/0.1\r\n"
#define DEFAULT_SERVER_PORT     8000
#define QUEUE_DEPTH             256
#define READ_SZ                 8192

#define EVENT_TYPE_ACCEPT       0
#define EVENT_TYPE_READ         1
#define EVENT_TYPE_WRITE        2

struct request {
  int event_type;
  int iovec_count;
  int client_socket;
  struct iovec iov[];
};

struct io_uring ring;

const char *unimplemented_content = \
  "HTTP/1.0 400 Bad Request\r\n"
  "Content-type: text/html\r\n"
  "\r\n"
  "<html>"
  "<head>"
  "<title>ZeroHTTPd: Unimplemented</title>"
  "</head>"
  "<body>"
  "<h1>Bad Request (Unimplemented)</h1>"
  "<p>Your client sent a request ZeroHTTPd did not understand and it is probably not your fault.</p>"
  "</body>"
  "</html>";

const char *http_404_content = \
  "HTTP/1.0 404 Not Found\r\n"
  "Content-type: text/html\r\n"
  "\r\n"
  "<html>"
  "<head>"
  "<title>ZeroHTTPd: Not Found</title>"
  "</head>"
  "<body>"
  "<h1>Not Found (404)</h1>"
  "<p>Your client is asking for an object that was not found on this server.</p>"
  "</body>"
  "</html>";

/*
 * Utility function to convert a string to lower case.
 * */
// 소문자로 변경
void strtolower(char *str) {
  for (; *str; ++str)
    *str = (char)tolower(*str);
}
/*
 * One function that prints the system call and the error details
 * and then exits with error code 1. Non-zero meaning things didn't go well.
 * 시스템 호출과 오류 세부 정보를 인쇄한 다음 오류 코드 1로 종료하는 함수입니다.
 * 0(Non-zero)이 아닌 것은 일이 잘 진행되지 않았음을 의미합니다.
 */
void fatal_error(const char *syscall) {
  perror(syscall);
  exit(1); // 문제가 있음. 
}

/*
 * Helper function for cleaner looking code.
 * 더 깔끔하게 보이는 코드를 위한 도우미 함수입니다.
 * */

void *zh_malloc(size_t size) {
  void *buf = malloc(size);
  if (!buf) {
    fprintf(stderr, "Fatal error: unable to allocate memory.\n");
    exit(1);
  }
  return buf;
}

/*
 * This function is responsible for setting up the main listening socket used by the
 * web server.
 * 이 함수는 웹 서버에서 사용하는 기본 듣기(listening) 소켓을 설정하는 역할을 합니다.
 * main() 시작에서 사용 
 * */
int setup_listening_socket(int port) {
  int sock;
  struct sockaddr_in srv_addr;

  sock = socket(PF_INET, SOCK_STREAM, 0);
  if (sock == -1) fatal_error("socket()");

  int enable = 1;
  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0)
    fatal_error("setsockopt(SO_REUSEADDR)");

  memset(&srv_addr, 0, sizeof(srv_addr));
  srv_addr.sin_family = AF_INET;
  srv_addr.sin_port = htons(port); // 빅 엔디안(Big Endian)으로 변환, "Host to Network Short(16bits)"
  srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // "Host to Network Long(32bits)"

  /* We bind to a port and turn this socket into a listening socket.
   * 포트에 바인딩하고 이 소켓을 듣기 소켓으로 바꿉니다.
   * */
  if (bind(sock, (const struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0)
    fatal_error("bind()");

  if (listen(sock, 10) < 0)
    fatal_error("listen()");

  return (sock);
}
// server_loop()에서 사용 
int add_accept_request(int server_socket, struct sockaddr_in *client_addr, socklen_t *client_addr_len) {
  struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
  io_uring_prep_accept(sqe, server_socket, (struct sockaddr *) client_addr, client_addr_len, 0);
  struct request *req = malloc(sizeof(*req));
  req->event_type = EVENT_TYPE_ACCEPT;
  io_uring_sqe_set_data(sqe, req);
  io_uring_submit(&ring);
  return 0;
}
// server_loop()에서 사용 
int add_read_request(int client_socket) {
  struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
  struct request *req = malloc(sizeof(*req) + sizeof(struct iovec));
  req->iov[0].iov_base = malloc(READ_SZ);
  req->iov[0].iov_len = READ_SZ;
  req->event_type = EVENT_TYPE_READ;
  req->client_socket = client_socket;
  memset(req->iov[0].iov_base, 0, READ_SZ);
  /* Linux kernel 5.5 has support for readv, but not for recv() or read() */ ✅
  /* Linux 커널 5.5는 readv를 지원하지만, recv() 또는 read()는 지원하지 않습니다. */
  io_uring_prep_readv(sqe, client_socket, &req->iov[0], 1, 0);
  io_uring_sqe_set_data(sqe, req);
  io_uring_submit(&ring);
  return 0;
}
// _send_static_string_content(), handle_get_method()에서 사용
int add_write_request(struct request *req) {
  struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
  req->event_type = EVENT_TYPE_WRITE;
  io_uring_prep_writev(sqe, req->client_socket, req->iov, req->iovec_count, 0);
  io_uring_sqe_set_data(sqe, req);
  io_uring_submit(&ring);
  return 0;
}
// 바로 아래 handle_unimplemented_method(), handle_http_404()에서 사용 
void _send_static_string_content(const char *str, int client_socket) {
  struct request *req = zh_malloc(sizeof(*req) + sizeof(struct iovec));
  unsigned long slen = strlen(str);
  req->iovec_count = 1;
  req->client_socket = client_socket;
  req->iov[0].iov_base = zh_malloc(slen);
  req->iov[0].iov_len = slen;
  memcpy(req->iov[0].iov_base, str, slen);
  add_write_request(req);
}

/*
 * When ZeroHTTPd encounters any other HTTP method other than GET or POST, this function
 * is used to inform the client.
 * ZeroHTTPd는 GET 또는 POST 이외의 다른 HTTP 메소드를 발견하면 이 함수를 사용하여 클라이언트에 알립니다.
 * */

void handle_unimplemented_method(int client_socket) {
  _send_static_string_content(unimplemented_content, client_socket);
}

/*
 * This function is used to send a "HTTP Not Found" code and message to the client in
 * case the file requested is not found.
 * 이 기능은 요청한 파일을 찾을 수 없는 경우 "HTTP Not Found" 코드와 메시지를 클라이언트에 보내는 데 사용됩니다.
 * */

void handle_http_404(int client_socket) {
  _send_static_string_content(http_404_content, client_socket);
}

/*
 * Once a static file is identified to be served, this function is used to read the file
 * and write it over the client socket using Linux's sendfile() system call. This saves us
 * the hassle of transferring file buffers from kernel to user space and back.
 * 제공할 정적 파일이 식별되면 이 함수는 파일을 읽고 Linux의 sendfile() 시스템 호출을 사용하여 
 * 클라이언트 소켓에 쓰는 데 사용됩니다.
 * 이는 파일 버퍼를 커널에서 사용자 공간으로 전송하고 그 반대로 전송하는 번거로움을 줄여줍니다.
 * */
// handle_get_method()에서 사용 
void copy_file_contents(char *file_path, off_t file_size, struct iovec *iov) {
  int fd;

  char *buf = zh_malloc(file_size);
  fd = open(file_path, O_RDONLY);
  if (fd < 0) fatal_error("read");

  /* We should really check for short reads here */
  int ret = read(fd, buf, file_size);
  if (ret < file_size) {
    fprintf(stderr, "Encountered a short read.\n"); // "짧은 읽기를 만났습니다."
  }
  close(fd);

  iov->iov_base = buf;
  iov->iov_len = file_size;
}

/*
 * Simple function to get the file extension of the file that we are about to serve.
 * 우리가 제공하려는 파일의 파일 확장자를 가져오는 간단한 함수입니다.
 * */
// 바로 아래 send_headers()에서 사용 
const char *get_filename_ext(const char *filename) {
  const char *dot = strrchr(filename, '.');
  if (!dot || dot == filename) return "";
  return dot + 1;
}

/*
 * Sends the HTTP 200 OK header, the server string, for a few types of files, it can also
 * send the content type based on the file extension. It also sends the content length
 * header. Finally it send a '\r\n' in a line by itself signalling the end of headers
 * and the beginning of any content.
 * 몇 가지 유형의 파일에 대해 서버 문자열인 HTTP 200 OK 헤더를 전송하며, 파일 확장자를 기반으로 
 * 콘텐츠 유형을 전송할 수도 있습니다. 또한 콘텐츠 길이 헤더도 보냅니다.
 * 마지막으로 헤더의 끝과 콘텐츠의 시작을 알리는 '\r\n'을 한 줄로 보냅니다.
 * */

void send_headers(const char *path, off_t len, struct iovec *iov) {
  char small_case_path[1024];
  char send_buffer[1024];
  strcpy(small_case_path, path);
  strtolower(small_case_path);

  char *str = "HTTP/1.0 200 OK\r\n";
  unsigned long slen = strlen(str);
  iov[0].iov_base = zh_malloc(slen);
  iov[0].iov_len = slen;
  memcpy(iov[0].iov_base, str, slen);

  slen = strlen(SERVER_STRING); // "Server: zerohttpd/0.1\r\n"
  iov[1].iov_base = zh_malloc(slen);
  iov[1].iov_len = slen;
  memcpy(iov[1].iov_base, SERVER_STRING, slen);

  /*
   * Check the file extension for certain common types of files
   * on web pages and send the appropriate content-type header.
   * Since extensions can be mixed case like JPG, jpg or Jpg,
   * we turn the extension into lower case before checking.
   * 웹 페이지에서 특정 일반적인 유형의 파일에 대한 파일 확장자를 확인하고 적절한 콘텐츠 유형 헤더를 보냅니다.
   * 확장자는 JPG, jpg, Jpg 등 대소문자가 혼용될 수 있으므로 확장자를 소문자로 변환한 후 확인합니다.
   * */
  const char *file_ext = get_filename_ext(small_case_path);
  if (strcmp("jpg", file_ext) == 0)  strcpy(send_buffer, "Content-Type: image/jpeg\r\n");
  if (strcmp("jpeg", file_ext) == 0) strcpy(send_buffer, "Content-Type: image/jpeg\r\n");
  if (strcmp("png", file_ext) == 0)  strcpy(send_buffer, "Content-Type: image/png\r\n");
  if (strcmp("gif", file_ext) == 0)  strcpy(send_buffer, "Content-Type: image/gif\r\n");
  if (strcmp("htm", file_ext) == 0)  strcpy(send_buffer, "Content-Type: text/html\r\n");
  if (strcmp("html", file_ext) == 0) strcpy(send_buffer, "Content-Type: text/html\r\n");
  if (strcmp("js", file_ext) == 0)   strcpy(send_buffer, "Content-Type: application/javascript\r\n");
  if (strcmp("css", file_ext) == 0)  strcpy(send_buffer, "Content-Type: text/css\r\n");
  if (strcmp("txt", file_ext) == 0)  strcpy(send_buffer, "Content-Type: text/plain\r\n");
  slen = strlen(send_buffer);
  iov[2].iov_base = zh_malloc(slen);
  iov[2].iov_len = slen;
  memcpy(iov[2].iov_base, send_buffer, slen);

  /* Send the content-length header, which is the file size in this case. 
   * 이 경우 파일 크기인 콘텐츠 길이 헤더를 보냅니다. */
  sprintf(send_buffer, "content-length: %ld\r\n", len);
  slen = strlen(send_buffer);
  iov[3].iov_base = zh_malloc(slen);
  iov[3].iov_len = slen;
  memcpy(iov[3].iov_base, send_buffer, slen);

  /*
   * When the browser sees a '\r\n' sequence in a line on its own,
   * it understands there are no more headers. Content may follow.
   * 브라우저가 한 줄에서 '\r\n' 시퀀스를 자체적으로 보면 더 이상 헤더가 없다는 것을 이해합니다. 
   * 내용(Content)이 따를 수 있습니다.
   * */
  strcpy(send_buffer, "\r\n"); // 한 줄에 '\r\n'만 있으면 헤더 끝을 나타냅니다. 
  slen = strlen(send_buffer);
  iov[4].iov_base = zh_malloc(slen);
  iov[4].iov_len = slen;
  memcpy(iov[4].iov_base, send_buffer, slen);
}

// handle_http_method()에서 사용
void handle_get_method(char *path, int client_socket) {
  char final_path[1024];

  /*
   If a path ends in a trailing slash, the client probably wants the index
   file inside of that directory.
   경로가 후행 슬래시로 끝나는 경우 클라이언트는 아마도 해당 디렉터리 내부에 인덱스 파일을 원할 것입니다.
   */
  if (path[strlen(path) - 1] == '/') {
    strcpy(final_path, "public");
    strcat(final_path, path);
    strcat(final_path, "index.html");
  } else {
    strcpy(final_path, "public");
    strcat(final_path, path);
  }

  /* The stat() system call will give you information about the file
   * like type (regular file, directory, etc), size, etc. 
   * stat() 시스템 호출은 유형(일반 파일, 디렉터리 등), 크기 등과 같은 파일에 대한 정보를 제공합니다.
   */
  struct stat path_stat;
  if (stat(final_path, &path_stat) == -1) {
    printf("404 Not Found: %s (%s)\n", final_path, path);
    handle_http_404(client_socket);
  } else {
    /* Check if this is a normal/regular file and not a directory or something else */
	/* 이것이 디렉토리나 다른 것이 아닌 일반(normal/regular) 파일인지 확인하십시오. */
    if (S_ISREG(path_stat.st_mode)) {
      struct request *req = zh_malloc(sizeof(*req) + (sizeof(struct iovec) * 6));
      req->iovec_count = 6;
      req->client_socket = client_socket;
      send_headers(final_path, path_stat.st_size, req->iov);
      copy_file_contents(final_path, path_stat.st_size, &req->iov[5]);
      printf("200 %s %ld bytes\n", final_path, path_stat.st_size);
      add_write_request( req);
    } else {
      handle_http_404(client_socket);
      printf("404 Not Found: %s\n", final_path);
    }
  }
}

/*
 * This function looks at method used and calls the appropriate handler function.
 * Since we only implement GET and POST methods, it calls handle_unimplemented_method()
 * in case both these don't match. This sends an error to the client.
 * 이 함수는 사용된 메소드를 살펴보고 적절한 핸들러 함수를 호출합니다.
 * 우리는 GET 및 POST 메소드만 구현하므로 둘 다 일치하지 않는 경우에는 handle_unimplemented_method()를 호출합니다.
 * 그러면 클라이언트에 오류가 전송됩니다.
 * */
// handle_client_request()에서 사용
void handle_http_method(char *method_buffer, int client_socket) {
  char *method, *path, *saveptr;

  method = strtok_r(method_buffer, " ", &saveptr);
  strtolower(method);
  path = strtok_r(NULL, " ", &saveptr);

  if (strcmp(method, "get") == 0) {
    handle_get_method(path, client_socket);
  } else {
    handle_unimplemented_method(client_socket);
  }
}
// 바로 아래 handle_client_request()에서 사용
int get_line(const char *src, char *dest, int dest_sz) {
  for (int i = 0; i < dest_sz; i++) {
    dest[i] = src[i];
    if (src[i] == '\r' && src[i+1] == '\n') {
      dest[i] = '\0';
      return 0; // 정상
    }
  }
  return 1; // 에러 
}
// server_loop()에서 사용
int handle_client_request(struct request *req) {
  char http_request[1024];
  /* Get the first line, which will be the request */
  if(get_line(req->iov[0].iov_base, http_request, sizeof(http_request))) {
    fprintf(stderr, "Malformed request\n");
    exit(1);
  }
  handle_http_method(http_request, req->client_socket);
  return 0;
}
// main()에서 사용 
/* ------------------------------------------------------------
  server_loop() 요약 
    case EVENT_TYPE_ACCEPT:
      add_accept_request(server_socket, &client_addr, &client_addr_len);
  	    req->event_type = EVENT_TYPE_ACCEPT;
      add_read_request(cqe->res);
  	    req->event_type = EVENT_TYPE_READ;
  	    io_uring_prep_readv(sqe, client_socket, &req->iov[0], 1, 0);
    case EVENT_TYPE_READ:
      handle_client_request(req);
        handle_http_method(http_request, req->client_socket);
  	    handle_get_method(path, client_socket);
          send_headers(final_path, path_stat.st_size, req->iov);
          copy_file_contents(final_path, path_stat.st_size, &req->iov[5]);
          add_write_request( req);
  		    req->event_type = EVENT_TYPE_WRITE;	
  			io_uring_prep_writev(sqe, req->client_socket, req->iov, req->iovec_count, 0);
    case EVENT_TYPE_WRITE:
      close(req->client_socket);
------------------------------------------------------------ */
void server_loop(int server_socket) {
  struct io_uring_cqe *cqe;
  struct sockaddr_in client_addr;
  socklen_t client_addr_len = sizeof(client_addr);

  add_accept_request(server_socket, &client_addr, &client_addr_len);

  while (1) {
    int ret = io_uring_wait_cqe(&ring, &cqe);
    struct request *req = (struct request *) cqe->user_data;
    if (ret < 0) fatal_error("io_uring_wait_cqe");
    if (cqe->res < 0) {
      fprintf(stderr, "Async request failed: %s for event: %d\n",
                       strerror(-cqe->res), req->event_type);
      exit(1);
    }

    switch (req->event_type) {
      case EVENT_TYPE_ACCEPT:
        add_accept_request(server_socket, &client_addr, &client_addr_len);
        add_read_request(cqe->res);
        free(req);
        break;
      case EVENT_TYPE_READ:
        if (!cqe->res) {
          fprintf(stderr, "Empty request!\n");
          break;
        }
        handle_client_request(req);
        free(req->iov[0].iov_base);
        free(req);
        break;
      case EVENT_TYPE_WRITE:
        for (int i = 0; i < req->iovec_count; i++) {
          free(req->iov[i].iov_base);
        }
        close(req->client_socket);
        free(req);
        break;
    }
    /* Mark this request as processed */
    io_uring_cqe_seen(&ring, cqe);
  }
}

void sigint_handler(int signo) {
  printf("^C pressed. Shutting down.\n");
  io_uring_queue_exit(&ring);
  exit(0);
}

int main() {
  int server_socket = setup_listening_socket(DEFAULT_SERVER_PORT); // 8000

  signal(SIGINT, sigint_handler);
  io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
  server_loop(server_socket);

  return 0;
}

📦 Running this program

이 프로그램을 사용하려면 index.html 파일과 함께 사용할 이미지가 있는 "public(공용)" 폴더가 포함된 디렉터리에서 실행해야 합니다. 예제 프로그램의 빌드 지침을 따랐다면 새로 빌드된 바이너리가 빌드(build) 디렉터리에 있어야 합니다. "public" 폴더가 있는 git repo의 루트 디렉터리로 변경하여 실행해야 합니다. 모든 예제를 빌드하고 이 웹 서버 예제를 실행하는 샘플 세션은 다음과 같습니다.
$ mkdir build $ cd build $ cmake .. $ cmake --build . $ cd .. $ build/webserver_liburing Minimum kernel version required is: 5.5 Your kernel version is: 5.6 ZeroHTTPd listening on port: 8000

📦 Program structure

무엇보다 먼저 main() 함수는 setup_listening_socket()을 호출하여 지정된 포트에서 수신 대기합니다. 그러나 실제로 연결을 수락하기 위해 accept()를 호출하지는 않습니다. 나중에 설명하겠지만 'io_uring'에 대한 요청을 통해 이를 수행합니다.

프로그램의 핵심은 'io_uring'에 대한 제출(자체 및 다른 함수를 통해)을 발행하고 완료 대기열 항목을 기다리고 이를 처리하는 server_loop() 함수입니다. 좀 더 자세히 살펴보겠습니다.

SQE를 얻고 'liburing'에서 io_uring_prep_accept()를 사용하여 제출할 accept() 작업을 준비합니다. 우리는 각 제출물을 추적하기 위해 구조체 요청을 사용합니다. 이러한 인스턴스에는 한 상태에서 다음 상태로 진행되는 각 요청의 컨텍스트가 있습니다. 구조체 요청을 살펴보겠습니다.
struct request { int event_type; int iovec_count; int client_socket; struct iovec iov[]; };

⚛ 원문

Email 답글이 올라오면 이메일로 알려드리겠습니다.