glibc | This directory contains the sources of the GNU C Library

Missing the module.lds file in the latest kernel. Apply the following source code as a patch in the kernel and build the image.

As it can see, at the second line to last, shm_open is a undefined symbol even though -lrt is appended.

This is expected: you are linking against librt.so. The definition of shm_open is in librt.so, and not in your library.

What should be done to get this problem fixed?

There is no problem and there is nothing to fix here.

It seems it was not an issue with the code but with the input data which had debug info (see EDIT2 in the question)

I found out the "-ldl" link option was ignored because it was placed too early in the final c++ link command during make. So if you want to use external .so file and need to use libdl.so, you should configure qemu like this. (under qemu-5.1.0/build directory)

../configure --target-list=aarch64-softmmu --enable-debug --enable-gtk --extra-ldflags="-Wl,--no-as-needed,-ldl"

The -Wl,--no-as-needed,-ldl part was added. (the others are for my needs). -as-needed is the default and it lists the needed library in the elf file. I tested it with just -ldl but it didn't work, hence the final command.

The root cause of the issue is highlighted clearly in the output of the fix-broken command:

Basically, you should get the point (based on your latest comment). Docker is based on some command, when it's done - it stops the container.

So to make it continuously running you should have command and run infinitely.

Also check this answer as well, there are more explanation Why docker exiting with code 0

One of the easiest solution is to tail some logs. Like,

This is not a cmake-related error, it's just how the library was implemented. I do not know why, but it appears that the specialization of T* at::Tensor::data const with T = long long was forgotten/omitted.

If you want to get your signed 64-bits pointer, you can still get it with int64_t:

The key difference between these is that older versions of the busybox image statically linked busybox against glibc (current versions dynamically link busybox against glibc due to use of libnss even in static configuration), whereas the alpine image dynamically links against musl libc.

Going into the weighting factors used to choose between these in detail would be off-topic here (software recommendation requests), but some key points:

Comparing glibc against musl libc, a few salient points (though there are certainly many other factors as well):

• glibc is built for performance and portability over size (often adding special-case performance optimizations that take a large amount of code).
• musl libc is built for correctness and size over performance (it's willing to be somewhat slower to have a smaller code size and to run in less RAM); and it's much more aggressive about having correct error reporting (instead of just exiting immediately) in the face of resource exhaustion.
• glibc is more widely used, so bugs that manifest against its implementation tend to be caught more quickly. Often, when one is the first person to build a given piece of software against musl, one will encounter bugs (typically in that software, not in musl) or places where the maintainer explicitly chose to use GNU extensions instead of sticking to the libc standard.
• glibc is licensed under LGPL terms; only software under GPL-compatible terms can be statically linked against it; whereas musl is under a MIT license, and usable with fewer restrictions.

Comparing the advantages of a static build against a dynamic build:

• If your system image will only have a single binary executable (written in C or otherwise using a libc), a static build is always better, as it discards any parts of your libraries that aren't actually used by that one executable.
• If your system image is intended to have more binaries added that are written in C, using dynamic linking will keep the overall size down, since it allows those binaries to use the libc that's already there.
• If your system image is intended to have more binaries added in a language that doesn't use libc (this can be the case for Go and Rust, f/e), then you don't benefit from dynamic linking; you don't need the unused parts of libc there because you won't be using them anyhow.

Honestly, these two images don't between themselves cover the whole matrix space of possibilities; there are situations where neither of them is optimal. There would be value to having an image with only busybox that statically links against musl libc (if everything you're going to add is in a non-C language), or an image with busybox that dynamically links against glibc (if you're going to add more binaries that need libc and aren't compatible with musl).

I reported this to the maintainers. It has been fixed by the following commit.

https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/commit/?id=20f1ee93171895341877b8c5679a33823c4ca582