Omega2 Docker for Cross Compilation

In my repositories ( GitHub and DockerHub ) I have an automated Dockerfile build based on borromeotlhs', but his is currently broken, and doesn't automate all the process.

Now you only need to pull from my Docker Hub with the command:

docker pull jlcs/omega2-sdk 

and then run make to finish the build (will take a long time).

Or use this other one with the toolchain already built (see Edit 2 below):

docker pull jlcs/omega2-docker-built

To run it use:

docker run -it --name omega2-sdk-app -v /my_host_dir:/remote jlcs/omega2-sdk bash

or the bigger one (see Edit 2)

docker run -it --name omega2-sdk-app -v /my_host_dir:/remote jlcs/omega2-docker-built bash

where the container is given a name, shared directory and opens a terminal.

How to compile C code

Once you are in the Docker container, some environment variables are set (maybe not depending on current dockerfile) for you to use:

mipsel-openwrt-linux-gcc [options] 

The compiler binaries are generated inside the directory:

/lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl-1.1.15/bin/

Note: The 'el' in mipsel indicates it is a Little Endian version of MIPS.

Another option is to create a package, and install with opkg, as explained here (step 6b).

Edits

Edit 1: What to change for Omega2+

If you read the Dockerfile you will notice the lines

# Set SDK environment for Omega2
# For Omega2+ change the third echo line with: (notice the 'p' for plus)
#  echo "CONFIG_TARGET_ramips_mt7688_DEVICE_omega2p=y" > .config && \

RUN echo "CONFIG_TARGET_ramips=y" > .config  && \
    echo "CONFIG_TARGET_ramips_mt7688=y" >> .config  && \
    echo "CONFIG_TARGET_ramips_mt7688_DEVICE_omega2=y" >> .config && \
    make defconfig

So before running make, you can run

echo "CONFIG_TARGET_ramips=y" > .config  && \
echo "CONFIG_TARGET_ramips_mt7688=y" >> .config  && \
echo "CONFIG_TARGET_ramips_mt7688_DEVICE_omega2p=y" >> .config && \
make defconfig

And then run make.

Edit 2: Added docker image with prebuilt SDK (Omega2)

In this second Docker Hub repository I simply run make tools/install and make toolchain/installfrom my previous image.

The download is about 2GB.

Use

docker pull jlcs/omega2-docker-built

to download it.

Edit 3: Added CMake support.

You can update your image with CMake 3.7.2, and use this Toolchain-omega2-mipsel.cmake file to configure your cross-compilation:

# this one is important
SET(CMAKE_SYSTEM_NAME Linux)
#this one not so much
SET(CMAKE_SYSTEM_VERSION 1)

# specify the cross compiler
SET(CMAKE_C_COMPILER   /lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl/bin/mipsel-openwrt-linux-gcc)
SET(CMAKE_CXX_COMPILER /lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl/bin/mipsel-openwrt-linux-g++)

# where is the target environment 
SET(CMAKE_FIND_ROOT_PATH  /lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl)

# search for programs in the build host directories
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# for libraries and headers in the target directories
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) 

# From:
# http://www.vtk.org/Wiki/CMake_Cross_Compiling

# Use the commands:
# mkdir build
# cd build
# cmake -DCMAKE_TOOLCHAIN_FILE=Toolchain-omega2-mipsel.cmake ..
# make

Edit 4: A Docker micro-reference

Check this cheat sheet and this other one.

Some definitions:

• Image – a read-only layer that is the base of your container. It can have a parent image to abstract away the more basic filesystem snapshot. So a Java image would inherit from a linux image with the preinstalled utilities. A tomcat image will have a Java image as the parent because it depends on Java to run Tomcat.
• Container – a runnable instance of the image, basically it is a process isolated by docker that runs on top of the filesystem that an image provides.

Some commands:

• Download an image, and all its parents, from the registry:

docker pull image-name

• Run a shell command inside a freshly created and started container:

docker run -ti --name container-name image-name /command

• Start and stop a container, duh!

docker start container-name
docker stop container-name

• Run a command inside a container from the image and remove the container when command is done.

docker run --rm -ti image-name /command

Source

Simplified vision of Docker:

Sharing host folders as a mounted volume:

Images from dotnetcurry

@John-Wright
bonjour is needed if you want to use http://omega-ABCD.local/, instead use http://192.168.3.1 when connecting to the omega's wifi access point.

@Patrick-Rainsberry

try with Omega's numeric IP, like 192.168.3.1 if connected to its AP.

@Paul-Grant
check @WereCatf 's source directory, specially first_time_setup.sh and my docker project on info about how to build from LEDE.

The OnionIoT repository is not ready yet, they will publish the source code in the future*.

@Mathieu-Gosbee

