1. 유닉스 도메인 소켓(UDS, Unix Domain Socket)

unix_socket = socket(AF_UNIX, type, 0);
error = socketpair(AF_UNIX, 0, int sv[2]);

유닉스 도메인 소켓은 로컬 프로세스 간의 효과적인 IPC에 쓰이는 소켓으로, AF_UNIX 소켓 패밀리에 속한다. Nginx에서의 IPC는 대부분 이 UDS를 통해 이루어진다.

타입	SOCK_STREAM	SOCK_DGRAM	SOCK_SEQPACKET
연결 방식	연결 지향적	비연결 지향적	연결 지향적
신뢰성	데이터 순서, 무손실 보장.	메시지 손실 가능	데이터 순서, 무손실 보장.
메시지 경계	경계 없음	경계 보존	경계 보존

소켓인만큼 bind(), connect(), sendto()와 같은 시스템 콜들을 이용할 수 있는데, 이때 필요한 소켓 주소는 다음과 같은 구조로 이루어져있다.

struct sockaddr_un {
	sa_family_t sun_family;             /* AF_UNIX */
	char        sun_path[108];          /* Pathname */
}

소켓 주소의 유형도 다음과 같은 세 가지로 구분될 수 있는데, 여기서는 UDS를 따로 만들어 바인드하지는 않고, 양방향 파이프처럼 사용하기 위한 socketpair()를 자주 사용해서, 전부 Unnamed라고 봐도 될 것 같다.

구분	Pathname	Unnamed	Abstract
파일 시스템	생성 (실제 I/O 발생은 X)	없음	없음
보안	파일 권한 적용	프로세스 간만 가능	권한 문제 없음
정리	unlink()	자동 해제	자동 해제
사용 예	일반적인 IPC	언바운드, socketpair()	임시/보안 통신

자세한 내용은 man unix에서 확인할 수 있습니다.

2. 소스 코드 계속 읽어 보기 (continue)

/src/os/unix/ngx_process_cycle.c

프로세스 시그널들을 블록하면서 마스터 프로세스 사이클을 시작한다. 프로세스의 작업을 수행하다 예상치 못한 신호로 인해 비정상적으로 중단되는 경우를 방지하기 위함이다.

// 
void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
    char              *title;
    u_char            *p;
    size_t             size;
    ngx_int_t          i;
    ngx_uint_t         sigio;
    sigset_t           set;
    struct itimerval   itv;
    ngx_uint_t         live;
    ngx_msec_t         delay;
    ngx_core_conf_t   *ccf;

	/**
		프로세스 시그널 블록
	*/

	/**
		마스터 프로세스 시작 메시지 + 타이틀 출력 
	*/

	//ngx_init_cycle()에서 저장했던 컨텍스트
    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

	/**
		컨텍스트 안에 몇 개의 워커 프로세스를 만들지가 들어있다(default: 1)
	    NGX_PROCESS_RESPAWN == -3
    */
    ngx_start_worker_processes(cycle, ccf->worker_processes,
                               NGX_PROCESS_RESPAWN);
    ngx_start_cache_manager_processes(cycle, 0);

	//...
    
    for ( ;; ) {
		/**
			강제 종료 시 워커 프로세스들을 종료하기 위한 딜레이 처리
		*/

        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend");

		//블록된 시그널들을 제외한 시그널들에 대한 수신 대기
        sigsuspend(&set);

        ngx_time_update();

        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "wake up, sigio %i", sigio);

        /**
	        종료, 강제 종료, 재설정, 재시작 등을 처리
		*/
    }
}

다음으로는 설정된 n개의 워커 프로세스를 생성하고, 마스터-워커의 IPC를 위한 유닉스 도메인 소켓을 생성하고 설정한다.

