fastcgi main

int main(int argc, char *argv[])
{
    int exit_status = FPM_EXIT_OK;
    int cgi = 0, c, use_extended_info = 0;
    zend_file_handle file_handle;

    /* temporary locals */
    int orig_optind = php_optind;
    char *orig_optarg = php_optarg;
    int ini_entries_len = 0;
    /* end of temporary locals */


    int max_requests = 500;
    int requests = 0;
    int fcgi_fd = 0;
    fcgi_request request;
    char *fpm_config = NULL;
    char *fpm_prefix = NULL;
    char *fpm_pid = NULL;
    int test_conf = 0;
    int force_daemon = -1;
    int php_information = 0;
    int php_allow_to_run_as_root = 0;


    sapi_startup(&cgi_sapi_module);
    cgi_sapi_module.php_ini_path_override = NULL;
    cgi_sapi_module.php_ini_ignore_cwd = 1;
    
    fcgi_init();



    while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
        switch (c) {
            case 'c':
                if (cgi_sapi_module.php_ini_path_override) {
                    free(cgi_sapi_module.php_ini_path_override);
                }
                cgi_sapi_module.php_ini_path_override = strdup(php_optarg);
                break;

            case 'n':
                cgi_sapi_module.php_ini_ignore = 1;
                break;

            case 'd': {
                /* define ini entries on command line */
                int len = strlen(php_optarg);
                char *val;

                if ((val = strchr(php_optarg, '='))) {
                    val++;
                    if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
                        cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
                        ini_entries_len += (val - php_optarg);
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len, "\"", 1);
                        ini_entries_len++;
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
                        ini_entries_len += len - (val - php_optarg);
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
                        ini_entries_len += sizeof("\n\0\"") - 2;
                    } else {
                        cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("\n\0"));
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
                        memcpy(cgi_sapi_module.ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
                        ini_entries_len += len + sizeof("\n\0") - 2;
                    }
                } else {
                    cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
                    memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
                    memcpy(cgi_sapi_module.ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
                    ini_entries_len += len + sizeof("=1\n\0") - 2;
                }
                break;
            }

            case 'y':
                fpm_config = php_optarg;
                break;

            case 'p':
                fpm_prefix = php_optarg;
                break;

            case 'g':
                fpm_pid = php_optarg;
                break;

            case 'e': /* enable extended info output */
                use_extended_info = 1;
                break;

            case 't': 
                test_conf++;
                break;

            case 'm': /* list compiled in modules */
                cgi_sapi_module.startup(&cgi_sapi_module);
                php_output_activate(TSRMLS_C);
                SG(headers_sent) = 1;
                php_printf("[PHP Modules]\n");
                print_modules(TSRMLS_C);
                php_printf("\n[Zend Modules]\n");
                print_extensions(TSRMLS_C);
                php_printf("\n");
                php_output_end_all(TSRMLS_C);
                php_output_deactivate(TSRMLS_C);
                fcgi_shutdown();
                exit_status = FPM_EXIT_OK;
                goto out;

            case 'i': /* php info & quit */
                php_information = 1;
                break;

            case 'R': /* allow to run as root */
                php_allow_to_run_as_root = 1;
                break;

            case 'D': /* daemonize */
                force_daemon = 1;
                break;

            case 'F': /* nodaemonize */
                force_daemon = 0;
                break;

            default:
            case 'h':
            case '?':
                cgi_sapi_module.startup(&cgi_sapi_module);
                php_output_activate(TSRMLS_C);
                SG(headers_sent) = 1;
                php_cgi_usage(argv[0]);
                php_output_end_all(TSRMLS_C);
                php_output_deactivate(TSRMLS_C);
                fcgi_shutdown();
                exit_status = (c == 'h') ? FPM_EXIT_OK : FPM_EXIT_USAGE;
                goto out;

            case 'v': /* show php version & quit */
                cgi_sapi_module.startup(&cgi_sapi_module);
                if (php_request_startup(TSRMLS_C) == FAILURE) {
                    SG(server_context) = NULL;
                    php_module_shutdown(TSRMLS_C);
                    return FPM_EXIT_SOFTWARE;
                }
                SG(headers_sent) = 1;
                SG(request_info).no_headers = 1;

#if ZEND_DEBUG
                php_printf("PHP %s (%s) (built: %s %s) (DEBUG)\nCopyright (c) 1997-2015 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__,        __TIME__, get_zend_version());
#else
                php_printf("PHP %s (%s) (built: %s %s)\nCopyright (c) 1997-2015 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__,      get_zend_version());
#endif
                php_request_shutdown((void *) 0);
                fcgi_shutdown();
                exit_status = FPM_EXIT_OK;
                goto out;
        }
    }

    if (php_information) {
        cgi_sapi_module.phpinfo_as_text = 1;
        cgi_sapi_module.startup(&cgi_sapi_module);
        if (php_request_startup(TSRMLS_C) == FAILURE) {
            SG(server_context) = NULL;
            php_module_shutdown(TSRMLS_C);
            return FPM_EXIT_SOFTWARE;
        }
        SG(headers_sent) = 1;
        SG(request_info).no_headers = 1;
        php_print_info(0xFFFFFFFF TSRMLS_CC);
        php_request_shutdown((void *) 0);
        fcgi_shutdown();
        exit_status = FPM_EXIT_OK;
        goto out;
    }

    /* No other args are permitted here as there is no interactive mode */
    if (argc != php_optind) {
        cgi_sapi_module.startup(&cgi_sapi_module);
        php_output_activate(TSRMLS_C);
        SG(headers_sent) = 1;
        php_cgi_usage(argv[0]);
        php_output_end_all(TSRMLS_C);
        php_output_deactivate(TSRMLS_C);
        fcgi_shutdown();
        exit_status = FPM_EXIT_USAGE;
        goto out;
    }

    php_optind = orig_optind;
    php_optarg = orig_optarg;


    cgi_sapi_module.additional_functions = additional_functions;
    cgi_sapi_module.executable_location = argv[0];

    /* startup after we get the above ini override se we get things right */
    if (cgi_sapi_module.startup(&cgi_sapi_module) == FAILURE) {

        return FPM_EXIT_SOFTWARE;
    }
    
    if (use_extended_info) {
        CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
    }

    /* check force_cgi after startup, so we have proper output */
    if (cgi && CGIG(force_redirect)) {
        /* Apache will generate REDIRECT_STATUS,
         * Netscape and redirect.so will generate HTTP_REDIRECT_STATUS.
         * redirect.so and installation instructions available from
         * http://www.koehntopp.de/php.
         *   -- kk@netuse.de
         */
        if (!getenv("REDIRECT_STATUS") &&
            !getenv ("HTTP_REDIRECT_STATUS") &&
            /* this is to allow a different env var to be configured
             * in case some server does something different than above */
            (!CGIG(redirect_status_env) || !getenv(CGIG(redirect_status_env)))
        ) {
            zend_try {
                SG(sapi_headers).http_response_code = 400;
                PUTS("<b>Security Alert!</b> The PHP CGI cannot be accessed directly.\n\n\
<p>This PHP CGI binary was compiled with force-cgi-redirect enabled.  This\n\
means that a page will only be served up if the REDIRECT_STATUS CGI variable is\n\
set, e.g. via an Apache Action directive.</p>\n\
<p>For more information as to <i>why</i> this behaviour exists, see the <a href=\"http://php.net/security.cgi-bin\">\
manual page for CGI security</a>.</p>\n\
<p>For more information about changing this behaviour or re-enabling this webserver,\n\
consult the installation file that came with this distribution, or visit \n\
<a href=\"http://php.net/install.windows\">the manual page</a>.</p>\n");
            } zend_catch {
            } zend_end_try();
#if defined(ZTS) && !defined(PHP_DEBUG)
            /* XXX we're crashing here in msvc6 debug builds at
             * php_message_handler_for_zend:839 because
             * SG(request_info).path_translated is an invalid pointer.
             * It still happens even though I set it to null, so something
             * weird is going on.
             */
            tsrm_shutdown();
#endif
            return FPM_EXIT_SOFTWARE;
        }
    }

　　 //fpm_init的初始化
    if (0 > fpm_init(argc, argv, fpm_config ? fpm_config : CGIG(fpm_config), fpm_prefix, fpm_pid, test_conf, php_allow_to_run_as_root, force_daemon)) {

        if (fpm_globals.send_config_pipe[1]) {
            int writeval = 0;
            zlog(ZLOG_DEBUG, "Sending \"0\" (error) to parent via fd=%d", fpm_globals.send_config_pipe[1]);
            write(fpm_globals.send_config_pipe[1], &writeval, sizeof(writeval));
            close(fpm_globals.send_config_pipe[1]);
        }
        return FPM_EXIT_CONFIG;
    }

    if (fpm_globals.send_config_pipe[1]) {
        int writeval = 1;
        zlog(ZLOG_DEBUG, "Sending \"1\" (OK) to parent via fd=%d", fpm_globals.send_config_pipe[1]);
        write(fpm_globals.send_config_pipe[1], &writeval, sizeof(writeval));
        close(fpm_globals.send_config_pipe[1]);
    }
    fpm_is_running = 1;

　　 //开始执行
    fcgi_fd = fpm_run(&max_requests);
  
    //父进程处理的工作是在fpm_event_loop,是个无限死循环

　　parent = 0; /* onced forked tell zlog to also send messages through sapi_cgi_log_fastcgi() */ zlog_set_external_logger(sapi_cgi_log_fastcgi); /* make php call us to get _ENV vars */ php_php_import_environment_variables = php_import_environment_variables; php_import_environment_variables = cgi_php_import_environment_variables; 　　 
　　 //下面都是子进程要处理的工作了

    /* library is already initialized, now init our request */
    fcgi_init_request(&request, fcgi_fd);

    zend_first_try {
        while (fcgi_accept_request(&request) >= 0) {
            char *primary_script = NULL;
            request_body_fd = -1;
            SG(server_context) = (void *) &request;
            init_request_info(TSRMLS_C);
            CG(interactive) = 0;

            fpm_request_info();

            /* request startup only after we've done all we can to
             *            get path_translated */
            if (php_request_startup(TSRMLS_C) == FAILURE) {
                fcgi_finish_request(&request, 1);
                SG(server_context) = NULL;
                php_module_shutdown(TSRMLS_C);
                return FPM_EXIT_SOFTWARE;
            }

            /* check if request_method has been sent.
             * if not, it's certainly not an HTTP over fcgi request */
            if (!SG(request_info).request_method) {
                goto fastcgi_request_done;
            }

            if (fpm_status_handle_request(TSRMLS_C)) {
                goto fastcgi_request_done;
            }

            /* If path_translated is NULL, terminate here with a 404 */
            if (!SG(request_info).path_translated) {
                zend_try {
                    zlog(ZLOG_DEBUG, "Primary script unknown");
                    SG(sapi_headers).http_response_code = 404;
                    PUTS("File not found.\n");
                } zend_catch {
                } zend_end_try();
                goto fastcgi_request_done;
            }

            if (fpm_php_limit_extensions(SG(request_info).path_translated)) {
                SG(sapi_headers).http_response_code = 403;
                PUTS("Access denied.\n");
                goto fastcgi_request_done;
            }

            /* 
             * have to duplicate SG(request_info).path_translated to be able to log errrors
             * php_fopen_primary_script seems to delete SG(request_info).path_translated on failure
             */
            primary_script = estrdup(SG(request_info).path_translated);

            /* path_translated exists, we can continue ! */
            if (php_fopen_primary_script(&file_handle TSRMLS_CC) == FAILURE) {
                zend_try {
                    zlog(ZLOG_ERROR, "Unable to open primary script: %s (%s)", primary_script, strerror(errno));
                    if (errno == EACCES) {
                        SG(sapi_headers).http_response_code = 403;
                        PUTS("Access denied.\n");
                    } else {
                        SG(sapi_headers).http_response_code = 404;
                        PUTS("No input file specified.\n");
                    }
                } zend_catch {
                } zend_end_try();
                /* we want to serve more requests if this is fastcgi
                 * so cleanup and continue, request shutdown is
                 * handled later */

                goto fastcgi_request_done;
            }

            fpm_request_executing();

            php_execute_script(&file_handle TSRMLS_CC);

fastcgi_request_done:
            if (primary_script) {
                efree(primary_script);
            }

            if (request_body_fd != -1) {
                close(request_body_fd);
            }
            request_body_fd = -2;

            if (EG(exit_status) == 255) {
                if (CGIG(error_header) && *CGIG(error_header)) {
                    sapi_header_line ctr = {0};

                    ctr.line = CGIG(error_header);
                    ctr.line_len = strlen(CGIG(error_header));
                    sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
                }
            }

            fpm_request_end(TSRMLS_C);
            fpm_log_write(NULL TSRMLS_CC);

            STR_FREE(SG(request_info).path_translated);
            SG(request_info).path_translated = NULL;

            php_request_shutdown((void *) 0);

            requests++;
            if (max_requests && (requests == max_requests)) {
                fcgi_finish_request(&request, 1);
                break;
            }
            /* end of fastcgi loop */
        }
        fcgi_shutdown();

        if (cgi_sapi_module.php_ini_path_override) {
            free(cgi_sapi_module.php_ini_path_override);
        }
        if (cgi_sapi_module.ini_entries) {
            free(cgi_sapi_module.ini_entries);
        }
    } zend_catch {
        exit_status = FPM_EXIT_SOFTWARE;
    } zend_end_try();

out:

    SG(server_context) = NULL;
    if (parent) {
        php_module_shutdown(TSRMLS_C);
        sapi_shutdown();
    }


    return exit_status;
}

