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

Question

Eu estou escrevendo em um módulo do Apache que atualmente roda no 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 a hora da modificação e verifico no sistema de arquivos em cada execução.

Isto é um pouco 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 depois que é alterado, mas não por causa dessa verificação. Parece-me que o próprio Apache está verificando o tempo de modificação e está liberando toda a memória no módulo.

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

É este o comportamento pretendido do servidor Apache e, em caso afirmativo, o que é isso chamado e onde é documentado?

Código completo para a função que verifica os 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): link

    

Answer 1

Há um pouco de contexto faltando aqui. No entanto, acho que a resposta pode ser bem 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 exibe um 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 desse arquivo fizesse o que você disse, embora eu tenha a impressão de que há uma razão para isso não estar claro.

Verifique também se o sistema de arquivos subjacente realmente armazena e atualiza o mtime da maneira esperada. Nem sempre. Sua verificação de horário (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 sempre que tentar.

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