• You don't need the full SDK, nor in Docker, nor in your host pc. You can download the toolchain directly, as you can find in the third answer of this thread.
• Omega2 comes with SSH already listening, you can use scp to copy the binary, no need for sftp. Also, for windows, I prefer moba xterm than putty, which is based in putty, but better UI. More info in the docs.
• If you want to use windows, there is a thread that shows how to use Bash on Ubuntu on Windows to develop on windows without docker or virtual machines.
• Unless you love to code on VIM through serial or SSH in the omega, you are probably using a text editor like Sublime Text or Atom, or a full IDE, like CLion, Visual Studio, etc. to code a serious project. Why bother copying the source code and compiling in the omega when you can set up a faster and standard (& this) workflow in your pc?
• If your project is so small that gcc can compile it inside the omega2, why not use another programming language, like python? Here the docs about the libraries and supported languages. Python even has a GPIO module that C doesn't.

@Paul-Kourany it's always useful to post the kernel panic log to help debugging. If you have serial connection, open an issue with all the info you can.

From my other post you can see it's not the only package with problems due to kernel mismatch.
Using --force-* is not usually a good idea if you want things to work. I think openssl works fine until you use VPN because the VPN must interact with the IP stack and that is kernel stuff.

Right now I see 3 options:

• Find a package compiled for the kernel version the Omega2 firmware uses (uname -ra I think).
• Compile your own firmware using the LEDE SDK (in my signature there is a Docker project for that, or you can use @WereCatf 's github source repository with a script that automates everything). Problem with this option, the wifi is shit without the onion ralink driver, and it, of course, kernel panics in custom firmwares with most recent kernel. Note too that I did not try enough compiling a custom firmware with lower kernel version, and that should be the way to go.
• Wait until onion releases their SDK configuration and then everybody should be able to build a custom decent firmware with all their needs.

@Richard-Berg
check 5 posts above, the Edit1, changing curl with your package.

@José-Luis-Cánovas said in [Project] Docker Omega2 SDK for Cross Compilation + CMake support:

Edit 1: Install curl before running the script:

First, we need to login as root in the container to gain privileges to install new packages.
With the docker container stopped, run:
[Run in your host's terminal (mac, windows, linux)]

$   docker start omega2-sdk-app-built
$   docker exec -ti --user root omega2-sdk-app-built bash

Now you are root user inside the container. Install the curl package.
[Run inside the docker container]

#   apt update && apt install -y curl
#   exit

Then, go back to the container as omega user with the usual:
[Run in your host's terminal (mac, windows, linux)]

$   docker start omega2-sdk-app-built
$   docker attach omega2-sdk-app-built

Run the script above.

This is because omega user haven't got sudo permissions, and I prefer not to run anything inside docker with root permissions. Because the --user root option in docker is an easy and explicit way to use root, I don't plan to change this.

If you need to, create your own Dockerfile with FROM jlcs/omega2-docker-built at the start, and you will have ready to go image for your project.

Also, tell me what packages you need, because I plan to add many others.

@Jo-Kritzinger
Think of Docker as a virtual machine (doesn't work like that, but for the sake of simplicity), in particular, an Ubuntu 14.04 with some files added (/lede/*).

Anything you run on the Docker container, doesn't affect your host machine, only your shared directories, and those are for copying code.

Now that we think of the container as a machine on its own, let's see the SDK.
Ubuntu comes with gcc that compiles C code to its own architecture, and it can run the compiled binaries with its shared libraries, e.g. in /usr/lib. All that is fine, if you compile for the PC.
Omega2 can't compile anything because the compiler is too big for it to run on the Omega2. Therefore, we need a cross compiler, including the gcc binary and cross compiled libraries aiming for the same MIPSel arquitecture as the Omega2 has.
The gcc binary and cross compiled libraries are not in your Ubuntu 14.04 /usr/lib directory, because Ubuntu doesn't need any of them. They are inside the /lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl/ (the compiler) and /lede/staging_dir/target-mipsel_24kc_musl/ (the include and library files) directories. There is where mipsel-openwrt-linux-gcc must look for the headers and libraries (see below).

Your errors come from the linker not finding suitable files for your specified libraries, because the directory is wrong.

One bug I find is that your toolchain dir has a -1.1.16 in the end. It is now gone in the new builds of the docker image.

Another thing you can do is pasting these lines in your ~/.bashrcfile, or exec a docker pull from the last image built, where the env vars are already set:

export PATH "$PATH:/lede/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl/bin"
export STAGING_DIR "/lede/staging_dir"
export CFLAGS=-I/lede/staging_dir/target-mipsel_24kc_musl/usr/include
export LDFLAGS=-L/lede/staging_dir/target-mipsel_24kc_musl/usr/lib

Notice that PATH no longer has -1.1.16, and the include and libraries directories are set for the compiler.

Finally, once you compile successfully and copy it to the Omega2, the binary that uses shared libraries will find the .so objects in the Omega2 too, but the lede SDK already have them all in your host machine.

@Jo-Kritzinger
if you are still interested, I added (in the OP edits) the image with all the make commands to build the SDK already executed, and also added CMake support, very easy to use and works like a charm for me.

If you use CLion projects for example, you only have to copy your source code to the shared directory (between your mac and docker), copy the Toolchain-omega2-mipsel.cmake file I posted in the Edit 3 and run cmake from docker as said in the last lines.
If any errors happen, delete the CMake cache files and try again.