int fpm_init(int argc, char **argv, char *config, char *prefix, char *pid, int test_conf, int run_as_root, int force_daemon) /* {{{ */
{
    fpm_globals.argc = argc;
    fpm_globals.argv = argv;
    if (config && *config) {
        fpm_globals.config = strdup(config);
    }
    fpm_globals.prefix = prefix;
    fpm_globals.pid = pid;
    fpm_globals.run_as_root = run_as_root;

    if (0 > fpm_php_init_main()           ||
        0 > fpm_stdio_init_main()         ||  //io输出重定向到/dev/null
        0 > fpm_conf_init_main(test_conf, force_daemon) || //加载php-fpm.conf配置文件
        0 > fpm_unix_init_main()          ||  //得到主进程pid,并写到fpm_globals.parent_pid里
        0 > fpm_scoreboard_init_main()    ||
        0 > fpm_pctl_init_main()          ||
        0 > fpm_env_init_main()           || //环境变量初始化
        0 > fpm_signals_init_main()       || //信号的初始化以及设置回调函数
        0 > fpm_children_init_main()      ||
        0 > fpm_sockets_init_main()       || //建立socket，绑定bind,监听listen
        0 > fpm_worker_pool_init_main()   || 
        0 > fpm_event_init_main()) {　　　　　　//调用epoll_create;并将套接字放到epoll_ctl里

        if (fpm_globals.test_successful) {
            exit(FPM_EXIT_OK);
        } else {
            zlog(ZLOG_ERROR, "FPM initialization failed");
            return -1;
        }
    }

    if (0 > fpm_conf_write_pid()) {   //将主进程的pid写进文件
        zlog(ZLOG_ERROR, "FPM initialization failed");
        return -1;
    }

    fpm_stdio_init_final();
    zlog(ZLOG_NOTICE, "fpm is running, pid %d", (int) fpm_globals.parent_pid);

    return 0;
}

