Function runtime_application_worker

src/daemon/runtime.c:1270–1310

}

static void *runtime_application_worker(void *opaque) {
    cbm_daemon_runtime_worker_t *worker = opaque;
    cbm_daemon_runtime_service_t *service = worker->service;
    uint8_t *response = NULL;
    uint32_t response_length = 0;
    cbm_daemon_runtime_application_status_t status = service->application.request(
        service->application.context, worker->application_session,
        worker->application_request_token, worker->application_request,
        worker->application_request_length, &response, &response_length);

    bool valid_status = runtime_application_status_is_callback_result(status);
    bool valid_response =
        response_length <= CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX &&
        (response_length == 0 || response != NULL) &&
        (status == CBM_DAEMON_RUNTIME_APPLICATION_OK || (response == NULL && response_length == 0));
    if (!valid_status || !valid_response) {
        free(response);
        response = NULL;
        response_length = 0;
        status = CBM_DAEMON_RUNTIME_APPLICATION_HANDLER_ERROR;
    }

    /* Completion must be one atomic transition from the client's point of
     * view: publish the done flag BEFORE the response bytes leave, so by the
     * time any client can react to the response, admission already observes
     * this slot as reusable. With the store after the send, a client that
     * pipelines its next request the moment it sees a response raced this
     * thread's final instructions and was rejected BUSY — on loaded Windows
     * hosts roughly half of all back-to-back requests on one connection,
     * surfacing as the wandering Phase 5 session drops. The admission side
     * joins this thread after observing the flag, which safely absorbs the
     * tail of the send. */
    atomic_store_explicit(&worker->application_thread_done, true, memory_order_release);
    bool sent = runtime_worker_send_application_response(worker, worker->application_request_token,
                                                         status, response, response_length, true);
    free(response);
    if (!sent && !atomic_load_explicit(&worker->disconnecting, memory_order_acquire)) {
        cbm_daemon_ipc_connection_interrupt(worker->connection);
    }
    return NULL;
}

static bool runtime_worker_reap_application(cbm_daemon_runtime_worker_t *worker, bool wait) {
    if (!worker->application_thread_started) {