¿Qué hace Apache con los módulos cargados cuando se modifica un archivo?

Question

Estoy escribiendo sobre un módulo de Apache que actualmente se ejecuta en 2.2.22. El módulo ejecuta scripts escritos en un nuevo lenguaje de programación y, para optimizarlo, almacena en caché los resultados del análisis para usos sucesivos.

Dado que el análisis en caché debe eliminarse cuando se modifica el archivo, almaceno la hora de modificación y la comparo con el sistema de archivos en cada ejecución.

Este es parte del código con un mensaje de depuración:

 if (file->is_modified (mtime)) {
     ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
          "P* removing cached file");
     files.erase(it);
 }

Lo que descubrí al probar esto (obtener una página, modificar el archivo, obtenerlo nuevamente) es que nunca se alcanza este bloque. El archivo se analiza nuevamente después de cambiarlo, pero no debido a esta verificación. Me parece que el propio Apache está comprobando la hora de modificación y está liberando toda la memoria del módulo.

Los archivos analizados se reutilizan correctamente cuando no se modifican.

¿Es este el comportamiento previsto del servidor Apache y, de ser así, cómo se llama y dónde está documentado?

Código completo para la función que busca programas almacenados en caché

shared_ptr<pstar_file> pstar_pool::get_file_handle (
            request_rec *r,
            wpl_io &io,
            const char *filename,
            int mtime
            )
{
    pstar_map_t::iterator it;

    apr_proc_mutex_lock (mutex);

    // Check if a cached program exists
    it = files.find(filename);
    if (it != files.end()) {
            if (it->second->is_modified (mtime)) {
                    files.erase(it);
            }
            else {
                    apr_proc_mutex_unlock (mutex);
                    return it->second;
            }
    }

    apr_proc_mutex_unlock (mutex);

    shared_ptr<pstar_file> file_ptr(new pstar_file(io, filename, mtime));

    apr_proc_mutex_lock (mutex);
    files.insert(std::pair<string,shared_ptr<pstar_file>>(filename, file_ptr));
    apr_proc_mutex_unlock (mutex);

    return file_ptr;
}

Código completo para todo el módulo en Github (varios archivos):https://github.com/atlesn/P-star/blob/master/src/apache2/pstar_pool.cpp

Answer 1

Aquí falta bastante contexto. Sin embargo, creo que la respuesta podría ser bastante sencilla.

Los módulos se cargan cuando se crea una instancia de un proceso de trabajo. Cuando se carga un módulo, normalmente se copia en la imagen del proceso en la memoria y los cambios en el disco no lo afectan. Si esto es relevante depende de lo que esté haciendo en su módulo personalizado.

Ciertamente, Apache no muestra un comportamiento extraño o indefinido cuando se utilizan y modifican archivos a los que acceden los módulos. Si su módulo abre un archivo, sería muy extraño que una modificación posterior de ese archivo haga lo que usted dijo, aunque tengo la sensación de que hay una razón por la que no está clara.

Compruebe también que el sistema de archivos subyacente realmente almacene y actualice mtime de la forma esperada. No siempre es así. Su verificación de mtime (que no ha incluido) también podría estar incorrecta.

Dado que usted dice que el archivo se está recargando por algún medio desconocido, es muy posible que se esté creando una instancia de un nuevo proceso de trabajo para cada solicitud, o que obtenga un trabajador diferente cada vez que lo intente.

Considere la impresión de depuración en su verificación de mtime para ayudar a aislar esto.