int fpm_stdio_init_main() /* {{{ */
{
    int fd = open("/dev/null", O_RDWR);

    if (0 > fd) {
        zlog(ZLOG_SYSERROR, "failed to init stdio: open(\"/dev/null\")");
        return -1;
    }

    if (0 > dup2(fd, STDIN_FILENO) || 0 > dup2(fd, STDOUT_FILENO)) {
        zlog(ZLOG_SYSERROR, "failed to init stdio: dup2()");
        close(fd);
        return -1;
    }
    close(fd);
    return 0;
}

int fpm_signals_init_main() /* {{{ */
{
    struct sigaction act;
　　//利用socketpair创建全双工管道，但只是主进程使用
    if (0 > socketpair(AF_UNIX, SOCK_STREAM, 0, sp)) {
        zlog(ZLOG_SYSERROR, "failed to init signals: socketpair()");
        return -1;
    }

    if (0 > fd_set_blocked(sp[0], 0) || 0 > fd_set_blocked(sp[1], 0)) {
        zlog(ZLOG_SYSERROR, "failed to init signals: fd_set_blocked()");
        return -1;
    }

    if (0 > fcntl(sp[0], F_SETFD, FD_CLOEXEC) || 0 > fcntl(sp[1], F_SETFD, FD_CLOEXEC)) {
        zlog(ZLOG_SYSERROR, "falied to init signals: fcntl(F_SETFD, FD_CLOEXEC)");
        return -1;
    }

    memset(&act, 0, sizeof(act));
    act.sa_handler = sig_handler;
    sigfillset(&act.sa_mask);

    if (0 > sigaction(SIGTERM,  &act, 0) ||
        0 > sigaction(SIGINT,   &act, 0) ||
        0 > sigaction(SIGUSR1,  &act, 0) ||
        0 > sigaction(SIGUSR2,  &act, 0) ||
        0 > sigaction(SIGCHLD,  &act, 0) ||
        0 > sigaction(SIGQUIT,  &act, 0)) {

        zlog(ZLOG_SYSERROR, "failed to init signals: sigaction()");
        return -1;
    }
    return 0;
}

