Desenvolvedores do kernel Linux estão prestes a ganhar uma ajudinha elegante para escrever drivers com menos boilerplate e menos chance de resource leak. Uma nova série de patches propõe macros de auto-cleanup específicas para o PM runtime — transformando o velho par get/put em algo mais difícil de errar e bem mais legível. A ideia vem sendo discutida por Takashi Iwai (com base em trabalho inicial de Rafael J. Wysocki) e materializa um padrão que muitos já seguiam “na mão”: se você “pega” o recurso, alguém precisa “devolver” — e esse “alguém”, agora, pode ser o próprio compilador guiado por macros da cleanup.h.
Menos bugs, menos boilerplate
Se você já escreveu driver, sabe: cada pm_runtime_resume_and_get(dev) precisa de um pm_runtime_put(dev) correspondente — inclusive em todos os caminhos de erro. Em funções com várias saídas, é muito fácil esquecer um put e abrir uma janela para vazamento de referência (e comportamentos estranhos de energia). As novas macros de classe automatizam essa devolução: você adquire a referência e, quando a variável sair de escopo, o auto-cleanup chama o put apropriado por você. Resultado: menos código cerimonial, menos if-else repetitivo e menos bugs sutis. Para quem mantém dispositivos sempre ativos durante trechos críticos, isso se conecta diretamente à semântica do PM runtime já documentada no kernel.
Como funciona na prática
A série introduz CLASS() para o PM runtime, com variantes que cobrem tanto o pm_runtime_put() comum quanto o pm_runtime_put_autosuspend(). Além disso, o fluxo é harmonizado em torno de pm_runtime_resume_and_get(), permitindo até substituir usos de pm_runtime_get_sync() sem precisar pensar em put explícito na cauda da função. A discussão pública já mostrou exatamente esse formato “antes e depois”, ilustrando o ganho de clareza:
Antes (boilerplate e risco de esquecer o put):
ret = pm_runtime_resume_and_get(dev);
if (ret < 0)
return ret;
/* ... uso do dispositivo ... */
pm_runtime_put(dev);
return 0;Depois (com CLASS e auto-cleanup):
CLASS(pm_runtime_resume_and_get, pm)(dev);
if (IS_ERR(pm))
return PTR_ERR(pm);
/* ... uso do dispositivo, que não vai suspender nesse escopo ... */
return 0; /* o pm_runtime_put() acontece automaticamente */E, quando o correto é devolver com autosuspend:
CLASS(pm_runtime_resume_and_get_auto, pm)(dev);
if (IS_ERR(pm))
return PTR_ERR(pm);
/* ... */
return 0; /* chama pm_runtime_put_autosuspend() ao sair do escopo */O mesmo padrão também ajuda a “unificar” casos antigos com pm_runtime_get_sync() (você usa CLASS(pm_runtime_resume_and_get, ...) e simplesmente ignora a checagem de erro, se for esse o comportamento esperado).
Por que isso importa
Além de limpar o código existente — e de reduzir o tempo de revisão em patches que antes repetiam padrões de cleanup — a mudança tem impacto direto na confiabilidade. Em caminhos de erro pouco exercitados (ou difíceis de cobrir em testes), o auto-cleanup age como um “cinto de segurança”: a referência de PM runtime sempre será liberada ao sair do escopo. É como ter um “assistente inteligente” varrendo a sujeira que você poderia deixar para trás quando um goto err interrompe o fluxo feliz.
Quando isso chega ao kernel
A proposta foi enviada agora (19 de setembro de 2025) e deve mirar a próxima janela de merge — provavelmente o Linux 6.18, sujeito à revisão e eventuais ajustes durante o review público (há inclusive observações sobre dispositivos com PM runtime desabilitado que podem refinar a implementação). Em paralelo, há conversas sobre converter pontos existentes (como no PCI core) e retirar definições antigas de __free() que se tornarem desnecessárias.
Linux kernel cleanup.h — esta evolução aproveita a infraestrutura de auto-cleanup do kernel para tornar mais seguro o uso do PM runtime.
