�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fserver%2F'>server</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fserver%2Fmpm%2F'>mpm</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fserver%2Fmpm%2Fmpmt_os2%2F'>mpmt_os2</a>/</p><hr><h3>✏️ Editing: mpmt_os2_child.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the &quot;License&quot;); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define INCL_NOPMAPI
#define INCL_DOS
#define INCL_DOSERRORS

#include &quot;ap_config.h&quot;
#include &quot;httpd.h&quot;
#include &quot;mpm_default.h&quot;
#include &quot;http_main.h&quot;
#include &quot;http_log.h&quot;
#include &quot;http_config.h&quot;
#include &quot;http_core.h&quot;  /* for get_remote_host */
#include &quot;http_connection.h&quot;
#include &quot;scoreboard.h&quot;
#include &quot;ap_mpm.h&quot;
#include &quot;ap_listen.h&quot;
#include &quot;apr_portable.h&quot;
#include &quot;apr_poll.h&quot;
#include &quot;mpm_common.h&quot;
#include &quot;apr_strings.h&quot;
#include &lt;os2.h&gt;
#include &lt;process.h&gt;

APLOG_USE_MODULE(mpm_mpmt_os2);

/* XXXXXX move these to header file private to this MPM */

/* We don&#039;t need many processes,
 * they&#039;re only for redundancy in the event of a crash
 */
#define HARD_SERVER_LIMIT 10

/* Limit on the total number of threads per process
 */
#ifndef HARD_THREAD_LIMIT
#define HARD_THREAD_LIMIT 256
#endif

#define ID_FROM_CHILD_THREAD(c, t)    ((c * HARD_THREAD_LIMIT) + t)

typedef struct {
    apr_pool_t *pconn;
    apr_socket_t *conn_sd;
} worker_args_t;

#define WORKTYPE_CONN 0
#define WORKTYPE_EXIT 1

static apr_pool_t *pchild = NULL;
static int child_slot;
static int shutdown_pending = 0;
extern int ap_my_generation;
static int volatile is_graceful = 1;
HEV shutdown_event; /* signaled when this child is shutting down */

/* grab some MPM globals */
extern int ap_min_spare_threads;
extern int ap_max_spare_threads;
extern HMTX ap_mpm_accept_mutex;

static void worker_main(void *vpArg);
static void clean_child_exit(int code);
static void set_signals();
static void server_maintenance(void *vpArg);


static void clean_child_exit(int code)
{
    if (pchild) {
        apr_pool_destroy(pchild);
    }

    exit(code);
}