static void sig_handler(int signo) /* {{{ */
{
    static const char sig_chars[NSIG + 1] = {
        [SIGTERM] = 'T',
        [SIGINT]  = 'I',
        [SIGUSR1] = '1',
        [SIGUSR2] = '2',
        [SIGQUIT] = 'Q',
        [SIGCHLD] = 'C'
    };
    char s;
    int saved_errno;

    if (fpm_globals.parent_pid != getpid()) {
        /* prevent a signal race condition when child process
            have not set up it's own signal handler yet */
        return;
    }

    saved_errno = errno;
    s = sig_chars[signo];
    write(sp[1], &s, sizeof(s));
    errno = saved_errno;
}

int fpm_sockets_init_main() /* {{{ */
{
    unsigned i, lq_len;
    struct fpm_worker_pool_s *wp;
    char *inherited = getenv("FPM_SOCKETS");
    struct listening_socket_s *ls;
    if (0 == fpm_array_init(&sockets_list, sizeof(struct listening_socket_s), 10)) {
        return -1;
    }

    /* create all required sockets */
    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        switch (wp->listen_address_domain) {
            case FPM_AF_INET :
                wp->listening_socket = fpm_socket_af_inet_listening_socket(wp);
                break;

            case FPM_AF_UNIX :
                if (0 > fpm_unix_resolve_socket_premissions(wp)) {
                    return -1;
                }
                wp->listening_socket = fpm_socket_af_unix_listening_socket(wp);
                break;
        }

        if (wp->listening_socket == -1) {
            return -1;
        }

    if (wp->listen_address_domain == FPM_AF_INET && fpm_socket_get_listening_queue(wp->listening_socket, NULL, &lq_len) >= 0) {
            fpm_scoreboard_update(-1, -1, -1, (int)lq_len, -1, -1, 0, FPM_SCOREBOARD_ACTION_SET, wp->scoreboard);
        }
    }

    return 0;
}

static int fpm_socket_af_inet_listening_socket(struct fpm_worker_pool_s *wp) /* {{{ */
{
    struct addrinfo hints, *servinfo, *p;
    for (p = servinfo; p != NULL; p = p->ai_next) {
    inet_ntop(p->ai_family, fpm_get_in_addr(p->ai_addr), tmpbuf, INET6_ADDRSTRLEN);
    if (sock < 0) {
        if ((sock = fpm_sockets_get_listening_socket(wp, p->ai_addr, p->ai_addrlen)) != -1) {
            zlog(ZLOG_DEBUG, "Found address for %s, socket opened on %s", dup_address, tmpbuf);
        }
    } else {
        zlog(ZLOG_WARNING, "Found multiple addresses for %s, %s ignored", dup_address, tmpbuf);
    }

}

static int fpm_sockets_get_listening_socket(struct fpm_worker_pool_s *wp, struct sockaddr *sa, int socklen) /* {{{ */
{
    int sock;

    sock = fpm_sockets_hash_op(0, sa, 0, wp->listen_address_domain, FPM_GET_USE_SOCKET);
    if (sock >= 0) {
        return sock;
    }

    sock = fpm_sockets_new_listening_socket(wp, sa, socklen);
    fpm_sockets_hash_op(sock, sa, 0, wp->listen_address_domain, FPM_STORE_USE_SOCKET);

    return sock;
}

static int fpm_sockets_new_listening_socket(struct fpm_worker_pool_s *wp, struct sockaddr *sa, int socklen) /* {{{ */
{
    int flags = 1;
    int sock;
    mode_t saved_umask = 0;

    sock = socket(sa->sa_family, SOCK_STREAM, 0);

    if (0 > sock) {
        zlog(ZLOG_SYSERROR, "failed to create new listening socket: socket()");
        return -1;
    }

    if (0 > setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags))) {
        zlog(ZLOG_WARNING, "failed to change socket attribute");
    }

    if (wp->listen_address_domain == FPM_AF_UNIX) {
        if (fpm_socket_unix_test_connect((struct sockaddr_un *)sa, socklen) == 0) {
            zlog(ZLOG_ERROR, "An another FPM instance seems to already listen on %s", ((struct sockaddr_un *) sa)->sun_path);
            close(sock);
            return -1;
        }
        unlink( ((struct sockaddr_un *) sa)->sun_path);
        saved_umask = umask(0777 ^ wp->socket_mode);
    }

    if (0 > bind(sock, sa, socklen)) {
        zlog(ZLOG_SYSERROR, "unable to bind listening socket for address '%s'", wp->config->listen_address);
        if (wp->listen_address_domain == FPM_AF_UNIX) {
            umask(saved_umask);
        }
        close(sock);
        return -1;
    }

    if (wp->listen_address_domain == FPM_AF_UNIX) {
        char *path = ((struct sockaddr_un *) sa)->sun_path;

        umask(saved_umask);

        if (wp->socket_uid != -1 || wp->socket_gid != -1) {
            if (0 > chown(path, wp->socket_uid, wp->socket_gid)) {
                zlog(ZLOG_SYSERROR, "failed to chown() the socket '%s'", wp->config->listen_address);
                close(sock);
                return -1;
            }
        }
    }

    if (0 > listen(sock, wp->config->listen_backlog)) {
        zlog(ZLOG_SYSERROR, "failed to listen to address '%s'", wp->config->listen_address);
        close(sock);
        return -1;
    }

    return sock;
}

int fpm_event_init_main() /* {{{ */
{
    struct fpm_worker_pool_s *wp;
    int max;
　　 //moudule是个全局变量
    if (!module) {
        zlog(ZLOG_ERROR, "no event module found");
        return -1;
    }

    if (!module->wait) {
        zlog(ZLOG_ERROR, "Incomplete event implementation. Please open a bug report on https://bugs.php.net.");
        return -1;
    }

    /* count the max number of necessary fds for polling */
    max = 1; /* only one FD is necessary at startup for the master process signal pipe */
    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        if (!wp->config) continue;
　　　　　/*
　　　　　 *如果打开显示输出开头，那么max为最大子进程数量的2倍,再加1
　　　　　 *这个max就是epoll_create()函数里的参数,但意义不大,
         *重要的是epoll_wait()中的第二个参数,它是个数组，类型为struct epoll_event events[max]
　　　　  *假设开5个进程,那么max为5*2+1=11， 加1,这个1，就是信号(sigusr,sigquit等等)要使用,
　　　　　 */
　　　　　if (wp->config->catch_workers_output && wp->config->pm_max_children > 0) {
            max += (wp->config->pm_max_children * 2);
        }
    }
