summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authoru <u@billy>2023-11-17 14:37:58 -0500
committeru <u@billy>2023-11-17 14:38:55 -0500
commit2493370e44566970dae72afd5553566962a4284c (patch)
tree61d5ac99f5a91aaa651db11db1f248e8d17a97f4
parent53602a78a8f743dd1e17f186cc19d89e7a83b9aa (diff)
delete cruft files
Diffstat
-rw-r--r--Makefile25
-rwxr-xr-xsrc/grub-efi.sh65
-rwxr-xr-xsrc/initrd.sh59
-rwxr-xr-xsrc/mkinitramfs-samizdat85
-rwxr-xr-xsrc/parted-usb.sh389
-rwxr-xr-xsrc/publish-ip.sh53
-rwxr-xr-xsrc/qemu.sh129
-rwxr-xr-xsrc/store-child-permanently47
-rwxr-xr-xsrc/xorriso-usb.sh295
9 files changed, 4 insertions, 1143 deletions
diff --git a/Makefile b/Makefile
index 6265999..db124be 100644
--- a/Makefile
+++ b/Makefile
@@ -37,27 +37,10 @@ wait_for_files: src/wait_for_files.c | build-deps
37%: src/%.c | build-deps 37%: src/%.c | build-deps
38 $(CC) $(CFLAGS) $< -o $@ 38 $(CC) $(CFLAGS) $< -o $@
39 39
40dyndns_realprog = dyndns.ssh-rsa.cryptonomic.net 40src_bin_programs = btrfs-functions.sh var.sh dnsmasq-dhcp-script.sh usb partvi
41dyndns_links = dyndns.ssh-dss.cryptonomic.net \
42dyndns.ecdsa-sha2-nistp256.cryptonomic.net dyndns.ssh-ed25519.cryptonomic.net
43dyndns_progs = $(dyndns_realprog) $(dyndns_links)
44
45$(addprefix src/, $(dyndns_links)):
46 ln -s $(dyndns_realprog) $@
47
48src_bin_programs = xorriso-usb.sh btrfs-functions.sh btrfs-receive-root.sh \
49btrfs-send-root.sh var.sh grub-efi.sh keygen.sh initrd.sh qemu.sh \
50dnsmasq-dhcp-script.sh publish-ip.sh \
51git-ll-remote usb \
52hostname.cryptonomic.net partvi ficlonerange.py ${dyndns_progs}
53 41
54bin_programs=$(addprefix src/, $(src_bin_programs)) samizdat-paths.sh ${cc_files} ${btrfs_utils} 42bin_programs=$(addprefix src/, $(src_bin_programs)) samizdat-paths.sh ${cc_files} ${btrfs_utils}
55 43
56dyndns_programs = cryptonomic-dyndns-command samizdat-ssh-command samizdat-ssh-uid
57dyndns_program_paths=$(addprefix cryptonomic-dyndns-server/bin/, $(dyndns_programs))
58
59bin_programs += $(dyndns_program_paths)
60
61btrfs_utils=$(addprefix src/btrfs-utils/, btarfs with-btrfs-seed) 44btrfs_utils=$(addprefix src/btrfs-utils/, btarfs with-btrfs-seed)
62 45
63initrd_files:=$(wildcard src/initrd/*) dynmenu samizdat-pinentry wait_for_files 46initrd_files:=$(wildcard src/initrd/*) dynmenu samizdat-pinentry wait_for_files
@@ -163,7 +146,7 @@ $(btrfs_images): FORCE
163 $(MAKE) -C rootfs $(notdir $@) 146 $(MAKE) -C rootfs $(notdir $@)
164 147
165boot: rootfs 148boot: rootfs
166 sudo ./src/mkinitramfs-samizdat 149 sudo update-initramfs -u
167 sudo ROOTFS=$(rootfs) ./src/parted-usb.sh 150 sudo ROOTFS=$(rootfs) ./src/parted-usb.sh
168 151
169fastboot: rootfs 152fastboot: rootfs
@@ -265,13 +248,13 @@ bootclean:
265.PHONY: update upgrade up upgrade-key initrd 248.PHONY: update upgrade up upgrade-key initrd
266 249
267initrd: install 250initrd: install
268 ./src/mkinitramfs-samizdat 251 sudo update-initramfs -u
269 252
270update: apt-get-update-stamp 253update: apt-get-update-stamp
271 git pull --ff-only --recurse-submodules 254 git pull --ff-only --recurse-submodules
272 255
273upgrade: install-submodules install 256upgrade: install-submodules install
274 ./src/mkinitramfs-samizdat -f 257 sudo update-initramfs -u
275 258
276upgrade-key: upgrade key 259upgrade-key: upgrade key
277 260
diff --git a/src/grub-efi.sh b/src/grub-efi.sh
deleted file mode 100755
index f3f6b1c..0000000
--- a/src/grub-efi.sh
+++ /dev/null
@@ -1,65 +0,0 @@
1#!/bin/bash
2. samizdat-paths.sh
3
4if [ "$BOOTLOADER_ONLY" ]
5then
6 linux_kernel_commandline='boot=samizdat components quiet nbdroot=192.168.10.1/samizdat.btrfs nbddev=/dev/nbd0 ip=dhcp'
7else
8 linux_kernel_commandline='boot=samizdat components quiet'
9fi
10
11grub_config()
12{
13 cat <<EOF
14insmod echo
15echo GRUB (samizdat)
16
17insmod normal
18insmod keystatus
19
20insmod linux
21insmod iso9660
22
23insmod part_acorn
24insmod part_amiga
25insmod part_apple
26insmod part_bsd
27insmod part_dvh
28insmod part_gpt
29insmod part_msdos
30insmod part_plan
31insmod part_sun
32insmod part_sunpc
33
34echo Loading vmlinuz...
35
36linux /linux/vmlinuz ${linux_kernel_commandline}
37
38echo Loading initrd.img...
39initrd /linux/initrd.img
40
41echo Booting.
42echo
43boot
44
45EOF
46}
47
48real_destdir=$samizdat_grub_efi_dir
49[ "$real_destdir" ] || exit 1
50destdir=$real_destdir.tmp
51
52set -e
53rm -r "${destdir}" 2>/dev/null || true
54mkdir -p "${destdir}"/grub/i386-pc/
55cp -r /usr/lib/grub/i386-pc/* "${destdir}"/grub/i386-pc/
56rm "${destdir}"/grub/i386-pc/*.img || true
57
58grub_config > "${destdir}"/load_cfg
59
60grub-mkimage -O i386-pc -d /usr/lib/grub/i386-pc/ -o "${destdir}"/core.img -c "${destdir}"/load_cfg --prefix=/grub iso9660 biosdisk
61cat /usr/lib/grub/i386-pc/cdboot.img "${destdir}"/core.img > "${destdir}"/grub/i386-pc/eltorito.img
62cat /usr/lib/grub/i386-pc/boot.img "${destdir}"/core.img > "${destdir}"/embedded.img
63
64rm -r "$real_destdir" 2>/dev/null || true
65mv -T "$destdir" "$real_destdir"
diff --git a/src/initrd.sh b/src/initrd.sh
deleted file mode 100755
index 2ec278d..0000000
--- a/src/initrd.sh
+++ /dev/null
@@ -1,59 +0,0 @@
1#!/bin/sh
2
3. samizdat-paths.sh
4
5if [ -d "$1" ]
6then
7 samizdat_linux_dir=$1
8fi
9
10initrd=${samizdat_linux_dir}/initrd.img
11vmlinuz=${samizdat_linux_dir}/vmlinuz
12
13conf_dir=$samizdat_initramfs_conf_dir
14
15get_kernel_version()
16{
17 local pkgs_file="$1"
18 egrep '^ii linux-image-(amd64|686)' "$pkgs_file" |
19 (read _ pkg ver _; apt-cache show "$pkg=$ver") |
20 grep Depends |
21 (read _ a; echo ${a#linux-image-})
22}
23
24pkgs_file=rootfs/_build/${rootfs:-samizdat}.pkgs.txt
25
26[ -f "$pkgs_file" ] || exit
27
28kernel_version=$(get_kernel_version rootfs/_build/${rootfs:-samizdat}.pkgs.txt)
29
30[ "$kernel_version" ] || exit
31
32debian_initrd=/boot/initrd.img-${kernel_version}
33
34find_deps() {
35 find "$conf_dir" "$samizdat_initrd_files_dir" "$debian_initrd" "$@"
36}
37
38force_rebuild()
39{
40 touch "$conf_dir"
41 return 1
42}
43
44rebuild()
45{
46 set -ex
47 cp -f /boot/vmlinuz-"${kernel_version}" "$vmlinuz"
48 /usr/sbin/mkinitramfs -d "$conf_dir" -o "$initrd" "${kernel_version}" || force_rebuild
49}
50
51if [ ! -e "$initrd" -o ! -e "$vmlinuz" ]; then
52 rebuild
53else
54 found=$(find_deps -newer "$initrd" -print -quit)
55 if [ "$found" ]; then
56 echo "initrd.sh: rebuild forced: found modified source: $found" >&2
57 rebuild
58 fi
59fi
diff --git a/src/mkinitramfs-samizdat b/src/mkinitramfs-samizdat
deleted file mode 100755
index c2e6141..0000000
--- a/src/mkinitramfs-samizdat
+++ /dev/null
@@ -1,85 +0,0 @@
1#!/bin/bash
2if [ "$(id -u)" != 0 ]
3then
4 exec sudo -- "$0" "$@"
5 exit 1
6fi
7
8loudly()
9{
10 (set -x
11 "$@")
12}
13
14deb_arch()
15{
16 dpkg-architecture -q DEB_HOST_ARCH
17}
18
19up_to_date()
20{
21 local found
22 [ -e "$1" ] || return
23 [ -z "$FORCE_BUILD" ] || return
24 found=$(find "$samizdat_initramfs_conf_dir" \
25 "$samizdat_initrd_files_dir" \
26 -type f -newer "$1" -print -quit) || return
27 [ -z "$found" ]
28}
29
30build_image()
31{
32 OUTPUT=/boot/initrd.img-$1
33 # Always regenerate when --system specified.
34 # Otherwise, only regenerate if it appears dependencies changed.
35 if ! up_to_date "$OUTPUT"
36 then
37 /usr/sbin/mkinitramfs \
38 -d "$samizdat_initramfs_conf_dir" \
39 -o "$OUTPUT" \
40 -k "$1" || return
41 fi
42 loudly ln -sf "${OUTPUT#/}" /initrd.img
43}
44
45. samizdat-paths.sh
46
47OUTPUT_TAG=
48FORCE_BUILD=
49while [ $# -gt 0 ]
50do
51 case "$1" in
52 -t|--tag) OUTPUT_TAG=.samizdat;;
53 -f|--force) FORCE_BUILD=y;;
54 --) shift; break;;
55 -*) exit 1;;
56 *) break;;
57 esac
58 shift
59done
60
61if [ "$1" ]
62then
63 k=/boot/vmlinuz-$1
64 if ! [ -e "$k" ]
65 then
66 printf 'Error: No such file: %s\n' "$k" >&2
67 exit 1
68 fi
69 build_image "$1$OUTPUT_TAG" || exit
70 ln -sf "${k#/}" /vmlinuz
71elif [ -L /vmlinuz ]
72then
73 l=$(readlink /vmlinuz)
74 mv=${l#boot/vmlinuz-}
75 for v in "$mv" "$mv-$(deb_arch)"
76 do
77 [ -e "/boot/vmlinuz-$v" ] || continue
78 build_image "$v"
79 exit
80 done
81 exit 1
82else
83 printf 'Error: Could not determine kernel version. Create /vmlinuz or specify a version.' >&2
84 exit 1
85fi
diff --git a/src/parted-usb.sh b/src/parted-usb.sh
deleted file mode 100755
index bd8eeae..0000000
--- a/src/parted-usb.sh
+++ /dev/null
@@ -1,389 +0,0 @@
1#!/bin/bash
2USE_EFI=
3die()
4{
5 printf 'Error: %s\n' "$*" >&2
6 exit 1
7}
8KiB()
9{
10 printf %s $(("$1" * 1024))
11}
12MiB()
13{
14 KiB $(KiB "$1")
15}
16
17get_size()
18{
19 [ "$1" ] || return
20 if [ -b "$1" ]
21 then
22 blockdev --getsize64 "$1"
23 else
24 stat -c'%s' "$1"
25 fi
26}
27
28get_rootfs_size()
29{
30 rootfs_size=$(get_size "$ROOTFS")
31}
32
33initialize_target()
34{
35 if [ -b "$target" ]
36 then return
37 fi
38
39 rm -f "$target"
40 if [ "$ROOTFS" ]
41 then
42 get_rootfs_size
43 fallocate -l $(($(KiB 17) + $(MiB $end_keys) + rootfs_size + $(KiB 640))) "$target"
44 else
45 fallocate -l $(($(KiB 17) + $(MiB $end_keys))) "$target"
46 fi
47}
48
49# TODO: Use GUID type tags for each Samizdat partition type.
50partition_target()
51{
52 parted "$target" -sm -a optimal \
53 unit MiB \
54 mklabel gpt \
55 mkpart samizdat-efi 1 8 \
56 set 1 esp on \
57 mkpart samizdat-grub 8 64 \
58 set 2 bios_grub on \
59 mkpart samizdat-keys btrfs ${start_keys} ${end_keys}
60 if [ -b "$target" ]
61 then
62 partx -u "$target"
63 fi
64
65 if [ "$ROOTFS" ]
66 then
67 parted "$target" -sm -a optimal \
68 mkpart samizdat-rootfs btrfs ${end_keys}MiB 100%
69 fi
70}
71
72sex()
73{
74 (
75 set -x
76 "$@"
77 )
78}
79
80make_target_bootable()
81{
82 mkfs.btrfs -f --mixed "$part"3
83 mkdir -p "$mnt"
84 mount "$part"3 "$mnt"
85
86 mkdir -p "$mnt"/boot/grub
87 cp -avL "$GRUB_CONFIG" "$mnt"/boot/grub
88
89 mkdir -p "$mnt"/boot/efi
90 mkfs.vfat "$part"1
91 if [ "$USE_EFI" ]
92 then
93 efi_dir="$mnt".efi
94 mkdir -p "$efi_dir"
95 mount "$part"1 "$mnt".efi
96 mkdir "$efi_dir"/boot
97 boot_dir=$efi_dir/boot
98 else
99 boot_dir=$mnt/boot
100 fi
101
102 # https://wiki.archlinux.org/index.php/Multiboot_USB_drive#Hybrid_UEFI_GPT_+_BIOS_GPT/MBR_boot
103 # grub-install --target=x86_64-efi --removable --boot-directory=/mnt/boot --efi-directory=/mnt
104
105 GRUB_LOGFILE=$(mktemp) || exit
106 set -- eatmydata -- \
107 grub-install ${VERBOSE:+ -v} \
108 ${USE_EFI:+ --target=i386-efi} \
109 ${USE_EFI:+ --recheck} \
110 ${USE_EFI:+ --removable} \
111 ${USE_EFI:+ --efi-directory "$efi_dir"} \
112 --boot-directory "$boot_dir" \
113 "$dev"
114 echo "running: $* >$GRUB_LOGFILE 2>&1" >&2
115 if "$@" >"$GRUB_LOGFILE" 2>&1
116 then
117 fail=
118 else
119 fail=y
120 fi
121 if [ "$USE_EFI" ]
122 then
123 umount -l "$mnt"/boot/efi || :
124 fi
125 umount -l "$mnt" || :
126 if [ "$fail" ]
127 then
128 set -x
129 tail -n5 "$GRUB_LOGFILE"
130 exit 1
131 else
132 rm "$GRUB_LOGFILE"
133 fi
134 sync
135}
136
137copy_rootfs()
138{
139 if [ -z "$ROOTFS" ]
140 then
141 return
142 fi
143 [ -e "$ROOTFS" -a -b "$part"4 ]
144 get_rootfs_size
145 part_size=$(blockdev --getsize64 "$part"4)
146 [ "$rootfs_size" -le "$part_size" ] || die "rootfs_size=$rootfs_size > part_size=$part_size"
147
148 (
149 set -x
150 dd if="$ROOTFS" of="$part"4
151 # dd if=rootfs/samizdat.patch.seed.btrfs of="$part"5
152 )
153}
154
155acquire_target_block_devices()
156{
157 if [ -b "$target" ]
158 then
159 dev=$target
160 part=$target
161 mnt=/mnt/${target#/dev/}
162 partx -u "$target"
163 else
164 trap release_target_block_devices EXIT
165 losetup -f "$target"
166 dev=$(losetup -j "$target" -O NAME --noheadings)
167
168 btrfs device scan -u || :
169 kpartx -vasas "$dev"
170 btrfs device scan
171 part=/dev/mapper/${dev##*/}p
172
173 mnt=$target.mnt
174 fi
175}
176
177release_target_block_devices()
178{
179 (
180 set +e
181 [ -z "$mnt" ] || ! mountpoint -q "$mnt" || umount "$mnt"
182 case "$dev" in
183 /dev/loop*)
184 kpartx -d "$dev"
185 losetup -d "$dev"
186 ;;
187 esac
188 true
189 )
190 unset mnt dev
191}
192
193add_keys()
194{
195 rsync -a --info=STATS "$GPG_INPUT_DIR"/ "$mnt"/gnupghome/
196}
197
198add_initrd()
199{
200 initrd_suffix=.samizdat
201 mkdir -p "$mnt"/linux
202 rsync -aL --info=STATS "${1}vmlinuz${2}" "$mnt"/linux/vmlinuz
203 rsync -aL --info=STATS "${1}initrd.img${2}${2:+$initrd_suffix}" "$mnt"/linux/initrd.img
204}
205
206add_grub_cfg()
207{
208 mkdir -p "$mnt"/boot/grub
209 cp -aL "$GRUB_CONFIG" "$mnt"/boot/grub
210}
211
212individualize()
213{
214 mkdir -p "$mnt"
215 (
216 set +e
217 losetup -a >&2
218 lsblk >&2
219 mount|grep $PWD >&2
220 : OK
221 )
222 mountpoint "$mnt" || mount "$part"3 "$mnt"
223 add_keys
224 add_initrd "$samizdat_linux_dir"/ "${version_suffix}"
225 add_grub_cfg
226}
227
228globalize()
229{
230 initialize_target
231 partition_target
232 acquire_target_block_devices
233 make_target_bootable
234 copy_rootfs
235}
236
237sanity_checks()
238{
239 [[ $UID = 0 ]] || die "You are not root."
240 for d in "$samizdat_linux_dir" "$GPG_INPUT_DIR"
241 do
242 [ -d "$d" ] || die "Not a directory: $d"
243 done
244}
245
246find_mac()
247{
248 start_mac=$1
249 for mac in $(ip link show | grep link/ether | (read _ mac _; echo $mac | tr : -)); do
250 if [ "${mac%??}" = "${start_mac%??}" ]; then
251 prefix=${mac%??}
252 suffix=$(printf %x $(( 0x${mac##*-} + 1 )))
253 MAC=${prefix}${suffix}
254 return
255 fi
256 done
257 MAC=$start_mac
258}
259
260boot_vm()
261{
262 boot_drive=$1
263 installer_target=samizdat.disk.img
264
265 if [ ! -e "$installer_target" ]
266 then
267 fallocate -l 10G "$installer_target"
268 fi
269
270 find_mac 52-54-00-12-34-56
271 qemu-system-x86_64 \
272 -enable-kvm \
273 ${USE_EFI:+ -bios /usr/share/OVMF/OVMF_CODE.fd} \
274 -smp 2 \
275 -m 512 \
276 -k en-us \
277 -net nic,model=virtio,macaddr="$MAC" \
278 -net tap,ifname=tap0,script=no,downscript=no \
279 -curses \
280 -drive file="$boot_drive",format=raw \
281 -drive file="$installer_target",format=raw
282}
283
284do_build()
285{
286 if [ -b "$target" ]
287 then
288 globalize
289 individualize
290 release_target_block_devices
291 elif [ -f "$target" -o ! -e "$target" ]
292 then
293 template=${target%.img}.template.img
294 final=$target
295 (
296 target=$target.tmp
297 if [ ! -e "$template" ]
298 then
299 target="$template".tmp globalize
300 release_target_block_devices
301 mv -T "$template".tmp "$template"
302 fi
303
304 cp -T --reflink=always "$template" "$target"
305 acquire_target_block_devices
306 individualize
307 release_target_block_devices
308
309 mv -T "$target" "$final"
310 )
311 else
312 die "Target must be a file or block device."
313 fi
314}
315
316. samizdat-paths.sh || die 'samizdat-paths.sh not found'
317samizdat_linux_dir=/
318
319DEFAULT_ROOTFS=rootfs/samizdat.seed.btrfs
320#DEFAULT_PATCHFS=rootfs/samizdat.patch.btrfs
321
322if [ "$ROOTFS" = none ]
323then
324 ROOTFS=
325elif [ "$ROOTFS" ]
326then
327 [ -f "$ROOTFS" ] || die "Not a file: $ROOTFS"
328elif [ -f "$DEFAULT_ROOTFS" ]
329then
330 ROOTFS=$DEFAULT_ROOTFS
331fi
332
333if [ ! "$GPG_INPUT_DIR" ]
334then
335 for d in $GPG_INPUT_DIR /root/.gnupg /cdrom/gnupghome
336 do
337 [ -d "$d" ] || continue
338 GPG_INPUT_DIR=$d
339 break
340 done
341fi
342
343: ${GRUB_CONFIG:=conf/grub.cfg}
344start_keys=64 # megs
345end_keys=256 # megs
346
347if [ "$KERNEL_VERSION" ]
348then
349 version_suffix=-$KERNEL_VERSION
350fi
351
352sanity_checks
353set -e
354
355if [ "$1" = -n ]
356then
357 shift
358 DO_BUILD=
359else
360 DO_BUILD=y
361fi
362
363default_target=boot-disk.img
364
365USB=$(which usb || echo ./src/usb)
366
367if [ "$1" ]
368then
369 if [ "$1" = USB ]
370 then
371 [ "$DO_BUILD" ] && arg= || arg=-n
372 target=$($USB $arg) || exit 1
373 elif [ -f "$1" ]
374 then
375 case "$1" in
376 *.img) ;;
377 *) die "Invalid image filename. Use *.img";;
378 esac
379 target=$1
380 fi
381else
382 target=$default_target
383fi
384
385if [ "$DO_BUILD" ]
386then
387 do_build
388fi
389boot_vm "$target"
diff --git a/src/publish-ip.sh b/src/publish-ip.sh
deleted file mode 100755
index 37fd2e3..0000000
--- a/src/publish-ip.sh
+++ /dev/null
@@ -1,53 +0,0 @@
1#!/bin/sh
2
3kiki_hostkey=/var/cache/kiki/config/ssh_host_rsa_key
4debian_hostkey=/etc/ssh/ssh_host_rsa_key
5
6determine_lan_ip()
7{
8 ip -4 -oneline addr show |
9 while read n dev _ ip rest; do
10 case "$rest" in
11 *'scope global'*) ;;
12 *) continue ;;
13 esac
14 # Exclude our IP address on br0 -- hosts connected via this device should
15 # be receiving DNS servers from us via DHCP, so dyndns is unnecessary.
16 # However, perhaps we could install a third entry in the dyndns. (Perhaps
17 # something like *.br0.ssh.cryptonomic.net would give us automatic names
18 # for all devices.)
19 case "$dev" in
20 br0) continue ;;
21 esac
22 echo ${ip%/*}
23 break
24 done
25}
26
27ssh_cryptonomic_net__known_hosts()
28{
29cat <<'END'
30|1|ORqVRkqd0LO25vHCB0LezHAgwRE=|ih7EYLpvg9jpU86/0Od0N8Ur36c= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBHkIETz7wmKd7TZgb3NPeUElZDjZqw2VPd8yDOBTj5UzUBmcgCyE1oCS3Oe1iO9zJWpPtG0QyYa29lKi+vN6pN4=
31END
32}
33
34tmpfile=$(mktemp) || exit 1
35trap 'rm -f "$tmpfile"' EXIT
36ssh_cryptonomic_net__known_hosts > "$tmpfile"
37
38lan_ip=$(determine_lan_ip)
39
40if [ "$lan_ip" ]; then
41 set -- lan "$lan_ip"
42else
43 set --
44fi
45
46hostkey=
47for f in "$kiki_hostkey" "$debian_hostkey"; do
48 [ -r "$f" ] || continue
49 hostkey=$f
50 break
51done
52
53ssh -o GlobalKnownHostsFile="$tmpfile" ${hostkey:+ -i "$hostkey"} dyndns@ssh.cryptonomic.net "$@"
diff --git a/src/qemu.sh b/src/qemu.sh
deleted file mode 100755
index 0300c71..0000000
--- a/src/qemu.sh
+++ /dev/null
@@ -1,129 +0,0 @@
1#!/bin/sh
2
3. samizdat-paths.sh
4
5case "$(id -u)" in
6 0) sudo= ;;
7 *) sudo=sudo ;;
8esac
9
10iso=${samizdat_iso_dir}/samizdat.iso
11disk=${samizdat_iso_dir}/samizdat.disk.img
12layered=${samizdat_iso_dir}/${iso%.iso}.layered.iso
13
14[ -f "$layered" ] && iso=$layered
15
16[ "$1" ] && iso=$1
17
18[ "$NO_NET" ] || USE_NET=y
19
20NET='tap,ifname=tap0,script=no,downscript=no'
21
22[ "$SLOW_BOOT" ] || QEMU_LOADS_LINUX=y
23
24# To use qemu built-in pxe boot server:
25# NET='user,tftp=isolinux,bootfile=/pxelinux.0'
26
27nbd_filename=samizdat.btrfs
28[ "$NBD_FILENAME" ] && nbd_filename=$NBD_FILENAME
29
30initrd=${samizdat_isolinux_dir}/linux/initrd.img
31kernel=${samizdat_isolinux_dir}/linux/vmlinuz
32kcmdline_CDROM='boot=samizdat components quiet'
33kcmdline_CDROM_NET="${kcmdline_CDROM} nbdroot=,${nbd_filename}, nbddev=/dev/nbd0 ip=dhcp"
34kcmdline_NET="${kcmdline_CDROM_NET} netkeys"
35
36find_mac()
37{
38 start_mac=$1
39 for mac in $(ip link show | grep link/ether | (read _ mac _; echo $mac | tr : -)); do
40 if [ "${mac%??}" = "${start_mac%??}" ]; then
41 prefix=${mac%??}
42 suffix=$(printf %x $(( 0x${mac##*-} + 1 )))
43 MAC=${prefix}${suffix}
44 return
45 fi
46 done
47 MAC=$start_mac
48}
49find_mac 52-54-00-12-34-56
50
51kcmdline_BOOTIF="BOOTIF=01-$MAC"
52
53set --
54if [ "$USE_ISO" ]; then
55 set -- "$@" -cdrom "$iso"
56 if [ "$QEMU_LOADS_LINUX" ]; then
57 set -- "$@" -initrd "$initrd" -kernel "$kernel"
58 if [ "$NO_NET" ]; then
59 set -- "$@" -append "$kcmdline_CDROM"
60 else
61 set -- "$@" -append "$kcmdline_CDROM_NET"
62 fi
63 else
64 set -- "$@" -boot d
65 fi
66else
67 if [ "$QEMU_LOADS_LINUX" ]; then
68 set -- "$@" -initrd "$initrd" -kernel "$kernel" -append "$kcmdline_NET $kcmdline_BOOTIF"
69 else
70 set -- "$@" -boot n
71 fi
72fi
73
74case $(arch) in
75 x86_64) qemu=qemu-system-x86_64 ;;
76 *) qemu=qemu-system-i386 ;;
77esac
78
79try_fallocate()
80{
81 for size in "$@"; do
82 fallocate -l "$size" "$disk"~tmp || continue
83 mv "$disk"~tmp "$disk"
84 return
85 done
86 false
87}
88
89if [ ! -e "$disk" ]; then
90 try_fallocate 16GB 8GB 4GB 2GB 1GB ||
91 echo "Warning: no virtual disk (could not create $disk)" >&2
92fi
93
94if grep -q '^flags.*\<vmx\>' /proc/cpuinfo; then
95 kvm='-enable-kvm -cpu host'
96 read nested < /sys/module/kvm_intel/parameters/nested
97 if [ "$nested" != Y ]; then
98 printf '%s\n' \
99 'Warning: nested KVM is not available' \
100 'Try "make install-nested-kvm"'
101 fi
102else
103 >&2 printf '%s\n' \
104 '' \
105 'Warning: kernel virtual machine extensions (KVM) not available.' \
106 'The VM will be intolerably slow.' \
107 'If your hardware supports KVM, you need to enable it in the BIOS.' \
108 '' \
109 'If you are trying to run qemu in a virtual machine, you need to append' \
110 'the kvm-(intel|amd) module parameter "nested=1" on the _host_ machine.' \
111 'Use "make install-nested-kvm" to do so.' \
112 ''
113 kvm=
114fi
115
116mem_total=$(grep MemTotal /proc/meminfo | (read _ kb _; echo $((kb / 1024))))
117use_mem=640
118if [ "$mem_total" -le $((use_mem * 2)) ]; then
119 use_mem=$((mem_total / 2))
120fi
121
122set -x
123$sudo ${qemu} ${kvm} -smp 2 -m ${use_mem} -k en-us \
124 -vga qxl \
125 -net nic,model=virtio,macaddr=$MAC \
126 ${USE_NET:+ -net "$NET"} \
127 -rtc base=localtime \
128 -drive index=0,media=disk,format=raw,file="$disk" \
129 "$@"
diff --git a/src/store-child-permanently b/src/store-child-permanently
deleted file mode 100755
index 82e79d8..0000000
--- a/src/store-child-permanently
+++ /dev/null
@@ -1,47 +0,0 @@
1#!/bin/sh
2
3. samizdat-paths.sh
4
5error()
6{
7 printf 'Error: %s\n' "${*:-command failed}" >&2
8 exit 1
9}
10
11warning()
12{
13 printf 'Warning: %s\n' "${*:-something went wrong}" >&2
14}
15
16store_tmpfs()
17{
18 local dir="$1"
19 mountpoint -q "$dir" || return 0
20 [ ! -d "$dir".backup ] || error "existing child backup found: '$dir.backup'. Refusing to continue."
21 cp -a "$dir" "$dir".backup || error "failed to make copy of child."
22 umount "$dir" || error "failed to unmount child tmpfs"
23 rmdir "$dir" || mv -Tb "$dir" "$dir".unlikely
24 mv -T "$dir".backup "$dir" || error "failed to move copied child dir into place. Child will not function!"
25}
26
27assert_root()
28{
29 [ "$(id -u)" = 0 ] || error "you are not root"
30}
31
32main()
33{
34 assert_root
35 child=$1
36 [ "$child" ] || usage
37 if [ -d "$samizdat_child_dir"/child."$child" ]; then
38 store_tmpfs "$samizdat_child_dir"/child."$child"
39 else
40 error "not a directory: $samizdat_child_dir/child.$child"
41 fi
42}
43
44case $# in
45 0) read child < reused-child && main "$child" ;;
46 *) main "$@" ;;
47esac
diff --git a/src/xorriso-usb.sh b/src/xorriso-usb.sh
deleted file mode 100755
index 436c8fe..0000000
--- a/src/xorriso-usb.sh
+++ /dev/null
@@ -1,295 +0,0 @@
1#!/bin/bash
2
3die() { printf "%s: Error: %s\n" "$0" "$*" >&2; exit 1; }
4
5whole_device()
6{
7 case "$1" in
8 *-part?) false ;;
9 *-part??) false ;;
10 *-part???) false ;;
11 */usb\*) false ;;
12 *) true ;;
13 esac
14}
15
16confirm_usb()
17{
18 local msg="This will completely overwrite device:\n\n\t%s\n\nType 'yes' to confirm.\nContinue? "
19 printf "$msg" "$1" >&2
20 read line
21 case "$line" in
22 [yY][eE][sS]) return ;;
23 *) die "Aborted by user." ;;
24 esac
25}
26
27choose_usb()
28{
29 local devs maj
30 set -- /dev/disk/by-id/usb*
31 for dev; do
32 shift
33 whole_device "$dev" || continue
34 set -- "$@" "$dev"
35 done
36 if [ $# = 0 ]; then
37 die "no usb device found"
38 elif [ $# = 1 ]; then
39 confirm_usb "$1" || die impossible
40 outdev="$1"
41 else
42 die "multiple USB devices connected and choice between them is unimplemented. ($*)"
43 fi
44}
45
46choose_cdrom()
47{
48 die 'choose_cdrom: unimplemented; specify cdrom device with --out'
49}
50
51choose_outdev()
52{
53 if [ "$CMDLINE_OUTDEV" ]; then
54 outdev=$CMDLINE_OUTDEV~
55 NEED_STDIO=y
56 elif [ "$USB" ]; then
57 choose_usb
58 NEED_STDIO=y
59 else
60 choose_cdrom
61 NEED_STDIO=
62 fi
63}
64
65generate_keys()
66{
67 if [ "$ADAM" -o "$BOOTLOADER_ONLY" ]; then
68 kiki init || die 'kiki init failed'
69 GPG_INPUT_DIR=/root/.gnupg
70 else
71 keygen.sh "$child_dir" || die "keygen.sh failed"
72 GPG_INPUT_DIR=$child_dir/root/.gnupg
73 trap 'umount "$child_dir"; rmdir "$child_dir"' EXIT
74 fi
75}
76
77try_mount()
78{
79 # TODO: don't use /mnt
80 # Ofc the real solution is to get help with xorriso.
81 NEED_UNMOUNT="$1"
82 mount -r "$1" /mnt && trap 'umount -l /mnt' EXIT
83}
84
85verbosely()
86{
87 (set -x; "$@")
88}
89
90xorriso_cmd()
91{
92 # input variables:
93
94 ## that do not affect the output ISO image:
95
96 # SHOW_XORRISO_CMD
97 # SILENT
98 # NEED_STDIO
99
100 ## that do not vary by invocation:
101
102 # volid
103 # vmlinuz_dir
104 # efi_dir
105 # gpg_iso_path
106
107 ## that specify sources of input:
108
109 # INPUT_DEVICE
110 # GPG_INPUT_DIR
111 # $@ (btrfs filesystems)
112 # EXTRA_INPUT_DIRS
113
114 ## boolean flags
115
116 # REMOVE_BTRFS
117 # ADD_BTRFS
118
119 ${SHOW_XORRISO_CMD:+ verbosely} ${NO_ACT:+ :} \
120 xorrisofs -iso-level 3 -- \
121 ${INPUT_DEVICE:+ -indev "$INPUT_DEVICE" } \
122 -outdev ${NEED_STDIO:+stdio:}"$outdev" \
123 -blank as_needed \
124 ${SILENT:+ -report_about mishap} \
125 -return_with sorry 0 \
126 -volid "$volid" \
127 -pathspecs on \
128 \
129 \
130 ${EXTRA_INPUT_DIRS} \
131 \
132 \
133 -rm_r linux -- -add linux="${vmlinuz_dir}" -- \
134 ${REMOVE_BTRFS:+ -rm_r rootfs -- } \
135 ${ADD_BTRFS:+ -follow link -add "$@" -- -follow default } \
136 \
137 \
138 -rm_r "${gpg_iso_path}" -- \
139 -add "${gpg_iso_path}=${GPG_INPUT_DIR}" -- \
140 \
141 \
142 -chown_r 0 / -- \
143 -chgrp_r 0 / -- \
144 -chmod_r go-rwx "${gpg_iso_path}" -- \
145 \
146 \
147 -as mkisofs -graft-points \
148 -b grub/i386-pc/eltorito.img \
149 -no-emul-boot -boot-info-table \
150 --embedded-boot "${efi_dir}"/embedded.img \
151 --protective-msdos-label \
152 grub="${efi_dir}"/grub
153}
154
155run_xorriso()
156{
157 xorriso_cmd "$@" || die "xorriso exited $?"
158
159 case "$outdev" in
160 *~) [ -f "$outdev" ] && mv "$outdev" "${outdev%\~}" ;;
161 esac
162
163 if [ "$USB" -a "$DETACH" -a $? = 0 ]; then
164 udisks --detach "$outdev"
165 fi
166}
167
168find_child()
169{
170 # TODO: Lookup by IP address, MAC address
171 printf '%s' "$samizdat_child_dir"/child."$1"
172}
173
174. samizdat-paths.sh || die 'samizdat-path.sh not found'
175
176if [ -f xorriso-usb.config ]; then
177 . xorriso-usb.config
178fi
179
180volid=SamizdatLive
181vmlinuz_dir=$samizdat_linux_dir
182efi_dir=$samizdat_grub_efi_dir
183gpg_iso_path=gnupghome
184
185
186outdev=
187GPG_INPUT_DIR=
188child_dir=$samizdat_child_dir/child.$$
189
190OPT=$(getopt -o '' --long 'bootloader,reuse-child:,adam,usb,detach,in:,out:,test' -n "$0" -- "$@") || die 'getopt error'
191eval set -- "$OPT"
192unset OPT
193
194ADAM=; DETACH=; USB=y
195while [ $# -gt 0 ]; do
196 case "$1" in
197 --) shift; break;;
198 --adam) shift; ADAM=y;;
199 --bootloader) shift; export BOOTLOADER_ONLY=y;;
200 --cdrom) shift; USB=;;
201 --detach) shift; DETACH=y;;
202 --in) INPUT_DEVICE="$2"; shift 2;;
203 --out) CMDLINE_OUTDEV="$2"; USB=; shift 2;;
204 --reuse-child) REUSE_CHILD=y; child_dir="$(find_child "$2")"; shift 2;;
205 --test) shift; QUICK_TEST=y;;
206 *) die 'getopt error';;
207 esac
208done
209
210if [ "$INPUT_DEVICE" ]; then
211 die "support for --in is disabled because xorriso needs different arguments to produce a bootable image"
212
213elif [ $# = 0 -a -z "$BOOTLOADER_ONLY" ]; then
214 if mountpoint -q /cdrom; then
215 INPUT_DEVICE=/cdrom
216 elif [ -e /srv/nbd.btrfs ]; then
217 set -- /srv/nbd.btrfs
218 elif [ "$(blockdev --getsz /dev/nbd0)" -gt 0 ]; then
219 (set -x; dd if=/dev/nbd0 of=/srv/nbd.btrfs~ && mv /srv/nbd.btrfs~ /srv/nbd.btrfs) || die "failed to copy network block device"
220 set -- /srv/nbd.btrfs
221 else
222 die "no input device and no input btrfs layers: aborting."
223 fi
224fi
225
226for fs; do
227 [ -f "$fs" ] || die "not a file: $fs"
228 case "$fs" in
229 *.btrfs) ;;
230 *) die "invalid name (does not match *.btrfs): $fs" ;;
231 esac
232 shift
233 set -- "$@" "rootfs/${fs##*/}=$fs"
234done
235
236
237[ "$(id -u)" = 0 ] || die "you are not root."
238
239grub-efi.sh || die "grub-efi.sh failed"
240
241choose_outdev
242
243if [ "$REUSE_CHILD" ]; then
244 GPG_INPUT_DIR=$child_dir/root/.gnupg
245 [ -d "$GPG_INPUT_DIR" ] || die "invalid child"
246else
247 generate_keys
248fi
249
250if [ "$INPUT_DEVICE" ]; then
251 if [ "$INPUT_DEVICE" = /dev/md55 ]; then
252 if mountpoint -q /cdrom; then
253 EXTRA_INPUT_DIRS='-add /=/cdrom --'
254 fi
255 elif [ -d "$INPUT_DEVICE" ]; then
256 EXTRA_INPUT_DIRS="-add /=$INPUT_DEVICE --" # TODO: escape
257 elif try_mount "$INPUT_DEVICE"; then
258 EXTRA_INPUT_DIRS='-add /=/mnt --'
259 else
260 REPLACE_INITRD=
261 REMOVE_BTRFS=
262 ADD_BTRFS=
263 fi
264elif [ "$BOOTLOADER_ONLY" ]; then
265 REPLACE_INITRD=
266 REMOVE_BTRFS=
267 ADD_BTRFS=
268else
269 REPLACE_INITRD=y
270 REMOVE_BTRFS=y
271 ADD_BTRFS=y
272fi
273REPLACE_INITRD= # TODO: fix initrd replacing
274
275if [ "$QUICK_TEST" ]; then
276 REMOVE_BTRFS=y
277 ADD_BTRFS=
278fi
279
280if [ "$REPLACE_INITRD" ]; then
281 # TODO: fix the paths so this backup isn't needed. What we need to do is
282 # support tftp pointing to the cdrom. This probably means a tftp directory
283 # that contains a symlink to /cdrom/linux which gets updated on success here
284 mv "${vmlinuz_dir}" "${vmlinuz_dir}".bak
285 mkdir "${vmlinuz_dir}"
286 initrd.sh || {
287 mv "${vmlinuz_dir}.bak" "${vmlinuz_dir}"
288 die 'initrd.sh failed'
289 }
290fi
291
292SILENT=
293SHOW_XORRISO_CMD=y
294
295run_xorriso "$@"
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-07 09:24:41 +0000