void ap_mpm_child_main(apr_pool_t *pconf)
{
    ap_listen_rec *lr = NULL;
    int requests_this_child = 0;
    int rv = 0;
    unsigned long ulTimes;
    int my_pid = getpid();
    ULONG rc, c;
    HQUEUE workq;
    apr_pollset_t *pollset;
    int num_listeners;
    TID server_maint_tid;
    void *sb_mem;

    /* Stop Ctrl-C/Ctrl-Break signals going to child processes */
    DosSetSignalExceptionFocus(0, &amp;ulTimes);
    set_signals();

    /* Create pool for child */
    apr_pool_create(&amp;pchild, pconf);
    apr_pool_tag(pchild, &quot;pchild&quot;);

    ap_run_child_init(pchild, ap_server_conf);

    /* Create an event semaphore used to trigger other threads to shutdown */
    rc = DosCreateEventSem(NULL, &amp;shutdown_event, 0, FALSE);

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00189)
                     &quot;unable to create shutdown semaphore, exiting&quot;);
        clean_child_exit(APEXIT_CHILDFATAL);
    }

    /* Gain access to the scoreboard. */
    rc = DosGetNamedSharedMem(&amp;sb_mem, ap_scoreboard_fname,
                              PAG_READ|PAG_WRITE);

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00190)
                     &quot;scoreboard not readable in child, exiting&quot;);
        clean_child_exit(APEXIT_CHILDFATAL);
    }

    ap_calc_scoreboard_size();
    ap_init_scoreboard(sb_mem);

    /* Gain access to the accpet mutex */
    rc = DosOpenMutexSem(NULL, &amp;ap_mpm_accept_mutex);

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00191)
                     &quot;accept mutex couldn&#039;t be accessed in child, exiting&quot;);
        clean_child_exit(APEXIT_CHILDFATAL);
    }

    /* Find our pid in the scoreboard so we know what slot our parent allocated us */
    for (child_slot = 0; ap_scoreboard_image-&gt;parent[child_slot].pid != my_pid &amp;&amp; child_slot &lt; HARD_SERVER_LIMIT; child_slot++);

    if (child_slot == HARD_SERVER_LIMIT) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf, APLOGNO(00192)
                     &quot;child pid not found in scoreboard, exiting&quot;);
        clean_child_exit(APEXIT_CHILDFATAL);
    }

    ap_my_generation = ap_scoreboard_image-&gt;parent[child_slot].generation;
    memset(ap_scoreboard_image-&gt;servers[child_slot], 0, sizeof(worker_score) * HARD_THREAD_LIMIT);

    /* Set up an OS/2 queue for passing connections &amp; termination requests
     * to worker threads
     */
    rc = DosCreateQueue(&amp;workq, QUE_FIFO, apr_psprintf(pchild, &quot;/queues/httpd/work.%d&quot;, my_pid));

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00193)
                     &quot;unable to create work queue, exiting&quot;);
        clean_child_exit(APEXIT_CHILDFATAL);
    }

    /* Create initial pool of worker threads */
    for (c = 0; c &lt; ap_min_spare_threads; c++) {
//        ap_scoreboard_image-&gt;servers[child_slot][c].tid = _beginthread(worker_main, NULL, 128*1024, (void *)c);
    }

    /* Start maintenance thread */
    server_maint_tid = _beginthread(server_maintenance, NULL, 32768, NULL);

    /* Set up poll */
    for (num_listeners = 0, lr = ap_listeners; lr; lr = lr-&gt;next) {
        num_listeners++;
    }

    apr_pollset_create(&amp;pollset, num_listeners, pchild, 0);

    for (lr = ap_listeners; lr != NULL; lr = lr-&gt;next) {
        apr_pollfd_t pfd = { 0 };

        pfd.desc_type = APR_POLL_SOCKET;
        pfd.desc.s = lr-&gt;sd;
        pfd.reqevents = APR_POLLIN;
        pfd.client_data = lr;
        apr_pollset_add(pollset, &amp;pfd);
    }

    /* Main connection accept loop */
    do {
        apr_pool_t *pconn;
        worker_args_t *worker_args;
        int last_poll_idx = 0;

        apr_pool_create(&amp;pconn, pchild);
        apr_pool_tag(pconn, &quot;transaction&quot;);
        worker_args = apr_palloc(pconn, sizeof(worker_args_t));
        worker_args-&gt;pconn = pconn;

        if (num_listeners == 1) {
            rv = apr_socket_accept(&amp;worker_args-&gt;conn_sd, ap_listeners-&gt;sd, pconn);
        } else {
            const apr_pollfd_t *poll_results;
            apr_int32_t num_poll_results;

            rc = DosRequestMutexSem(ap_mpm_accept_mutex, SEM_INDEFINITE_WAIT);

            if (shutdown_pending) {
                DosReleaseMutexSem(ap_mpm_accept_mutex);
                break;
            }

            rv = APR_FROM_OS_ERROR(rc);

            if (rv == APR_SUCCESS) {
                rv = apr_pollset_poll(pollset, -1, &amp;num_poll_results, &amp;poll_results);
                DosReleaseMutexSem(ap_mpm_accept_mutex);
            }

            if (rv == APR_SUCCESS) {
                if (last_poll_idx &gt;= num_listeners) {
                    last_poll_idx = 0;
                }

                lr = poll_results[last_poll_idx++].client_data;
                rv = apr_socket_accept(&amp;worker_args-&gt;conn_sd, lr-&gt;sd, pconn);
                last_poll_idx++;
            }
        }

        if (rv != APR_SUCCESS) {
            if (!APR_STATUS_IS_EINTR(rv)) {
                ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf, APLOGNO(00194)
                             &quot;apr_socket_accept&quot;);
                clean_child_exit(APEXIT_CHILDFATAL);
            }
        } else {
            DosWriteQueue(workq, WORKTYPE_CONN, sizeof(worker_args_t), worker_args, 0);
            requests_this_child++;
        }

        if (ap_max_requests_per_child != 0 &amp;&amp; requests_this_child &gt;= ap_max_requests_per_child)
            break;
    } while (!shutdown_pending &amp;&amp; ap_my_generation == ap_scoreboard_image-&gt;global-&gt;running_generation);

    ap_scoreboard_image-&gt;parent[child_slot].quiescing = 1;
    DosPostEventSem(shutdown_event);
    DosWaitThread(&amp;server_maint_tid, DCWW_WAIT);

    if (is_graceful) {
        char someleft;

        /* tell our worker threads to exit */
        for (c=0; c&lt;HARD_THREAD_LIMIT; c++) {
            if (ap_scoreboard_image-&gt;servers[child_slot][c].status != SERVER_DEAD) {
                DosWriteQueue(workq, WORKTYPE_EXIT, 0, NULL, 0);
            }
        }

        do {
            someleft = 0;

            for (c=0; c&lt;HARD_THREAD_LIMIT; c++) {
                if (ap_scoreboard_image-&gt;servers[child_slot][c].status != SERVER_DEAD) {
                    someleft = 1;
                    DosSleep(1000);
                    break;
                }
            }
        } while (someleft);
    } else {
        DosPurgeQueue(workq);

        for (c=0; c&lt;HARD_THREAD_LIMIT; c++) {
            if (ap_scoreboard_image-&gt;servers[child_slot][c].status != SERVER_DEAD) {
                DosKillThread(ap_scoreboard_image-&gt;servers[child_slot][c].tid);
            }
        }
    }

    apr_pool_destroy(pchild);
}