　　 //这时调用的就是epoll_create;epoll_ctl(efd,EPOLL_CTL_ADD,fd, {event.data.fd=fd.event.events=EPOLLIN} );
    if (module->init(max) < 0) {
        zlog(ZLOG_ERROR, "Unable to initialize the event module %s", module->name);
        return -1;
    }

    zlog(ZLOG_DEBUG, "event module is %s and %d fds have been reserved", module->name, max);

    if (0 > fpm_cleanup_add(FPM_CLEANUP_ALL, fpm_event_cleanup, NULL)) {
        return -1;
    }
    return 0;
}

/*    children: return listening socket
    parent: never return */
int fpm_run(int *max_requests) /* {{{ */
{
    struct fpm_worker_pool_s *wp;

    /* create initial children in all pools */
    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        int is_parent;

        is_parent = fpm_children_create_initial(wp);

        if (!is_parent) {
            goto run_child;
        }

        /* handle error */
        if (is_parent == 2) {
            fpm_pctl(FPM_PCTL_STATE_TERMINATING, FPM_PCTL_ACTION_SET);
            fpm_event_loop(1);
        }
    }

    /* run event loop forever */
    fpm_event_loop(0);

run_child: /* only workers reach this point */

    fpm_cleanups_run(FPM_CLEANUP_CHILD);

    *max_requests = fpm_globals.max_requests;
    return fpm_globals.listening_socket;
}

int fpm_children_create_initial(struct fpm_worker_pool_s *wp) /* {{{ */
{
    if (wp->config->pm == PM_STYLE_ONDEMAND) {
        wp->ondemand_event = (struct fpm_event_s *)malloc(sizeof(struct fpm_event_s));

        if (!wp->ondemand_event) {
            zlog(ZLOG_ERROR, "[pool %s] unable to malloc the ondemand socket event", wp->config->name);
            // FIXME handle crash
            return 1;
        }

        memset(wp->ondemand_event, 0, sizeof(struct fpm_event_s));
        fpm_event_set(wp->ondemand_event, wp->listening_socket, FPM_EV_READ | FPM_EV_EDGE, fpm_pctl_on_socket_accept, wp);
        wp->socket_event_set = 1;
        fpm_event_add(wp->ondemand_event, 0);

        return 1;
    }
    return fpm_children_make(wp, 0 /* not in event loop yet */, 0, 1);
}

int fpm_children_make(struct fpm_worker_pool_s *wp, int in_event_loop, int nb_to_spawn, int is_debug) /* {{{ */
{
    pid_t pid;
    struct fpm_child_s *child;
    int max;
    static int warned = 0;

    if (wp->config->pm == PM_STYLE_DYNAMIC) {
        if (!in_event_loop) { /* starting */
            max = wp->config->pm_start_servers;
        } else {
            max = wp->running_children + nb_to_spawn;
        }
    } else if (wp->config->pm == PM_STYLE_ONDEMAND) {
        if (!in_event_loop) { /* starting */
            max = 0; /* do not create any child at startup */
        } else {
            max = wp->running_children + nb_to_spawn;
        }
    } else { /* PM_STYLE_STATIC */
        max = wp->config->pm_max_children;
    }

    /*
     * fork children while:
     *   - fpm_pctl_can_spawn_children : FPM is running in a NORMAL state (aka not restart, stop or reload)
     *   - wp->running_children < max  : there is less than the max process for the current pool
     *   - (fpm_global_config.process_max < 1 || fpm_globals.running_children < fpm_global_config.process_max):
     *     if fpm_global_config.process_max is set, FPM has not fork this number of processes (globaly)
     */
    while (fpm_pctl_can_spawn_children() && wp->running_children < max && (fpm_global_config.process_max < 1 || fpm_globals.running_children < fpm_global_config.process_max)) {

        warned = 0;
        child = fpm_resources_prepare(wp); //创建管道，注意这里是循环,所以会创建多个管道，不需要全双工，
　　　　　　//因为只需要子进程向父进程汇报工作，子进程不需要自已保存日志，可让子进程专心处理php请求

        if (!child) {
            return 2;
        }

        pid = fork();

        switch (pid) {

            case 0 :
                fpm_child_resources_use(child); //子进程将stdout和stderr重定向到fd_stdout[1]和fd_stderr[1]中
                fpm_globals.is_child = 1;
                fpm_child_init(wp);
                return 0;

            case -1 :
                zlog(ZLOG_SYSERROR, "fork() failed");
　　　　　　　　　 fpm_resources_discard(child);
                return 2;

            default :
                child->pid = pid;
                fpm_clock_get(&child->started);
                fpm_parent_resources_use(child);//父进程将fd_stdout[0]和fd_stderr[0]写到epoll里，进行监听
                zlog(is_debug ? ZLOG_DEBUG : ZLOG_NOTICE, "[pool %s] child %d started", wp->config->name, (int) pid);
        }

    }

    if (!warned && fpm_global_config.process_max > 0 && fpm_globals.running_children >= fpm_global_config.process_max) {
        warned = 1;
        zlog(ZLOG_WARNING, "The maximum number of processes has been reached. Please review your configuration and consider raising 'process.max'");
    }

    return 1; /* we are done */
}

static struct fpm_child_s *fpm_resources_prepare(struct fpm_worker_pool_s *wp) /* {{{ */
{
    struct fpm_child_s *c;

    c = fpm_child_alloc();

    if (!c) {
        zlog(ZLOG_ERROR, "[pool %s] unable to malloc new child", wp->config->name);
        return 0;
    }

    c->wp = wp;
    c->fd_stdout = -1; c->fd_stderr = -1;

    if (0 > fpm_stdio_prepare_pipes(c)) { //创建两个管道
        fpm_child_free(c);
        return 0;
    }

