rtnetlink | Package rtnetlink provides low-level access

If I follow the code correctly, you're redoing a ton of work for every IP address that doesn't need to be redone. Every time through the main loop you're:

• creating a new packet socket
• binding it
• setting up a tx packet ring buffer
• mmap'ing it
• sending a single packet
• unmapping
• closing the socket

That's a huge amount of work you're causing the system to do for one packet.

You should only create one packet socket at the beginning, set up the tx buffer and mmap once, and leave it open until the program is done. You can send any number of packets through the interface without closing/re-opening.

This is why your top time users are setsockopt, mmap, unmap, etc. All of those operations are heavy in the kernel.

Also, the point of PACKET_TX_RING is that you can set up a large buffer and create one packet after another within the buffer without making a send system call for each packet. By using the packet header's tp_status field you're telling the kernel that this frame is ready to be sent. You then advance your pointer within the ring buffer to the next available slot and build another packet. When you have no more packets to build (or you've filled the available space in the buffer [i.e. wrapped around to your oldest still-in-flight frame]), you can then make one send/sendto call to tell the kernel to go look at your buffer and (start) sending all those packets.

You can then start building more packets (being careful to ensure they are not still in use by the kernel -- through the tp_status field).

That said, if this were a project I were doing, I would simplify a lot - at least for the first pass: create a packet socket, bind it to the interface, build packets one at a time, and use send once per frame (i.e. not bothering with PACKET_TX_RING). If (and only if) performance requirements are so tight that it needs to send faster would I bother setting up and using the ring buffer. I doubt you'll need that. This should go a ton faster without the excess setsockopt and mmap calls.

Finally, a non-blocking socket is only useful if you have something else to do while you're waiting. In this case, if you have the socket set to be non-blocking and the packet can't be sent because the call would block, the send call will fail and if you don't do something about that (enqueue the packet somewhere, and retry later, say), the packet will be lost. In this program, I can't see any benefit whatsoever to using a non-blocking socket. If the socket blocks, it's because the device transmit queue is full. After that, there's no point in you continuing to produce packets to be sent, you won't be able send those packets either. Much simpler to just block at that point until the queue drains.

Launching the container for the same image from the command line doesn't fail, if you look at the logs of the container that you started with Docker Desktop you'll see the same lines.

What happens is that the centos dockerfile use bash as its default command.

When you run a container it will attach to stdout and stderr by default but not stdin.

adding -i will attach stdin.

adding -t will provide you with a pseudo-tty

To actually use bash you'll need to provide both : -it

To sum up, here's how to mimick what Docker Desktop does, starting the container in the background with -d:

The problem here is that you are using a physical interface instead of using a bridge. If you would like to use bridge networking, you need to create a bridge or let OpenNebula create it for you.

Let me know if this answers your issue, if not, feel free to submit your query on OpenNebula Forum - https://forum.opennebula.io/. :)

The issue was that I needed to add "Dummy net driver support" under Device Drivers / Network device support / Network core driver support. I think this may have been built as a module by default. But I included it as a built-in feature.

As one of the comments said, it does not make sense to RUN a tc command during the build phase.

The workaround I used was:

1. Add permissions for tc in the container (if the eventual container user is not root), but don't actually RUN any of the tc commands in the Dockerfile.
2. Build the container as normal.
3. Run the container, adding --cap-add=NET_ADMIN
4. From inside the running container, execute the tc commands.

I solved this the other day for my Pi-2 by removing Wireguard updating/upgrading the Kernel to the latest version, installing the Kernel headers, and reinstalling Wireguard. Worked like a charm after that.

But, you may only need the kernel headers. You can try doing "sudo apt-get install raspberrypi-kernel-headers" before anything else.

I'm on:

Linux raspberrypi 4.19.118-v7+ #1311 SMP Mon Apr 27 14:21:24 BST 2020 armv7l GNU/Linux

You do anyone of below:

1.You can follow these steps to uninstall flannel