void add_worker()
{
    int thread_slot;
    int stacksize = ap_thread_stacksize == 0 ? 128*1024 : ap_thread_stacksize;

    /* Find a free thread slot */
    for (thread_slot=0; thread_slot &lt; HARD_THREAD_LIMIT; thread_slot++) {
        if (ap_scoreboard_image-&gt;servers[child_slot][thread_slot].status == SERVER_DEAD) {
            ap_scoreboard_image-&gt;servers[child_slot][thread_slot].status = SERVER_STARTING;
            ap_scoreboard_image-&gt;servers[child_slot][thread_slot].tid =
                _beginthread(worker_main, NULL, stacksize, (void *)thread_slot);
            break;
        }
    }
}



ULONG APIENTRY thread_exception_handler(EXCEPTIONREPORTRECORD *pReportRec,
                                        EXCEPTIONREGISTRATIONRECORD *pRegRec,
                                        CONTEXTRECORD *pContext,
                                        PVOID p)
{
    int c;

    if (pReportRec-&gt;fHandlerFlags &amp; EH_NESTED_CALL) {
        return XCPT_CONTINUE_SEARCH;
    }

    if (pReportRec-&gt;ExceptionNum == XCPT_ACCESS_VIOLATION ||
        pReportRec-&gt;ExceptionNum == XCPT_INTEGER_DIVIDE_BY_ZERO) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf, APLOGNO(00195)
                     &quot;caught exception in worker thread, initiating child shutdown pid=%d&quot;, getpid());
        for (c=0; c&lt;HARD_THREAD_LIMIT; c++) {
            if (ap_scoreboard_image-&gt;servers[child_slot][c].tid == _gettid()) {
                ap_scoreboard_image-&gt;servers[child_slot][c].status = SERVER_DEAD;
                break;
            }
        }

        /* Shut down process ASAP, it could be quite unhealthy &amp; leaking resources */
        shutdown_pending = 1;
        ap_scoreboard_image-&gt;parent[child_slot].quiescing = 1;
        kill(getpid(), SIGHUP);
        DosUnwindException(UNWIND_ALL, 0, 0);
    }

    return XCPT_CONTINUE_SEARCH;
}



