Re: [PATCH] OOM_pardon, a.k.a. don't kill my xlock (2004)(lwn.net)
56 pointsby luu8 hours ago8 comments
  • EdSchouten6 hours ago
    I still remember following Andries’s “Linux kernel hacker’s hut” course he taught at the Eindhoven University of Technology (TU/e) back in 2010. Every week we’d get an assignment where we had to write exploits for commonly occurring security vulnerabilities (e.g., buffer overflows, bad printf format). It was one of the most enjoyable courses I ever followed. Thanks for that, Andries!
    • blux5 hours ago
      Hey fellow TU/e'er :) I followed his course as well, somewhere around 2004/5. Executing man in the middle attacks, writing buffer overflow exploits. Good memories!
  • rwmj6 hours ago
    It's 2026 and I still can't configure the OOM killer to kill firefox before anything else.
    • bellowsgulch5 hours ago
      I looked into this, and actually, it seems like maybe you can? https://man7.org/linux/man-pages/man5/proc_pid_oom_score_adj...

      So, in actuality, I think your assertion just taught us all something, because despite knowing that the OOM killer and that the Magic SysRq key[1] exists, I didn't know you could configure this as an input!

      [1]: https://en.wikipedia.org/wiki/Magic_SysRq_key

      • rwmj5 hours ago
        I'm aware of it, but it's awkward to use in practice. You have to track down all the FF processes, each time you run it, and adjust all their scores.
        • nick__m33 minutes ago
          You could launch it as a systemd user target with OOMScoreAdjust=500 in the service section; weird and unconventional but wrapped in .desktop file it doesn't appear to be unwieldy.
        • bellowsgulch21 minutes ago
          Ah. Yes, that is awkward. Well, nonetheless, you taught me a new feature. Thanks!
        • jitl24 minutes ago
          sounds like a job for a program
        • loeg4 hours ago
          Maybe firefox could self-adjust, as a policy?
    • SoftTalker5 hours ago
      I always wanted it to target java processes, as they were always the culprit. These days it's python, VSCode, and antigravity.
    • dvh6 hours ago
      This. It's always browser running amok. I configured win+k shortcut key to: killall -9 chrome
    • yjftsjthsd-h4 hours ago
      Maybe not in kernel, but running the earlyoom daemon will let you do exactly that in userspace.
    • IsTom5 hours ago
      It's not a panacea, but in my case setting browser.tabs.unloadOnLowMemory in about:config helped a bunch.
    • 5 hours ago
      undefined
  • lelandfe6 hours ago
    I never pay for the OOF insurance, it seems like a waste of money and I've never met anyone that's had it happen.
    • keyle5 hours ago
      It can only happen once anyway, and I fly weekly!
  • hyperpape5 hours ago
    I confess, this is very funny and the underlying situation is a bit absurd, but it's unclear what point Brouwer is making by pointing out the absurdity.

    There surely is something absurd about having to register specific processes as exempt from the OOM killer. But given that the OOM killer exists, and could kill xlock...how should that be fixed?

    • ameliaquining4 hours ago
      I read him as arguing that overcommit was a mistake. Of course, he doesn't answer any of the obvious follow-up questions, such as, does fork–exec copy all the process's memory and then immediately throw it away, or what. (One could argue that fork–exec was also a mistake, but it long predates Linux, so this doesn't answer the question of how Torvalds should have designed it.)
    • dooglius4 hours ago
      The point is that the OOM killer shouldn't exist and arguing about how to tweak it is addressing the wrong problem
      • hyperpape4 hours ago
        But the second clause doesn't follow from the first!

        I don't think Linux was plausibly going to remove the OOM killer in 2004 or later. So the right solution for Linux is very much to tweak it to be less painful.

      • hackyhacky4 hours ago
        I agree that that's the point he's making, but I don't see how that would work practically. His attitude is that malloc(1<<63) should immediately crash the system, every time? How is that better?
        • cpgxiii4 hours ago
          No, if a process allocates an infeasible amount, malloc fails and the process needs to deal with the failure (which is what already happens, "malloc doesn't fail on Linux" is only really true for smaller-than-page-size allocations). The point being made is that the system should account conservatively for all memory that can be used, not just the optimistic underestimate that overcommit enables (i.e. the plane should always carry enough fuel for contingencies, and landing with extra fuel is a good outcome).
  • ptx4 hours ago
    FreeBSD has a "protect" command which does something similar to what this asks for – the man page [1] describes it:

    "The protect command is used to mark processes as protected. The kernel does not kill protected processes when swap space is exhausted. [...] If you protect a runaway process that allocates all memory the system will deadlock."

    [1] https://man.freebsd.org/cgi/man.cgi?query=protect&apropos=0&...

  • sedatk7 hours ago
    I’d say, let the one who tried to allocate memory crash, and if you’re a critical process like xlock, use statically allocated memory and don’t alloc again.
    • Retr0id6 hours ago
      Statically allocated memory can still OOM on access, due to overcommit and lazy page table population. What you really want is mlockall(2) (probably with MCL_CURRENT|MCL_ONFAULT followed by madvise with MADV_POPULATE_*)
      • Retr0id4 hours ago
        oops MCL_ONFAULT kinda does the opposite of what I wanted - I think if you omit that you can skip the madvise, and mlockall will populate everything for you.
    • feelamee6 hours ago
      > if you’re a critical process like xlock, use statically allocated memory and don’t alloc again.

      This doesn't save you if someone other allocates and OOM killer chooses you as victim

      • hkolk6 hours ago
        What is proposed is to not have an OOM killer with a selection process, meaning that the "someone other allocates" would be the one dying.
        • tux36 hours ago
          The problem is that Linux has memory overcommit and it will OOM when a process faults a page in, not just when someone allocates memory.

          So the OOM condition can hit any random process, not necessarily one that just tried to allocate. If you don't have some sort of selection, then you would still have an OOM killer, only it will be killing completely at random.

          • muvlon5 hours ago
            That's true, but critical processes could mlockall() after setup, so their stuff never needs paging in.
        • sedatk6 hours ago
          Yes, don’t have OOM roulette.
    • LoganDark6 hours ago
      This is only a viable answer when overcommit is disabled. The problem comes when overcommit is enabled and you find yourself in a position where many programs think they already have memory and yet there is none to give them. If you simply kill the first piece of code that encounters the end of available memory you might take down anything including the kernel itself.

      Nothing like statically allocating memory can work when overcommit is enabled because the kernel is free to compress memory, page it out and etc. and then murder you the next time you try to perform any operation that it doesn't have the space for, no matter how safe and static your initialization was.

      Note that overcommit is very useful in many cases including the ones where swap saves the stability of the system under conditions that would otherwise completely lock up or panic, so it's also not viable to just prevent it from being used.

      • 6 hours ago
        undefined
      • SoftTalker5 hours ago
        OOM killer always felt like a band-aid on a severed artery to me. I've rarely seen a machine that got into OOM state really recover without a full reboot.
        • sph4 hours ago
          Why would a system break if you SIGKILL a process?

          I’ve seen plenty of server log with OOM killing mariadb processes, and then being restarted automatically by systemd, often with no one noticing if not days later.

          The thing that bogs down systems and often makes them unrecoverable is when a memory hungry process starts swapping. Good luck trying to SSH in. Swap is such a silly idea on servers - good to deal with pages no one accesses, catastrophic when you’re out of RAM and memory latencies suddenly become 4 or 5 orders of magnitude slower.

      • sedatk6 hours ago
        I’m not against taking down the kernel if the situation is that catastrophic. Better than killing the lock screen for sure.
        • josefx6 hours ago
          Shouldn't desktop environments detect if a lock screen terminated abnormaly anyway? The OOM killer is just one of many possible causes.
        • LoganDark6 hours ago
          IMO if the security of a system depends on the lock screen not crashing then the system is not very secure. Security protocols should never fail open like that; a lock screen should never simply be a layer on top of the authenticated desktop. Windows and macOS get this right. I believe Wayland display managers are also able to get this right (but I haven't checked).
          • yjftsjthsd-h4 hours ago
            Yes, Wayland should fix this. Granted, then you have a locked screen that the user may or may not be able to unlock, which is awkward if better.
    • amluto6 hours ago
      The fact that xlock crashing unlocks an X11 session is, IMO, pathetic.
      • gjvc6 hours ago
        looking forward to your other insights
  • cwillu6 hours ago
    (2004)
  • bastawhiz5 hours ago
    Especially in an era where RAM is so expensive, the obvious answer is to simply never use memory. If your data can't fit in the plethora of CPU registers at your disposal, your software is probably too complicated. /s