fault | Default CSS Settings as Silent Sass Classes | Application Framework library

This looks similar to your problem. Setting up android emulators on mac m1 pros requires extra installation steps.

Maybe I'm wrong, but it seems that last part:

Solved downgrading to the nov 2021 version of opencv

When exactly does segmentation fault happen (=when is SIGSEGV sent)?

When you attempt to access memory you don’t have access to, such as accessing an array out of bounds or dereferencing an invalid pointer. The signal SIGSEGV is standardized but different OS might implement it differently. "Segmentation fault" is mainly a term used in *nix systems, Windows calls it "access violation".

Why is the process in undefined behavior state after that point?

Because one or several of the variables in the program didn’t behave as expected. Let’s say you have some array that is supposed to store a number of values, but you didn’t allocate enough room for all them. So only those you allocated room for get written correctly, and the rest written out of bounds of the array can hold any values. How exactly is the OS to know how critical those out of bounds values are for your application to function? It knows nothing of their purpose.

Furthermore, writing outside allowed memory can often corrupt other unrelated variables, which is obviously dangerous and can cause any random behavior. Such bugs are often hard to track down. Stack overflows for example are such segmentation faults prone to overwrite adjacent variables, unless the error was caught by protection mechanisms.

If we look at the behavior of "bare metal" microcontroller systems without any OS and no virtual memory features, just raw physical memory - they will just silently do exactly as told - for example, overwriting unrelated variables and keep on going. Which in turn could cause disastrous behavior in case the application is mission-critical.

Why is it not recoverable?

Because the OS doesn’t know what your program is supposed to be doing.

Though in the "bare metal" scenario above, the system might be smart enough to place itself in a safe mode and keep going. Critical applications such as automotive and med-tech aren’t allowed to just stop or reset, as that in itself might be dangerous. They will rather try to "limp home" with limited functionality.

Why does this solution avoid that unrecoverable state? Does it even?

That solution is just ignoring the error and keeps on going. It doesn’t fix the problem that caused it. It’s a very dirty patch and setjmp/longjmp in general are very dangerous functions that should be avoided for any purpose.

We have to realize that a segmentation fault is a symptom of a bug, not the cause.

If you use a docker for your node server, then it might be set up incorrectly

The TLDR is that loads which miss all levels of the TLB (and so require a page walk) and which are separated by address unknown stores can't execute in parallel, i.e., the loads are serialized and the memory level parallelism (MLP) factor is capped at 1. Effectively, the stores fence the loads, much as lfence would.

The slow version of your insert function results in this scenario, while the other two don't (the store address is known). For large region sizes the memory access pattern dominates, and the performance is almost directly related to the MLP: the fast versions can overlap load misses and get an MLP of about 3, resulting in a 3x speedup (and the narrower reproduction case we discuss below can show more than a 10x difference on Skylake).

The underlying reason seems to be that the Skylake processor tries to maintain page-table coherence, which is not required by the specification but can work around bugs in software.

For those who are interested, we'll dig into the details of what's going on.

I could reproduce the problem immediately on my Skylake i7-6700HQ machine, and by stripping out extraneous parts we can reduce the original hash insert benchmark to this simple loop, which exhibits the same issue:

The issue was solved by updating the system packages.

In my case, it was installin the latest version of mesa-vulkan-drivers that probably fixed the issue.

I think this is something that's simply not meant to work: you are only supposed to call setcontext with a context obtained from getcontext or makecontext, and not with the context passed to a signal handler.

The man page hints at this obliquely:

If the context was obtained by a call to a signal handler, then old standard text says that "program execution continues with the program instruction following the instruction interrupted by the signal". However, this sentence was removed in SUSv2, and the present verdict is "the result is unspecified".

Also, the glibc source of setcontext has a comment:

This implementation is intended to be used for synchronous context switches only. Therefore, it does not have to restore anything other than the PRESERVED state.

Indeed, it does not attempt to restore any of the floating-point registers, and it zeroes rax (as for getcontext returning 0). That would be pretty bad for trying to resume code that isn't expecting its registers to change spontaneously.

Asynchronous context switching would be needed for something like preemptive multitasking in userspace. I think the idea is that since pthreads is now firmly established, people should have no need for this, so it's not supported. getcontext/setcontext date from an earlier era, and in fact have since been removed from the POSIX spec on the premise that pthreads should be used instead.

This particular crash seems to be caused by a mismatch between the kernel's layout of struct ucontext_t, and what libc expects. In particular, libc expects the floating-point state, including the saved value of mxcsr, at a particular offset within struct ucontext_t. However the kernel pushes the floating point state at a separate location on the stack (which happens to overlap where libc expects it), and includes a pointer to it inside struct ucontext_t. So libc's setcontext attempts to load some garbage value into mxcsr, which has some of the reserved bits 16-31 set, and this causes a general protection fault.

However, as noted above, this mismatch is the least of the problems.

Let's look at the three possible scenarios: