O que o Apache faz com módulos carregados quando um arquivo é modificado?

Question

Estou escrevendo em um módulo Apache que atualmente roda em 2.2.22. O módulo executa scripts escritos em uma nova linguagem de programação e, para otimização, armazena em cache os resultados da análise para usos sucessivos.

Como a análise em cache deve ser excluída quando o arquivo é modificado, eu armazeno o horário da modificação e verifico-o no sistema de arquivos em cada execução.

Este é parte do código com uma mensagem de depuração:

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

O que descobri ao testar isso (obter uma página, modificar o arquivo, obtê-lo novamente) é que esse bloco nunca é alcançado. O arquivo é analisado novamente após ser alterado, mas não por causa dessa verificação. Parece-me que o próprio Apache está verificando o horário da modificação e liberando toda a memória do módulo.

Os arquivos analisados ​​são reutilizados corretamente quando não são modificados.

Esse é o comportamento pretendido do servidor Apache e, em caso afirmativo, como é chamado e onde está documentado?

Código completo para a função que verifica programas em cache

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 o módulo no Github (vários arquivos):https://github.com/atlesn/P-star/blob/master/src/apache2/pstar_pool.cpp

Answer 1

Há um pouco de contexto faltando aqui. No entanto, acho que a resposta pode ser bastante simples.

Os módulos são carregados quando um processo de trabalho é instanciado. Quando um módulo é carregado, normalmente ele é copiado para a imagem do processo na memória e as alterações no disco não o afetam. Se isso é relevante depende do que você está fazendo no seu módulo personalizado.

Certamente, o apache não apresenta comportamento estranho ou indefinido quando arquivos acessados ​​por módulos são usados ​​e alterados. Se o seu módulo abrir um arquivo, seria muito estranho que uma modificação posterior nesse arquivo fizesse o que você disse, embora eu tenha a sensação de que há um motivo para isso não estar claro.

Verifique também se o sistema de arquivos subjacente realmente armazena e atualiza mtime da maneira esperada. Nem sempre. Sua verificação mtime (que você não incluiu) também pode estar errada.

Como você diz que o arquivo está sendo recarregado por algum meio desconhecido, é bem possível que um novo processo de trabalho esteja sendo instanciado para cada solicitação ou que você obtenha um trabalhador diferente cada vez que tentar.

Considere a impressão de depuração em sua verificação mtime, para ajudar a isolar isso.