Home/ Questions/Q 506929
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-13T06:45:06+00:00

I understand that on Linux there is a kernel functionality referred to as OOM

  • 0

I understand that on Linux there is a kernel functionality referred to as “OOM Killer”. When the OOM (Out-Of-Memory) condition subsides, is there such a thing as a “Process Resurrector” ?

I understand this functionality would be difficult to implement for all sorts of reason, but is there something that gets close to it?

Edit: Example: the “Resurrector” would have a block of memory guaranteed to it for storing a limited set of process information (e.g. command-line, environment etc.) (i.e. not a whole process code & data !). Once the OOM condition is cleared, the “Resurrector” could go through the list and “resurrect” some processes.

From what I gather up to now, there doesn’t seem to be functionality akin to what I am asking.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    No. Once a process is killed by the OOM Killer, it’s dead. You can restart it (resources permitting), and if it’s something that’s managed by the system (via inittab, perhaps), it might get restarted that way.

    Edit: As a thought experiment, think about what a resurrection of a process would mean. Even if you could store the entire process state, you wouldn’t want to because the process killed might be the REASON for the out-of-memory condition.

    So the best you could possibly due would be to store it’s startup state (command line, etc). But that’s no good either, because again, that may be WHY the system ran out of memory in the first place!

    Furthermore, if you resurrected a process in this way, there’s no telling what could go wrong. What if the process controls hardware? What if the process controls shouldn’t be run more than once? What if it was connected to a tty that isn’t there anymore (because the sshd was one of the processes killed)?

    There’s an ENORMOUS amount of context around a process that the system can’t possibly be aware of. The ONLY sensible thing is the thing that the kernel does: kill the sucker and go on.

    I suppose you can imagine a hibernate-the-process-to-disk strategy, but given that we’re out of memory (including swap), that means either pre-reserving some disk space or deciding to allocate disk space to this on the fly. Either of which strategy may not be capable of dealing with the size of the process in question.

    In short: No, you don’t get to come back from the OOM killer. It’s a killer, you just have to deal with it.

    • 0