Beginner friendly guidance for building a static binary

[whacked]

Hi, I recently discovered Ian Henry's Janet for Mortals and am checking it out casually but with great interest. In it he writes "You can compile Janet programs into statically-linked native binaries and give them to people who have never even heard of Janet before", which I am very interested in trying, but didn't find a thorough treatment in the book.

In the discussion at #818 @fjan77's reply makes it look easy, but I don't have the background knowledge to connect the dots, so I'd greatly appreciate some guidance and hopefully it will help someone else with the same objectives.

I am on ubuntu 22.04 and I run the nix package manager, so I have 2 ways of setting up janet / jpm. The first is via nix flake, which I'll leave out of scope for now, except that in the flake, the least requirements to get started are to declare nixpkgs.janet and nixpkgs.jpm. Without the flake, I compile janet and jpm from the github source. I don't do global install but I specify environment variables and flags where necessary.

(side comment for completeness) : I cloned janet to /tmp/janet and built it there; then cloned jpm to /tmp/jpm but in order to compile jpm, it wants the path to janet, so I ended up compiling jpm from the janet directory tree, resulting in the jpm binary getting saved within the /tmp/janet hierarchy. For my current exploration, it shouldn't matter, and I will always be using janet/jpm in unprivileged mode.

Following another github thread, I test a dynamically linked executable with

# temp.janet
(defn main
  [&]
  (print "hello"))

I have this Makefile; the contrived paths resolve the funny structure from my janet build from github -- for now this is just to verify reproducibility

temp: temp.janet
	C_INCLUDE_PATH=/tmp/janet/build /tmp/janet/build/jpm/usr/local/bin/jpm --libpath=/tmp/janet/build -v quickbin $< $@

this is successful.

$ make
$ ./temp
hello

similarly, within the flake devShell, this creates a working executable:

# jpm looks in jpm's store path by default; the correct janet libpath is in ${nixpkgs.janet}/lib
$ jpm --libpath=/nix/store/ib2sqi3rfk2pr9kbdvb7q50np9mq0zd4-janet-1.32.1/lib quickbin temp.janet temp
$ ./temp
hello

from here, how can I get to a statically linked binary?

To verify a working musl-gcc I did

$ nix-shell musl
$ cat > main.c <<EOF
#include <stdio.h>
int main(int argc, char *argv[]) { printf("hello \n"); }
EOF
$ musl-gcc -static main.c
$ ./a.out
hello

following discussion #818 I create such a project.janet

(declare-project
 :name "probably-unimportant")

(declare-executable
  :name "project-temp"
  :entry "temp.janet"
  :lflags ["-static"])

running jpm --libpath=/nix/store/ib2sqi3rfk2pr9kbdvb7q50np9mq0zd4-janet-1.32.1/lib build prints a swath of errors, interesting ones are like

/nix/store/1fn92b0783crypjcxvdv6ycmvi27by0j-binutils-2.40/bin/ld: /nix/store/ib2sqi3rfk2pr9kbdvb7q50np9mq0zd4-janet-1.32.1/lib/libjanet.a(meson-generated_.._janet.c.o): in function `add_timeout':
(.text+0x512): undefined reference to `__fprintf_chk'
/nix/store/1fn92b0783crypjcxvdv6ycmvi27by0j-binutils-2.40/bin/ld: (.text+0x34b8): undefined reference to `fcntl64'

so this is at the edge of my knowledge of working with musl. It could also be a nix environment problem, though I have not used musl outside of a nix shell on my machine before. The cosmopolitan path #1322 looks the most interesting, but at the moment I'm hoping to get static binaries working.

[sogaiu]

I used qemu to setup an Alpine environment temporarily and carried out similar steps successfully.

Below is a summary of what I tried.

Setup and start Alpine system

wget https://dl-cdn.alpinelinux.org/alpine/v3.19/releases/x86_64/alpine-standard-3.19.0-x86_64.iso
# fetch and check sha256 / signature as desired -- see https://www.alpinelinux.org/downloads/

qemu-img create -f raw mykvm.config 1G
qemu-system-x86_64 -enable-kvm -m 2048 -name mykvm -cdrom alpine-standard-3.19.0-x86_64.iso -drive file=mykvm.config,if=virtio,format=raw -boot d

After it starts up, login as root (no / blank password), then use fdisk to create a partition:

fdisk /dev/vda

I used n to add a new primary partition and chose default values,
then chose w to write the table and exit.

Prepare filesystem, mount, and start setup:

mkdosfs /dev/vda1
mkdir -p /media/vda1
echo "/dev/vda1 /media/vda1 vfat rw 0 0" >> /etc/fstab
mount -a
setup-alpine  # (select vda1 for saving configs)

Answered (mostly defaults):

* Keymap [none]
* Hostname [localhost]
* Interface [eth0]
* Ip address for eth0? [dhcp]
* Do you want to do any manual network configuration? (y/n) [n]
* Root Password <something-appropriate>
* Timezone [UTC]
* Proxy [none]
* APK Mirror
  * Enter mirror number or URL: [1]
* User [no]
* Which ssh server? [none]
* Disk & Install
  * Which disk(s) would you like to use? [none]
  * Enter where to store configs [vda1]
  * Enter apk cache directory [/media/vda1/cache]

Update apk repository indexes

apk update

Install some packages

apk add gcc make git musl-dev

Tweak PATH things:

mkdir -p $HOME/.local/bin
export PATH=$HOME/.local/bin:$PATH

Fetch janet source:

mkdir src
cd src
git clone https://github.com/janet-lang/janet
cd janet

Build and install janet and jpm:

PREFIX=$HOME/.local make
PREFIX=$HOME/.local make install
PREFIX=$HOME/.local make install-jpm-git

Make static executable sample dir:

cd ..
mkdir sample
cd sample

Create sample file project.janet:

(declare-project
  :name "static-sample")

(declare-executable
  :name "static-sample"
  :lflags ["-static"]
  :entry "main.janet")

Create sample file main.janet:

(defn main
  [& args]
  (print "hi there"))

Build:

jpm build

Check result:

ldd build/static-sample
./build/static-sample

N.B. I didn't try to persist this enivornment. Possibly using lbu commit at the end of the above steps might give a reusable setup.

Update: I tried lbu commit. The packages installed via apk stuck around and apparently system settings did as well, but fetched janet source and the sample didn't.

---

References

• https://wiki.alpinelinux.org/wiki/Running_Alpine_in_Live_mode_in_QEMU
• https://www.qemu.org/docs/master/system/devices/net.html

[whacked]

Thank you for the comprehensive answer. I was able to fully reproduce your result.

Using this environment as a baseline, I was eventually able to cobble together a nix environment that loads musl and outputs a statically linked binary as well. The flake definition is here. It's not pretty, but you can either reproduce the static-sample binary by running nix build, or by entering the nix develop shell, jpm build and produce the binary.

This was super helpful, I really appreciate it, and hope this useful to someone else!