This bug is almost certainly not a bug in ripgrep or Rust or musl or any user code at all. Maybe one could complain that musl is using an inferior allocator that is freeing then immediately reallocating the same address.

edit: silly observation: the general Rust practice of using immutable bindings by default and not leaking shadowing bindings out of blocks would have made the bug I think I found less likely.

Thank you for writing virtually all of the intelligent competent comments on this page.

I would suggest you revisit this in a day or two and reevaluate whether your knee-jerk blaming of rust was appropriate here, then ask yourself what biases led you to do that.

Shevy is a long time troll. Should have been banned a while back

He's been banned multiple times actually (and from Reddit as well!) but he comes back with other names in the form of shevy-<language>>

I guess that makes introspection unlikely.

The bug is in the C code that Rust is interacting with. If anything, you seem to be making an argument in favor of replacing even more of the C code with Rust so that this doesn't happen.

What you seem to think is a defense of C is accidentally just providing ammunition to the "rewrite it in Rust" crusade that I'm guessing you're very much not a fan of. There are very solid arguments against rewriting everything in Rust, and you're arguably doing more harm than good by making a counterproductive one.

Rust wouldn't have helped, because this is a logic bug in the kernel, that creates a memory bug in userspace. The relevant kernel code would probably be marked "unsafe" with or without the bug.

> Rust wouldn't have helped, because this is a logic bug in the kernel, that creates a memory bug in userspace.

Unless I'm misunderstanding, the bug is kernel code accessing out-of-bounds memory in an array. That would 100% not segfault in normal Rust code.

> The relevant kernel code would probably be marked "unsafe" with or without the bug.

I mean, sure, if you remove the safety rails that prevent you from running off the side of the cliff, then you will in practice likely ending up running off the cliff. If you have to explicitly do that though, it still makes it a lot more obvious that this is a risk than if you refuse to have safety rails anyway for any purpose.

The kernel bug I believe hasn’t been root caused quite yet although the LLM does seem to have potentially found an unrelated problem.

Interesting, I hadn't heard that! That does sound like it's just as premature to claim Rust wouldn't have prevented it as it is to claim it would have, which I think stands as valid criticism of the comment I originally responded to.

It’s not. If you look at the analysis, the bug is present only in one version of the kernel everything else the same. It’s the kernel.

Also here’s a kernel developer confirming they think it’s the kernel: https://news.ycombinator.com/item?id=49134550

In addition to this likely not being a bug in the code you're pointing at, but the kernel (written in C). musl is literally C code, and that most rust users compile against glibc just like most C users do.

A kernel bug and you’re criticizing Rust. Weird take

As they wrote, it's "a bit sad" indeed because they cannot blame Rust for this.

They're a long-time anti-Rust zealot. This is the sort of nonsense they've been coming out with for years.

For starters, musl is a C library, not a Rust library.