    if (0 > fpm_scoreboard_proc_alloc(wp->scoreboard, &c->scoreboard_i)) {
        fpm_stdio_discard_pipes(c);
        fpm_child_free(c);
        return 0;
    }

    return c;
}

int fpm_stdio_prepare_pipes(struct fpm_child_s *child) /* {{{ */
{
    if (0 == child->wp->config->catch_workers_output) { /* not required */
        return 0;
    }

    if (0 > pipe(fd_stdout)) {
        zlog(ZLOG_SYSERROR, "failed to prepare the stdout pipe");
        return -1;
    }

    if (0 > pipe(fd_stderr)) {
        zlog(ZLOG_SYSERROR, "failed to prepare the stderr pipe");
        close(fd_stdout[0]);
        close(fd_stdout[1]);
        return -1;
    }

    if (0 > fd_set_blocked(fd_stdout[0], 0) || 0 > fd_set_blocked(fd_stderr[0], 0)) {
        zlog(ZLOG_SYSERROR, "failed to unblock pipes");
        close(fd_stdout[0]);
        close(fd_stdout[1]);
        close(fd_stderr[0]);
        close(fd_stderr[1]);
        return -1;
    }
    return 0;
}

static void fpm_parent_resources_use(struct fpm_child_s *child) /* {{{ */
{
    fpm_stdio_parent_use_pipes(child);
    fpm_child_link(child);
}

int fpm_stdio_parent_use_pipes(struct fpm_child_s *child) /* {{{ */
{
    if (0 == child->wp->config->catch_workers_output) { /* not required */
        return 0;
    }

    close(fd_stdout[1]);
    close(fd_stderr[1]);

    child->fd_stdout = fd_stdout[0];
    child->fd_stderr = fd_stderr[0];

    fpm_event_set(&child->ev_stdout, child->fd_stdout, FPM_EV_READ, fpm_stdio_child_said, child);
    fpm_event_add(&child->ev_stdout, 0);

    fpm_event_set(&child->ev_stderr, child->fd_stderr, FPM_EV_READ, fpm_stdio_child_said, child);
    fpm_event_add(&child->ev_stderr, 0);
    return 0;
}

static void fpm_child_link(struct fpm_child_s *child) /* {{{ */
{
    struct fpm_worker_pool_s *wp = child->wp;

    ++wp->running_children;
    ++fpm_globals.running_children;

    child->next = wp->children;
    if (child->next) {
        child->next->prev = child;
    }
    child->prev = 0;
    wp->children = child;
}

static void fpm_child_resources_use(struct fpm_child_s *child) /* {{{ */
{
    struct fpm_worker_pool_s *wp;
    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        if (wp == child->wp) {
            continue;
        }
        fpm_scoreboard_free(wp->scoreboard);
    }

    fpm_scoreboard_child_use(child->wp->scoreboard, child->scoreboard_i, getpid());
    fpm_stdio_child_use_pipes(child);
    fpm_child_free(child);
}

void fpm_stdio_child_use_pipes(struct fpm_child_s *child) /* {{{ */
{
    if (child->wp->config->catch_workers_output) {
        dup2(fd_stdout[1], STDOUT_FILENO);
        dup2(fd_stderr[1], STDERR_FILENO);
        close(fd_stdout[0]); close(fd_stdout[1]);
        close(fd_stderr[0]); close(fd_stderr[1]);
    } else {
        /* stdout of parent is always /dev/null */
        dup2(STDOUT_FILENO, STDERR_FILENO);
    }
}

void fpm_event_loop(int err) /* {{{ */
{
    static struct fpm_event_s signal_fd_event;

    /* sanity check */
    if (fpm_globals.parent_pid != getpid()) {
        return;
    }
　　//将sp[0]放到epoll中进行监听

    fpm_event_set(&signal_fd_event, fpm_signals_get_fd(), FPM_EV_READ, &fpm_got_signal, NULL);
    fpm_event_add(&signal_fd_event, 0);

    /* add timers */
    if (fpm_globals.heartbeat > 0) {
        fpm_pctl_heartbeat(NULL, 0, NULL); //慢日志和超时处理
    }

    if (!err) {
        fpm_pctl_perform_idle_server_maintenance_heartbeat(NULL, 0, NULL);

        zlog(ZLOG_DEBUG, "%zu bytes have been reserved in SHM", fpm_shm_get_size_allocated());
        zlog(ZLOG_NOTICE, "ready to handle connections");

#ifdef HAVE_SYSTEMD
        fpm_systemd_heartbeat(NULL, 0, NULL); 
#endif
    }

    while (1) {
        struct fpm_event_queue_s *q, *q2;
        struct timeval ms;
        struct timeval tmp;
        struct timeval now;
        unsigned long int timeout;
        int ret;

        /* sanity check */
        if (fpm_globals.parent_pid != getpid()) {
            return;
        }

        fpm_clock_get(&now);
        timerclear(&ms);

        /* search in the timeout queue for the next timer to trigger */
        q = fpm_event_queue_timer;
        while (q) {
            if (!timerisset(&ms)) {
                ms = q->ev->timeout;
            } else {
                if (timercmp(&q->ev->timeout, &ms, <)) {
                    ms = q->ev->timeout;
                }
            }
            q = q->next;
        }

        /* 1s timeout if none has been set */
        if (!timerisset(&ms) || timercmp(&ms, &now, <) || timercmp(&ms, &now, ==)) {
            timeout = 1000;
        } else {
            timersub(&ms, &now, &tmp);
            timeout = (tmp.tv_sec * 1000) + (tmp.tv_usec / 1000) + 1;
        }

        ret = module->wait(fpm_event_queue_fd, timeout);

        /* is a child, nothing to do here */
        if (ret == -2) {
            return;
        }

        if (ret > 0) {
            zlog(ZLOG_DEBUG, "event module triggered %d events", ret);
        }

　　　　　//定时器触发,比如主进程接收到用户的sigterm信号,向sp[1]内写入T,epoll发现sp[0]里有数据，然后调用回调函数,向每个进程发送sigterm信号，（kill函数），
 　　　　同时注册一个定时器，假设现在时间为1:02,那么1S后到期，超时时间为 2：02，这个无限循环就是一起遍历这个定时器链表,当当前时间大于或等于这个超时时间时，就触发相应
　　　　 回调函数，向每个子进程发送sigkill指令,再根据返回的sigchild信号,处理相应的事情
　　　　


        /* trigger timers */
        q = fpm_event_queue_timer;
        while (q) {
            fpm_clock_get(&now);
            if (q->ev) {
                if (timercmp(&now, &q->ev->timeout, >) || timercmp(&now, &q->ev->timeout, ==)) {
                    fpm_event_fire(q->ev);
                    /* sanity check */
                    if (fpm_globals.parent_pid != getpid()) {
                        return;
                    }
                    if (q->ev->flags & FPM_EV_PERSIST) {
                        fpm_event_set_timeout(q->ev, now);
                    } else { /* delete the event */
                        q2 = q;
                        if (q->prev) {
                            q->prev->next = q->next;
                        }
                        if (q->next) {
                            q->next->prev = q->prev;
                        }
                        if (q == fpm_event_queue_timer) {
                            fpm_event_queue_timer = q->next;
                            if (fpm_event_queue_timer) {
                                fpm_event_queue_timer->prev = NULL;
                            }
                        }
                        q = q->next;
                        free(q2);
                        continue;
                    }
                }
            }
            q = q->next;
        }
    }
}

