diff options
-rw-r--r-- | Makefile | 25 | ||||
-rwxr-xr-x | src/grub-efi.sh | 65 | ||||
-rwxr-xr-x | src/initrd.sh | 59 | ||||
-rwxr-xr-x | src/mkinitramfs-samizdat | 85 | ||||
-rwxr-xr-x | src/parted-usb.sh | 389 | ||||
-rwxr-xr-x | src/publish-ip.sh | 53 | ||||
-rwxr-xr-x | src/qemu.sh | 129 | ||||
-rwxr-xr-x | src/store-child-permanently | 47 | ||||
-rwxr-xr-x | src/xorriso-usb.sh | 295 |
9 files changed, 4 insertions, 1143 deletions
@@ -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 | ||
40 | dyndns_realprog = dyndns.ssh-rsa.cryptonomic.net | 40 | src_bin_programs = btrfs-functions.sh var.sh dnsmasq-dhcp-script.sh usb partvi |
41 | dyndns_links = dyndns.ssh-dss.cryptonomic.net \ | ||
42 | dyndns.ecdsa-sha2-nistp256.cryptonomic.net dyndns.ssh-ed25519.cryptonomic.net | ||
43 | dyndns_progs = $(dyndns_realprog) $(dyndns_links) | ||
44 | |||
45 | $(addprefix src/, $(dyndns_links)): | ||
46 | ln -s $(dyndns_realprog) $@ | ||
47 | |||
48 | src_bin_programs = xorriso-usb.sh btrfs-functions.sh btrfs-receive-root.sh \ | ||
49 | btrfs-send-root.sh var.sh grub-efi.sh keygen.sh initrd.sh qemu.sh \ | ||
50 | dnsmasq-dhcp-script.sh publish-ip.sh \ | ||
51 | git-ll-remote usb \ | ||
52 | hostname.cryptonomic.net partvi ficlonerange.py ${dyndns_progs} | ||
53 | 41 | ||
54 | bin_programs=$(addprefix src/, $(src_bin_programs)) samizdat-paths.sh ${cc_files} ${btrfs_utils} | 42 | bin_programs=$(addprefix src/, $(src_bin_programs)) samizdat-paths.sh ${cc_files} ${btrfs_utils} |
55 | 43 | ||
56 | dyndns_programs = cryptonomic-dyndns-command samizdat-ssh-command samizdat-ssh-uid | ||
57 | dyndns_program_paths=$(addprefix cryptonomic-dyndns-server/bin/, $(dyndns_programs)) | ||
58 | |||
59 | bin_programs += $(dyndns_program_paths) | ||
60 | |||
61 | btrfs_utils=$(addprefix src/btrfs-utils/, btarfs with-btrfs-seed) | 44 | btrfs_utils=$(addprefix src/btrfs-utils/, btarfs with-btrfs-seed) |
62 | 45 | ||
63 | initrd_files:=$(wildcard src/initrd/*) dynmenu samizdat-pinentry wait_for_files | 46 | initrd_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 | ||
165 | boot: rootfs | 148 | boot: 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 | ||
169 | fastboot: rootfs | 152 | fastboot: rootfs |
@@ -265,13 +248,13 @@ bootclean: | |||
265 | .PHONY: update upgrade up upgrade-key initrd | 248 | .PHONY: update upgrade up upgrade-key initrd |
266 | 249 | ||
267 | initrd: install | 250 | initrd: install |
268 | ./src/mkinitramfs-samizdat | 251 | sudo update-initramfs -u |
269 | 252 | ||
270 | update: apt-get-update-stamp | 253 | update: apt-get-update-stamp |
271 | git pull --ff-only --recurse-submodules | 254 | git pull --ff-only --recurse-submodules |
272 | 255 | ||
273 | upgrade: install-submodules install | 256 | upgrade: install-submodules install |
274 | ./src/mkinitramfs-samizdat -f | 257 | sudo update-initramfs -u |
275 | 258 | ||
276 | upgrade-key: upgrade key | 259 | upgrade-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 | |||
4 | if [ "$BOOTLOADER_ONLY" ] | ||
5 | then | ||
6 | linux_kernel_commandline='boot=samizdat components quiet nbdroot=192.168.10.1/samizdat.btrfs nbddev=/dev/nbd0 ip=dhcp' | ||
7 | else | ||
8 | linux_kernel_commandline='boot=samizdat components quiet' | ||
9 | fi | ||
10 | |||
11 | grub_config() | ||
12 | { | ||
13 | cat <<EOF | ||
14 | insmod echo | ||
15 | echo GRUB (samizdat) | ||
16 | |||
17 | insmod normal | ||
18 | insmod keystatus | ||
19 | |||
20 | insmod linux | ||
21 | insmod iso9660 | ||
22 | |||
23 | insmod part_acorn | ||
24 | insmod part_amiga | ||
25 | insmod part_apple | ||
26 | insmod part_bsd | ||
27 | insmod part_dvh | ||
28 | insmod part_gpt | ||
29 | insmod part_msdos | ||
30 | insmod part_plan | ||
31 | insmod part_sun | ||
32 | insmod part_sunpc | ||
33 | |||
34 | echo Loading vmlinuz... | ||
35 | |||
36 | linux /linux/vmlinuz ${linux_kernel_commandline} | ||
37 | |||
38 | echo Loading initrd.img... | ||
39 | initrd /linux/initrd.img | ||
40 | |||
41 | echo Booting. | ||
42 | echo | ||
43 | boot | ||
44 | |||
45 | EOF | ||
46 | } | ||
47 | |||
48 | real_destdir=$samizdat_grub_efi_dir | ||
49 | [ "$real_destdir" ] || exit 1 | ||
50 | destdir=$real_destdir.tmp | ||
51 | |||
52 | set -e | ||
53 | rm -r "${destdir}" 2>/dev/null || true | ||
54 | mkdir -p "${destdir}"/grub/i386-pc/ | ||
55 | cp -r /usr/lib/grub/i386-pc/* "${destdir}"/grub/i386-pc/ | ||
56 | rm "${destdir}"/grub/i386-pc/*.img || true | ||
57 | |||
58 | grub_config > "${destdir}"/load_cfg | ||
59 | |||
60 | grub-mkimage -O i386-pc -d /usr/lib/grub/i386-pc/ -o "${destdir}"/core.img -c "${destdir}"/load_cfg --prefix=/grub iso9660 biosdisk | ||
61 | cat /usr/lib/grub/i386-pc/cdboot.img "${destdir}"/core.img > "${destdir}"/grub/i386-pc/eltorito.img | ||
62 | cat /usr/lib/grub/i386-pc/boot.img "${destdir}"/core.img > "${destdir}"/embedded.img | ||
63 | |||
64 | rm -r "$real_destdir" 2>/dev/null || true | ||
65 | mv -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 | |||
5 | if [ -d "$1" ] | ||
6 | then | ||
7 | samizdat_linux_dir=$1 | ||
8 | fi | ||
9 | |||
10 | initrd=${samizdat_linux_dir}/initrd.img | ||
11 | vmlinuz=${samizdat_linux_dir}/vmlinuz | ||
12 | |||
13 | conf_dir=$samizdat_initramfs_conf_dir | ||
14 | |||
15 | get_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 | |||
24 | pkgs_file=rootfs/_build/${rootfs:-samizdat}.pkgs.txt | ||
25 | |||
26 | [ -f "$pkgs_file" ] || exit | ||
27 | |||
28 | kernel_version=$(get_kernel_version rootfs/_build/${rootfs:-samizdat}.pkgs.txt) | ||
29 | |||
30 | [ "$kernel_version" ] || exit | ||
31 | |||
32 | debian_initrd=/boot/initrd.img-${kernel_version} | ||
33 | |||
34 | find_deps() { | ||
35 | find "$conf_dir" "$samizdat_initrd_files_dir" "$debian_initrd" "$@" | ||
36 | } | ||
37 | |||
38 | force_rebuild() | ||
39 | { | ||
40 | touch "$conf_dir" | ||
41 | return 1 | ||
42 | } | ||
43 | |||
44 | rebuild() | ||
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 | |||
51 | if [ ! -e "$initrd" -o ! -e "$vmlinuz" ]; then | ||
52 | rebuild | ||
53 | else | ||
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 | ||
59 | fi | ||
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 | ||
2 | if [ "$(id -u)" != 0 ] | ||
3 | then | ||
4 | exec sudo -- "$0" "$@" | ||
5 | exit 1 | ||
6 | fi | ||
7 | |||
8 | loudly() | ||
9 | { | ||
10 | (set -x | ||
11 | "$@") | ||
12 | } | ||
13 | |||
14 | deb_arch() | ||
15 | { | ||
16 | dpkg-architecture -q DEB_HOST_ARCH | ||
17 | } | ||
18 | |||
19 | up_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 | |||
30 | build_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 | |||
47 | OUTPUT_TAG= | ||
48 | FORCE_BUILD= | ||
49 | while [ $# -gt 0 ] | ||
50 | do | ||
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 | ||
59 | done | ||
60 | |||
61 | if [ "$1" ] | ||
62 | then | ||
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 | ||
71 | elif [ -L /vmlinuz ] | ||
72 | then | ||
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 | ||
82 | else | ||
83 | printf 'Error: Could not determine kernel version. Create /vmlinuz or specify a version.' >&2 | ||
84 | exit 1 | ||
85 | fi | ||
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 | ||
2 | USE_EFI= | ||
3 | die() | ||
4 | { | ||
5 | printf 'Error: %s\n' "$*" >&2 | ||
6 | exit 1 | ||
7 | } | ||
8 | KiB() | ||
9 | { | ||
10 | printf %s $(("$1" * 1024)) | ||
11 | } | ||
12 | MiB() | ||
13 | { | ||
14 | KiB $(KiB "$1") | ||
15 | } | ||
16 | |||
17 | get_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 | |||
28 | get_rootfs_size() | ||
29 | { | ||
30 | rootfs_size=$(get_size "$ROOTFS") | ||
31 | } | ||
32 | |||
33 | initialize_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. | ||
50 | partition_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 | |||
72 | sex() | ||
73 | { | ||
74 | ( | ||
75 | set -x | ||
76 | "$@" | ||
77 | ) | ||
78 | } | ||
79 | |||
80 | make_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 | |||
137 | copy_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 | |||
155 | acquire_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 | |||
177 | release_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 | |||
193 | add_keys() | ||
194 | { | ||
195 | rsync -a --info=STATS "$GPG_INPUT_DIR"/ "$mnt"/gnupghome/ | ||
196 | } | ||
197 | |||
198 | add_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 | |||
206 | add_grub_cfg() | ||
207 | { | ||
208 | mkdir -p "$mnt"/boot/grub | ||
209 | cp -aL "$GRUB_CONFIG" "$mnt"/boot/grub | ||
210 | } | ||
211 | |||
212 | individualize() | ||
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 | |||
228 | globalize() | ||
229 | { | ||
230 | initialize_target | ||
231 | partition_target | ||
232 | acquire_target_block_devices | ||
233 | make_target_bootable | ||
234 | copy_rootfs | ||
235 | } | ||
236 | |||
237 | sanity_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 | |||
246 | find_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 | |||
260 | boot_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 | |||
284 | do_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' | ||
317 | samizdat_linux_dir=/ | ||
318 | |||
319 | DEFAULT_ROOTFS=rootfs/samizdat.seed.btrfs | ||
320 | #DEFAULT_PATCHFS=rootfs/samizdat.patch.btrfs | ||
321 | |||
322 | if [ "$ROOTFS" = none ] | ||
323 | then | ||
324 | ROOTFS= | ||
325 | elif [ "$ROOTFS" ] | ||
326 | then | ||
327 | [ -f "$ROOTFS" ] || die "Not a file: $ROOTFS" | ||
328 | elif [ -f "$DEFAULT_ROOTFS" ] | ||
329 | then | ||
330 | ROOTFS=$DEFAULT_ROOTFS | ||
331 | fi | ||
332 | |||
333 | if [ ! "$GPG_INPUT_DIR" ] | ||
334 | then | ||
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 | ||
341 | fi | ||
342 | |||
343 | : ${GRUB_CONFIG:=conf/grub.cfg} | ||
344 | start_keys=64 # megs | ||
345 | end_keys=256 # megs | ||
346 | |||
347 | if [ "$KERNEL_VERSION" ] | ||
348 | then | ||
349 | version_suffix=-$KERNEL_VERSION | ||
350 | fi | ||
351 | |||
352 | sanity_checks | ||
353 | set -e | ||
354 | |||
355 | if [ "$1" = -n ] | ||
356 | then | ||
357 | shift | ||
358 | DO_BUILD= | ||
359 | else | ||
360 | DO_BUILD=y | ||
361 | fi | ||
362 | |||
363 | default_target=boot-disk.img | ||
364 | |||
365 | USB=$(which usb || echo ./src/usb) | ||
366 | |||
367 | if [ "$1" ] | ||
368 | then | ||
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 | ||
381 | else | ||
382 | target=$default_target | ||
383 | fi | ||
384 | |||
385 | if [ "$DO_BUILD" ] | ||
386 | then | ||
387 | do_build | ||
388 | fi | ||
389 | boot_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 | |||
3 | kiki_hostkey=/var/cache/kiki/config/ssh_host_rsa_key | ||
4 | debian_hostkey=/etc/ssh/ssh_host_rsa_key | ||
5 | |||
6 | determine_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 | |||
27 | ssh_cryptonomic_net__known_hosts() | ||
28 | { | ||
29 | cat <<'END' | ||
30 | |1|ORqVRkqd0LO25vHCB0LezHAgwRE=|ih7EYLpvg9jpU86/0Od0N8Ur36c= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBHkIETz7wmKd7TZgb3NPeUElZDjZqw2VPd8yDOBTj5UzUBmcgCyE1oCS3Oe1iO9zJWpPtG0QyYa29lKi+vN6pN4= | ||
31 | END | ||
32 | } | ||
33 | |||
34 | tmpfile=$(mktemp) || exit 1 | ||
35 | trap 'rm -f "$tmpfile"' EXIT | ||
36 | ssh_cryptonomic_net__known_hosts > "$tmpfile" | ||
37 | |||
38 | lan_ip=$(determine_lan_ip) | ||
39 | |||
40 | if [ "$lan_ip" ]; then | ||
41 | set -- lan "$lan_ip" | ||
42 | else | ||
43 | set -- | ||
44 | fi | ||
45 | |||
46 | hostkey= | ||
47 | for f in "$kiki_hostkey" "$debian_hostkey"; do | ||
48 | [ -r "$f" ] || continue | ||
49 | hostkey=$f | ||
50 | break | ||
51 | done | ||
52 | |||
53 | ssh -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 | |||
5 | case "$(id -u)" in | ||
6 | 0) sudo= ;; | ||
7 | *) sudo=sudo ;; | ||
8 | esac | ||
9 | |||
10 | iso=${samizdat_iso_dir}/samizdat.iso | ||
11 | disk=${samizdat_iso_dir}/samizdat.disk.img | ||
12 | layered=${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 | |||
20 | NET='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 | |||
27 | nbd_filename=samizdat.btrfs | ||
28 | [ "$NBD_FILENAME" ] && nbd_filename=$NBD_FILENAME | ||
29 | |||
30 | initrd=${samizdat_isolinux_dir}/linux/initrd.img | ||
31 | kernel=${samizdat_isolinux_dir}/linux/vmlinuz | ||
32 | kcmdline_CDROM='boot=samizdat components quiet' | ||
33 | kcmdline_CDROM_NET="${kcmdline_CDROM} nbdroot=,${nbd_filename}, nbddev=/dev/nbd0 ip=dhcp" | ||
34 | kcmdline_NET="${kcmdline_CDROM_NET} netkeys" | ||
35 | |||
36 | find_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 | } | ||
49 | find_mac 52-54-00-12-34-56 | ||
50 | |||
51 | kcmdline_BOOTIF="BOOTIF=01-$MAC" | ||
52 | |||
53 | set -- | ||
54 | if [ "$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 | ||
66 | else | ||
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 | ||
72 | fi | ||
73 | |||
74 | case $(arch) in | ||
75 | x86_64) qemu=qemu-system-x86_64 ;; | ||
76 | *) qemu=qemu-system-i386 ;; | ||
77 | esac | ||
78 | |||
79 | try_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 | |||
89 | if [ ! -e "$disk" ]; then | ||
90 | try_fallocate 16GB 8GB 4GB 2GB 1GB || | ||
91 | echo "Warning: no virtual disk (could not create $disk)" >&2 | ||
92 | fi | ||
93 | |||
94 | if 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 | ||
102 | else | ||
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= | ||
114 | fi | ||
115 | |||
116 | mem_total=$(grep MemTotal /proc/meminfo | (read _ kb _; echo $((kb / 1024)))) | ||
117 | use_mem=640 | ||
118 | if [ "$mem_total" -le $((use_mem * 2)) ]; then | ||
119 | use_mem=$((mem_total / 2)) | ||
120 | fi | ||
121 | |||
122 | set -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 | |||
5 | error() | ||
6 | { | ||
7 | printf 'Error: %s\n' "${*:-command failed}" >&2 | ||
8 | exit 1 | ||
9 | } | ||
10 | |||
11 | warning() | ||
12 | { | ||
13 | printf 'Warning: %s\n' "${*:-something went wrong}" >&2 | ||
14 | } | ||
15 | |||
16 | store_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 | |||
27 | assert_root() | ||
28 | { | ||
29 | [ "$(id -u)" = 0 ] || error "you are not root" | ||
30 | } | ||
31 | |||
32 | main() | ||
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 | |||
44 | case $# in | ||
45 | 0) read child < reused-child && main "$child" ;; | ||
46 | *) main "$@" ;; | ||
47 | esac | ||
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 | |||
3 | die() { printf "%s: Error: %s\n" "$0" "$*" >&2; exit 1; } | ||
4 | |||
5 | whole_device() | ||
6 | { | ||
7 | case "$1" in | ||
8 | *-part?) false ;; | ||
9 | *-part??) false ;; | ||
10 | *-part???) false ;; | ||
11 | */usb\*) false ;; | ||
12 | *) true ;; | ||
13 | esac | ||
14 | } | ||
15 | |||
16 | confirm_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 | |||
27 | choose_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 | |||
46 | choose_cdrom() | ||
47 | { | ||
48 | die 'choose_cdrom: unimplemented; specify cdrom device with --out' | ||
49 | } | ||
50 | |||
51 | choose_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 | |||
65 | generate_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 | |||
77 | try_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 | |||
85 | verbosely() | ||
86 | { | ||
87 | (set -x; "$@") | ||
88 | } | ||
89 | |||
90 | xorriso_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 | |||
155 | run_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 | |||
168 | find_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 | |||
176 | if [ -f xorriso-usb.config ]; then | ||
177 | . xorriso-usb.config | ||
178 | fi | ||
179 | |||
180 | volid=SamizdatLive | ||
181 | vmlinuz_dir=$samizdat_linux_dir | ||
182 | efi_dir=$samizdat_grub_efi_dir | ||
183 | gpg_iso_path=gnupghome | ||
184 | |||
185 | |||
186 | outdev= | ||
187 | GPG_INPUT_DIR= | ||
188 | child_dir=$samizdat_child_dir/child.$$ | ||
189 | |||
190 | OPT=$(getopt -o '' --long 'bootloader,reuse-child:,adam,usb,detach,in:,out:,test' -n "$0" -- "$@") || die 'getopt error' | ||
191 | eval set -- "$OPT" | ||
192 | unset OPT | ||
193 | |||
194 | ADAM=; DETACH=; USB=y | ||
195 | while [ $# -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 | ||
208 | done | ||
209 | |||
210 | if [ "$INPUT_DEVICE" ]; then | ||
211 | die "support for --in is disabled because xorriso needs different arguments to produce a bootable image" | ||
212 | |||
213 | elif [ $# = 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 | ||
224 | fi | ||
225 | |||
226 | for 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" | ||
234 | done | ||
235 | |||
236 | |||
237 | [ "$(id -u)" = 0 ] || die "you are not root." | ||
238 | |||
239 | grub-efi.sh || die "grub-efi.sh failed" | ||
240 | |||
241 | choose_outdev | ||
242 | |||
243 | if [ "$REUSE_CHILD" ]; then | ||
244 | GPG_INPUT_DIR=$child_dir/root/.gnupg | ||
245 | [ -d "$GPG_INPUT_DIR" ] || die "invalid child" | ||
246 | else | ||
247 | generate_keys | ||
248 | fi | ||
249 | |||
250 | if [ "$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 | ||
264 | elif [ "$BOOTLOADER_ONLY" ]; then | ||
265 | REPLACE_INITRD= | ||
266 | REMOVE_BTRFS= | ||
267 | ADD_BTRFS= | ||
268 | else | ||
269 | REPLACE_INITRD=y | ||
270 | REMOVE_BTRFS=y | ||
271 | ADD_BTRFS=y | ||
272 | fi | ||
273 | REPLACE_INITRD= # TODO: fix initrd replacing | ||
274 | |||
275 | if [ "$QUICK_TEST" ]; then | ||
276 | REMOVE_BTRFS=y | ||
277 | ADD_BTRFS= | ||
278 | fi | ||
279 | |||
280 | if [ "$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 | } | ||
290 | fi | ||
291 | |||
292 | SILENT= | ||
293 | SHOW_XORRISO_CMD=y | ||
294 | |||
295 | run_xorriso "$@" | ||