segfault | Python C extension that segfaults

I'm working on embedded systems and my goal is to improve the safety of an existing code. I'm trying to follow Nasa's rules : https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code

The existing code contains dynamically allocated instances and variables which is pretty common, I'm required to translate the program to static memory alocation.

Is there generic practices and patterns to succesfully switch from dynamic to static memory allocation without breaking the code ?

In particular, I'm having issues with those kinds of mallocs :

Why does my code segfault when using the dynamic memory allocation in the code below ?Any pointers on what maybe happening? , im using valgrind and it points to the second loop being the issue .

Problem: I have a class (PortableFoo) designed to be very portable. It contains a scoped class PortableBar. The surrounding codebase (call it Client A) requires both Foo and Bar to have a function that cannot be implemented portably, and Foo's implementation must call Bar's implementation. The following is a solution that compiles and works in GCC, but I know invokes undefined behavior when it casts the reference from base to derived:

I would like to read a GRIB file downloaded from server using ecCodes library in Rust. However, my current solution results in segmentation fault. The extracted example, replicating the problem, is below.

I download the file using reqwest crate and get the response as Bytes¹ using bytes(). To read the file with ecCodes I need to create a codes_handle using codes_grib_handle_new_from_file()², which as argument requires *FILE usually get from fopen(). However, I would like to skip IO operations. So I figured I could use libc::fmemopen() to get *FILE from Bytes. But when I pass the *mut FILE from fmemopen() to codes_grib_handle_new_from_file() segmentation fault occurs.

I suspect the issue is when I get from Bytes a *mut c_void required by fmemopen(). I figured I can do this like that:

Other than the usual suspects (process.exit(), or process termination/signal, or crash/hardware failure), are there any circumstances where code in a finally block will not be reached?

The following typescript code usually executes as expected (using node.js) but occasionally will terminate immediately at line 4 with no exceptions being raised or change in the process exit code (exits 0/success):

When I run cpython with the -X showrefcount flag on an extension I'm writing, it reports a negative reference count (e.g. [-5538 refs, 13503 blocks]) when I return None from a function (using the Py-RETURN_NONE macro).

• The exact count varies between runs, but remains within the same order of magnitude.
• Whatever is happening, it seems to happen slowly; I need to call the extension function approximately 50,000 times before the reference count goes negative.
• If we replace Py_RETURN_NONE; with Py_INCREF(Py_None); return Py_None;, it changes nothing. Indeed, we can seemingly add an arbitrary number of Py_INCREF(Py_None)s without affecting the reference count at all.
• If we replace Py_RETURN_NONE; with return Py_None; and don't increment the reference count, it segfaults (as expected).
• If we replace the None return with another value, e.g. PyLong_FromLong(0);, the problem vanishes.

What is the cause of this? Related question: why is the reference count not zero after running an empty script?

In order not to have to remember to delete, we are using unique_ptr to manage the memory. We were under the impression that we can write and read in the memory, just that deletion is up to the smart pointer. However, the following code crashes on i=7220 with a segfault.

What is wrong?

I am writing a small TCP sockets "library", and I ran into much trouble.

When something happens to the socket that causes it to be instantly closed and freed (regardless of background lingering, talking about user space here), which is only done within a locked mutex since the application I'm writing is multi-threaded, I need a way to tell all the other (potentially) waiting threads (on the same mutex) that want to do something with the socket: "I'm terribly sorry, but the socket has been destroyed and you cannot access it" so that they don't cause any segmentation fault or such.

The idea I had was: the mutex was part of the socket (socket = a structure that contains multiple things, including a mutex and a file descriptor) so I couldn't quite free the socket if other threads were waiting for it (undefined behavior), so the possible solution is to allocate the mutex, free the socket but not the mutex, set some flag (in the allocated memory) saying that the socket has been closed, and a counter so that the last thread waking up and getting notified that it cannot use the socket unlocks and destroys the mutex and frees the memory allocated. The mutex can still be accessed without segfault if we just store its pointer before acquiring the mutex (and the pointer won't ever change).

This solution has a fundamental problem though - what if between unlocking the mutex and freeing it by the last holder, the thread gets preempted and another one locks the mutex again (since you NEED to check socket-related stuff after you acquire the lock, so no way of knowing it got destroyed, unless you maybe use an atomic variable but then again, checking the atomic variable and locking the mutex as a whole are not an atomic operation). Or if you try to access the mutex on the already-freed socket. Undefined behavior emerges.

Any ideas how to solve this problem? I.e. how to destroy a socket so that other threads know about it to quit safely, and there are no race conditions? By quitting I mean aborting the socket function they were in, not cancelling or stopping the threads themselves.

I am trying to get setup using GTK3+ and Glade. Unfortunately the most basic setup I can find online is sefaulting. In Glade I just created a basic window with the ID window_main. I'm not sure how this isn't working.

bytebowl.c