void fpm_pctl_heartbeat(struct fpm_event_s *ev, short which, void *arg) /* {{{ */
{
    static struct fpm_event_s heartbeat;
    struct timeval now;

    if (fpm_globals.parent_pid != getpid()) {
        return; /* sanity check */
    }

    if (which == FPM_EV_TIMEOUT) {
        fpm_clock_get(&now);
        fpm_pctl_check_request_timeout(&now);
        return;
    }

    /* ensure heartbeat is not lower than FPM_PCTL_MIN_HEARTBEAT */
    fpm_globals.heartbeat = MAX(fpm_globals.heartbeat, FPM_PCTL_MIN_HEARTBEAT);

    /* first call without setting to initialize the timer */
    zlog(ZLOG_DEBUG, "heartbeat have been set up with a timeout of %dms", fpm_globals.heartbeat);
    fpm_event_set_timer(&heartbeat, FPM_EV_PERSIST, &fpm_pctl_heartbeat, NULL);
    fpm_event_add(&heartbeat, fpm_globals.heartbeat);
}

static void fpm_pctl_check_request_timeout(struct timeval *now) /* {{{ */
{
    struct fpm_worker_pool_s *wp;

    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        int terminate_timeout = wp->config->request_terminate_timeout;
        int slowlog_timeout = wp->config->request_slowlog_timeout;
        struct fpm_child_s *child;

        if (terminate_timeout || slowlog_timeout) {
            for (child = wp->children; child; child = child->next) {
                fpm_request_check_timed_out(child, now, terminate_timeout, slowlog_timeout);
            }
        }
    }
}

void fpm_request_check_timed_out(struct fpm_child_s *child, struct timeval *now, int terminate_timeout, int slowlog_timeout) /* {{{ */
{
    struct fpm_scoreboard_proc_s proc, *proc_p;

    proc_p = fpm_scoreboard_proc_acquire(child->wp->scoreboard, child->scoreboard_i, 1);
    if (!proc_p) {
        zlog(ZLOG_WARNING, "failed to acquire scoreboard");
        return;
    }

    proc = *proc_p;
    fpm_scoreboard_proc_release(proc_p);

#if HAVE_FPM_TRACE
    if (child->slow_logged.tv_sec) {
        if (child->slow_logged.tv_sec != proc.accepted.tv_sec || child->slow_logged.tv_usec != proc.accepted.tv_usec) {
            child->slow_logged.tv_sec = 0;
            child->slow_logged.tv_usec = 0;
        }
    }
#endif

    if (proc.request_stage > FPM_REQUEST_ACCEPTING && proc.request_stage < FPM_REQUEST_END) {
        char purified_script_filename[sizeof(proc.script_filename)];
        struct timeval tv;

        timersub(now, &proc.accepted, &tv);

#if HAVE_FPM_TRACE
        if (child->slow_logged.tv_sec == 0 && slowlog_timeout &&
                proc.request_stage == FPM_REQUEST_EXECUTING && tv.tv_sec >= slowlog_timeout) {
            
            str_purify_filename(purified_script_filename, proc.script_filename, sizeof(proc.script_filename));

            child->slow_logged = proc.accepted;
            child->tracer = fpm_php_trace;

            fpm_trace_signal(child->pid);

            zlog(ZLOG_WARNING, "[pool %s] child %d, script '%s' (request: \"%s %s\") executing too slow (%d.%06d sec), logging",
                child->wp->config->name, (int) child->pid, purified_script_filename, proc.request_method, proc.request_uri,
                (int) tv.tv_sec, (int) tv.tv_usec);
        }
        else
#endif
        if (terminate_timeout && tv.tv_sec >= terminate_timeout) {
            str_purify_filename(purified_script_filename, proc.script_filename, sizeof(proc.script_filename));
            fpm_pctl_kill(child->pid, FPM_PCTL_TERM);

            zlog(ZLOG_WARNING, "[pool %s] child %d, script '%s' (request: \"%s %s\") execution timed out (%d.%06d sec), terminating",
                child->wp->config->name, (int) child->pid, purified_script_filename, proc.request_method, proc.request_uri,
                (int) tv.tv_sec, (int) tv.tv_usec);
        }
    }
}

