The standard memory management facilities available in plain C typically use private anonymous memory. This means that a pointer returned by malloc is backed only by an underlying physical page (see
https://www.kernel.org/doc/html/latest/admin-guide/mm/concepts.html#anonymous-memory if you want to learn more). Once the memory is freed, or the process closes (or it swaps...), that physical page will be repurposed by the OS for something else. The application won't be able to reconnect back to that memory location to access the same data again, which means that the in-memory state of an application has to be rebuilt every time that application starts up. But the whole point of persistent memory is that it's persistent, and you can reconnect to some existing state. So what can we do? Well, we can use file-backed DAX (direct access) memory. Such memory allows us to use a file to identify the in-memory state that we want to persist across application restarts. But standard malloc() doesn't have that functionality - as I explained earlier, it typically only relies on anonymous memory. Also, and more to the point that the quoted sentence makes, malloc is not failure atomic. If you allow applications to reconnect to some existing memory state, you also have to make sure that things in that state stay consistent. Allocating memory (from a persistent state) without linking it anywhere so that it's reachable would create a persistent memory leak. This means that a memory allocator for persistent memory needs to atomicity allocate and link that memory somewhere.