static void worker_main(void *vpArg)
{
    apr_thread_t *thd = NULL;
    apr_os_thread_t osthd;
    long conn_id;
    conn_rec *current_conn;
    apr_pool_t *pconn;
    apr_allocator_t *allocator;
    apr_bucket_alloc_t *bucket_alloc;
    worker_args_t *worker_args;
    HQUEUE workq;
    PID owner;
    int rc;
    REQUESTDATA rd;
    ULONG len;
    BYTE priority;
    int thread_slot = (int)vpArg;
    EXCEPTIONREGISTRATIONRECORD reg_rec = { NULL, thread_exception_handler };
    ap_sb_handle_t *sbh;

    /* Trap exceptions in this thread so we don&#039;t take down the whole process */
    DosSetExceptionHandler( &amp;reg_rec );

    osthd = apr_os_thread_current();
    apr_os_thread_put(&amp;thd, &amp;osthd, pchild);

    rc = DosOpenQueue(&amp;owner, &amp;workq,
                      apr_psprintf(pchild, &quot;/queues/httpd/work.%d&quot;, getpid()));

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00196)
                     &quot;unable to open work queue, exiting&quot;);
        ap_scoreboard_image-&gt;servers[child_slot][thread_slot].tid = 0;
    }

    conn_id = ID_FROM_CHILD_THREAD(child_slot, thread_slot);
    ap_update_child_status_from_indexes(child_slot, thread_slot, SERVER_READY,
                                        NULL);

    apr_allocator_create(&amp;allocator);
    apr_allocator_max_free_set(allocator, ap_max_mem_free);
    bucket_alloc = apr_bucket_alloc_create_ex(allocator);

    while (rc = DosReadQueue(workq, &amp;rd, &amp;len, (PPVOID)&amp;worker_args, 0, DCWW_WAIT, &amp;priority, NULLHANDLE),
           rc == 0 &amp;&amp; rd.ulData != WORKTYPE_EXIT) {
        pconn = worker_args-&gt;pconn;
        ap_create_sb_handle(&amp;sbh, pconn, child_slot, thread_slot);
        current_conn = ap_run_create_connection(pconn, ap_server_conf,
                                                worker_args-&gt;conn_sd, conn_id,
                                                sbh, bucket_alloc);

        if (current_conn) {
            current_conn-&gt;current_thread = thd;
            ap_process_connection(current_conn, worker_args-&gt;conn_sd);
            ap_lingering_close(current_conn);
        }

        apr_pool_destroy(pconn);
        ap_update_child_status_from_indexes(child_slot, thread_slot,
                                            SERVER_READY, NULL);
    }

    ap_update_child_status_from_indexes(child_slot, thread_slot, SERVER_DEAD,
                                        NULL);

    apr_bucket_alloc_destroy(bucket_alloc);
    apr_allocator_destroy(allocator);
}



static void server_maintenance(void *vpArg)
{
    int num_idle, num_needed;
    ULONG num_pending = 0;
    int threadnum;
    HQUEUE workq;
    ULONG rc;
    PID owner;

    rc = DosOpenQueue(&amp;owner, &amp;workq,
                      apr_psprintf(pchild, &quot;/queues/httpd/work.%d&quot;, getpid()));

    if (rc) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf, APLOGNO(00197)
                     &quot;unable to open work queue in maintenance thread&quot;);
        return;
    }

    do {
        for (num_idle=0, threadnum=0; threadnum &lt; HARD_THREAD_LIMIT; threadnum++) {
            num_idle += ap_scoreboard_image-&gt;servers[child_slot][threadnum].status == SERVER_READY;
        }

        DosQueryQueue(workq, &amp;num_pending);
        num_needed = ap_min_spare_threads - num_idle + num_pending;

        if (num_needed &gt; 0) {
            for (threadnum=0; threadnum &lt; num_needed; threadnum++) {
                add_worker();
            }
        }

        if (num_idle - num_pending &gt; ap_max_spare_threads) {
            DosWriteQueue(workq, WORKTYPE_EXIT, 0, NULL, 0);
        }
    } while (DosWaitEventSem(shutdown_event, 500) == ERROR_TIMEOUT);
}



/* Signal handling routines */

static void sig_term(int sig)
{
    shutdown_pending = 1;
    is_graceful = 0;
    signal(SIGTERM, SIG_DFL);
}



static void sig_hup(int sig)
{
    shutdown_pending = 1;
    is_graceful = 1;
}



static void set_signals()
{
    struct sigaction sa;

    sigemptyset(&amp;sa.sa_mask);
    sa.sa_flags = 0;
    sa.sa_handler = sig_term;

    if (sigaction(SIGTERM, &amp;sa, NULL) &lt; 0)
        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, APLOGNO(00198) &quot;sigaction(SIGTERM)&quot;);

    sa.sa_handler = sig_hup;

    if (sigaction(SIGHUP, &amp;sa, NULL) &lt; 0)
        ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, APLOGNO(00199) &quot;sigaction(SIGHUP)&quot;);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fserver%2Fmpm%2Fmpmt_os2'>🔙 Back</a></p>