static void
ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
{
    ngx_int_t  i;

    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");

    for (i = 0; i < n; i++) {

        ngx_spawn_process(cycle, ngx_worker_process_cycle,
                          (void *) (intptr_t) i, "worker process", type);

        ngx_pass_open_channel(cycle);
    }

/src/os/unix/ngx_process.c

아래는 프로세스 생성 및 생성한 프로세스와의 통신을 위한 유닉스 도메인 소켓을 만드는 과정이다.

ngx_pid_t
ngx_spawn_process(ngx_cycle_t *cycle, ngx_spawn_proc_pt proc, void *data,
    char *name, ngx_int_t respawn)
{
    u_long     on;
    ngx_pid_t  pid;
    ngx_int_t  s;

    if (respawn >= 0) {
        s = respawn;
    } else {
	    //사용할 수 있는 슬롯을 찾기
        for (s = 0; s < ngx_last_process; s++) {
            if (ngx_processes[s].pid == -1) {
                break;
            }
        }

		//현재 너무 많은 프로세스를 만든 경우
        if (s == NGX_MAX_PROCESSES) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                          "no more than %d processes can be spawned",
                          NGX_MAX_PROCESSES);
            return NGX_INVALID_PID;
        }
    }

	//NGX_PROCESS_DETACHED: 마스터와는 독립적으로 실행되는 프로세스인 경우
    if (respawn != NGX_PROCESS_DETACHED) {

		/**
			독립 프로세스가 아닌 경우 IPC를 위한 유닉스 도메인 소켓 페어를 생성.
		    두 프로세스는 여기서 만들어진 소켓을 사용해 서로 통신한다.
		    channel[0]: 마스터가 사용, channel[1]: 워커가 사용.
        */
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, ngx_processes[s].channel) == -1)
        {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "socketpair() failed while spawning \"%s\"", name);
            return NGX_INVALID_PID;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
                       "channel %d:%d",
                       ngx_processes[s].channel[0],
                       ngx_processes[s].channel[1]);

		/**
			생성한 두 소켓을 논블로킹으로 만듦
		*/

		/**
			마스터 프로세스의 소켓을 비동기 + SIGIO를 받도록 설정
			: 마스터는 다른 일을 하다 워커로부터 메시지가 오면 그 일을 처리한다.
			: 워커는 epoll 등으로 마스터로부터의 메시지를 가져와 처리
		*/

		/**
			이외 소켓 설정
		*/
		
		//워커가 마스터와 통신하기 위해 사용할 소켓 FD를 channel[1]로 지정
        ngx_channel = ngx_processes[s].channel[1];

    } else {//독립적인 프로세스인 경우에는 IPC 채널을 따로 만들지 않아도 됨
        ngx_processes[s].channel[0] = -1;
        ngx_processes[s].channel[1] = -1;
    }

    ngx_process_slot = s;

	//드디어 자식 프로세스를 만듦!!
    pid = fork();

    switch (pid) {

    case -1://실패한 경우
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "fork() failed while spawning \"%s\"", name);
        ngx_close_channel(ngx_processes[s].channel, cycle->log);
        return NGX_INVALID_PID;

    case 0://자식 프로세스인 경우
        ngx_parent = ngx_pid;
        ngx_pid = ngx_getpid();
        proc(cycle, data);//해당 자식 프로세스로서의 생명 주기를 시작
        break;

    default://부모 프로세스인 경우
        break;
    }

    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start %s %P", name, pid);

	/**
		새롭게 생성한 프로세스 관련 정보들을 유지하기 위해 저장
	*/

	//마지막 프로세스 번호인 경우 늘려줌
	if (s == ngx_last_process) {
        ngx_last_process++;
    }

    return pid;
}

아래의 ngx_pass_open_channel()은 이전에 만들었던 다른 프로세스들에게 새로운 프로세스가 생겼음을 알리고, channel[0]을 공유하도록 한다. 따로 공유하지 않았다면 워커 프로세스끼리의 통신은 꼭 마스터를 경유해서만 이루어질 수 있었겠지만, 이제는 곧바로 다른 프로세스에 메시지를 보낼 수 있게 된다.

static void
ngx_pass_open_channel(ngx_cycle_t *cycle)
{
    ngx_int_t      i;
    ngx_channel_t  ch;

    ngx_memzero(&ch, sizeof(ngx_channel_t));

    ch.command = NGX_CMD_OPEN_CHANNEL;
    ch.pid = ngx_processes[ngx_process_slot].pid;
    ch.slot = ngx_process_slot;
    ch.fd = ngx_processes[ngx_process_slot].channel[0];

    for (i = 0; i < ngx_last_process; i++) {

        if (i == ngx_process_slot
            || ngx_processes[i].pid == -1
            || ngx_processes[i].channel[0] == -1)
        {
            continue;
        }

        ngx_log_debug6(NGX_LOG_DEBUG_CORE, cycle->log, 0,
                      "pass channel s:%i pid:%P fd:%d to s:%i pid:%P fd:%d",
                      ch.slot, ch.pid, ch.fd,
                      i, ngx_processes[i].pid,
                      ngx_processes[i].channel[0]);

        /* TODO: NGX_AGAIN */

        ngx_write_channel(ngx_processes[i].channel[0],
                          &ch, sizeof(ngx_channel_t), cycle->log);
    }
}

Q. 프로세스는 독립적인 FD를 가지는데, 어떻게 FD 번호만 보내서 소켓을 공유할 수 있을까?
A. ngx_wite_channel()을 보면 컨트롤 메시지의 타입을 SCM_RIGHTS로 설정한다. SCM_RIGHTS를 설정하면 한 프로세스의 파일 디스크립터를 다른 프로세스로 전달할 수 있게 된다(꼭 같은 번호를 쓰게 되는 건 아님!). 세부 내용은 man unix로 볼 수 있다.

아까 만든 자식 프로세스는 아래의 사이클을 돌면서 비로소 이벤트를 처리하는 워커 프로세스로 거듭나게 된다.

//src/os/unix/ngx_process_cycle.c
static void
ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
{
    ngx_int_t worker = (intptr_t) data;

    ngx_process = NGX_PROCESS_WORKER;
    ngx_worker = worker;

    ngx_worker_process_init(cycle, worker);

    ngx_setproctitle("worker process");

    for ( ;; ) {

		/**
			종료 중일 때의 처리
		*/

        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");

		//이벤트가 있으면 처리
        ngx_process_events_and_timers(cycle);

		/**
			강제 종료 or 정상 종료 or 로그 파일 재오픈 처리
		*/
    }
}

다음은 워커 프로세스의 내부 구조와 소스 코드를 보도록 합시다.