void fpm_children_bury() /* {{{ */
{
    int status;
    pid_t pid;
    struct fpm_child_s *child;

    while ( (pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
        char buf[128];
        int severity = ZLOG_NOTICE;
        int restart_child = 1;

        child = fpm_child_find(pid);

        if (WIFEXITED(status)) {

            snprintf(buf, sizeof(buf), "with code %d", WEXITSTATUS(status));

            /* if it's been killed because of dynamic process management
             * don't restart it automaticaly
             */
            if (child && child->idle_kill) {
                restart_child = 0;
            }

            if (WEXITSTATUS(status) != FPM_EXIT_OK) {
                severity = ZLOG_WARNING;
            }

        } else if (WIFSIGNALED(status)) {
            const char *signame = fpm_signal_names[WTERMSIG(status)];
            const char *have_core = WCOREDUMP(status) ? " - core dumped" : "";

            if (signame == NULL) {
                signame = "";
            }

            snprintf(buf, sizeof(buf), "on signal %d (%s%s)", WTERMSIG(status), signame, have_core);

            /* if it's been killed because of dynamic process management
             * don't restart it automaticaly
             */
            if (child && child->idle_kill && WTERMSIG(status) == SIGQUIT) {
                restart_child = 0;
            }

            if (WTERMSIG(status) != SIGQUIT) { /* possible request loss */
                severity = ZLOG_WARNING;
            }
        } else if (WIFSTOPPED(status)) {

            zlog(ZLOG_NOTICE, "child %d stopped for tracing", (int) pid);

            if (child && child->tracer) {
                child->tracer(child);
            }

            continue;
        }

        if (child) {
            struct fpm_worker_pool_s *wp = child->wp;
            struct timeval tv1, tv2;

            fpm_child_unlink(child);

            fpm_scoreboard_proc_free(wp->scoreboard, child->scoreboard_i);

            fpm_clock_get(&tv1);

            timersub(&tv1, &child->started, &tv2);

            if (restart_child) {
                if (!fpm_pctl_can_spawn_children()) {
                    severity = ZLOG_DEBUG;
                }
                zlog(severity, "[pool %s] child %d exited %s after %ld.%06d seconds from start", child->wp->config->name, (int) pid, buf, tv2.tv_sec, (int) tv2.tv_usec);
            } else {
                zlog(ZLOG_DEBUG, "[pool %s] child %d has been killed by the process management after %ld.%06d seconds from start", child->wp->config->name, (int) pid, tv2.tv_sec, (int) tv2.tv_usec);
            }

            fpm_child_close(child, 1 /* in event_loop */);

            fpm_pctl_child_exited();

            if (last_faults && (WTERMSIG(status) == SIGSEGV || WTERMSIG(status) == SIGBUS)) {
                time_t now = tv1.tv_sec;
                int restart_condition = 1;
                int i;

                last_faults[fault++] = now;

                if (fault == fpm_global_config.emergency_restart_threshold) {
                    fault = 0;
                }

                for (i = 0; i < fpm_global_config.emergency_restart_threshold; i++) {
                    if (now - last_faults[i] > fpm_global_config.emergency_restart_interval) {
                        restart_condition = 0;
                        break;
                    }
                }

                if (restart_condition) {

                    zlog(ZLOG_WARNING, "failed processes threshold (%d in %d sec) is reached, initiating reload", fpm_global_config.emergency_restart_threshold, fpm_global_config.emergency_restart_interval);

                    fpm_pctl(FPM_PCTL_STATE_RELOADING, FPM_PCTL_ACTION_SET);
                }
            }

            if (restart_child) {
                fpm_children_make(wp, 1 /* in event loop */, 1, 0);

                if (fpm_globals.is_child) {
                    break;
                }
            }
        } else {
            zlog(ZLOG_ALERT, "oops, unknown child (%d) exited %s. Please open a bug report (https://bugs.php.net).", pid, buf);
        }
    }
}

fcgi_request *fcgi_init_request(int listen_socket)
{
    fcgi_request *req = (fcgi_request*)calloc(1, sizeof(fcgi_request));
    req->listen_socket = listen_socket;
    req->fd = -1;
    req->id = -1;

    req->in_len = 0;
    req->in_pad = 0;

    req->out_hdr = NULL;
    req->out_pos = req->out_buf;

#ifdef TCP_NODELAY
    req->nodelay = 0;
#endif

    fcgi_hash_init(&req->env);

    return req;
}

int fcgi_accept_request(fcgi_request *req)
{
    while (1) {
        if (req->fd < 0) {
            while (1) {
                if (in_shutdown) {
                    return -1;
                }

                {
                    int listen_socket = req->listen_socket;

                    sa_t sa;
                    socklen_t len = sizeof(sa);

                    FCGI_LOCK(req->listen_socket);
                    req->fd = accept(listen_socket, (struct sockaddr *)&sa, &len);
                    FCGI_UNLOCK(req->listen_socket);
                    if (req->fd >= 0) {
                        if (((struct sockaddr *)&sa)->sa_family == AF_INET) {

                            if (allowed_clients) {
                                int n = 0;
                                int allowed = 0;

                                while (allowed_clients[n] != INADDR_NONE) {
                                    if (allowed_clients[n] == sa.sa_inet.sin_addr.s_addr) {
                                        allowed = 1;
                                        break;
                                    }
                                    n++;
                                }
                                if (!allowed) {
                                    fprintf(stderr, "Connection from disallowed IP address '%s' is dropped.\n", inet_ntoa(sa.sa_inet.sin_addr));
                                    closesocket(req->fd);
                                    req->fd = -1;
                                    continue;
                                }
                            }

                        }
                    }
                }


                if (req->fd < 0 && (in_shutdown || (errno != EINTR && errno != ECONNABORTED))) {

                    return -1;
                }


                if (req->fd >= 0) {
                    struct pollfd fds;
                    int ret;

                    fds.fd = req->fd;
                    fds.events = POLLIN;
                    fds.revents = 0;
                    do {
                        errno = 0;
                        ret = poll(&fds, 1, 5000);
                    } while (ret < 0 && errno == EINTR); //相当于 当事件没有发生时，持续等待5000ms,当这段时间内依然没有 事件发生生时，返回ret为0,否则>0
                    if (ret > 0 && (fds.revents & POLLIN)) {
                        break;
                    }
                    fcgi_close(req, 1, 0);

                }

            }
        } else if (in_shutdown) {
            return -1;
        }
        if (fcgi_read_request(req)) {

            return req->fd;
        } else {
            fcgi_close(req, 1, 1);
        }
    }
}