mirror of
https://github.com/zerotier/edge.git
synced 2026-05-22 16:25:05 -07:00
Adam Ierymenko
1335 lines
32 KiB
Bash
Executable File
1335 lines
32 KiB
Bash
Executable File
#!/bin/sh
|
|
|
|
PREFIX=
|
|
. "$PREFIX/lib/libalpine.sh"
|
|
. "$PREFIX/lib/dasd-functions.sh"
|
|
|
|
MBR=${MBR:-"/usr/share/syslinux/mbr.bin"}
|
|
ROOTFS=${ROOTFS:-ext4}
|
|
BOOTFS=${BOOTFS:-ext4}
|
|
VARFS=${VARFS:-ext4}
|
|
BOOTLOADER=${BOOTLOADER:-syslinux}
|
|
DISKLABEL=${DISKLABEL:-dos}
|
|
|
|
# default location for mounted root
|
|
SYSROOT=${SYSROOT:-/mnt}
|
|
|
|
# machine arch
|
|
ARCH=$(apk --print-arch)
|
|
|
|
in_list() {
|
|
local i="$1"
|
|
shift
|
|
while [ $# -gt 0 ]; do
|
|
[ "$i" = "$1" ] && return 0
|
|
shift
|
|
done
|
|
return 1
|
|
}
|
|
|
|
all_in_list() {
|
|
local needle="$1"
|
|
local i
|
|
[ -z "$needle" ] && return 1
|
|
shift
|
|
for i in $needle; do
|
|
in_list "$i" $@ || return 1
|
|
done
|
|
return 0
|
|
}
|
|
|
|
# wrapper to only show given device
|
|
_blkid() {
|
|
blkid | grep "^$1:"
|
|
}
|
|
|
|
# if given device have an UUID display it, otherwise return the device
|
|
uuid_or_device() {
|
|
local i=
|
|
case "$1" in
|
|
/dev/md*) echo "$1" && return 0;;
|
|
esac
|
|
for i in $(_blkid "$1"); do
|
|
case "$i" in
|
|
UUID=*) eval $i;;
|
|
esac
|
|
done
|
|
if [ -n "$UUID" ]; then
|
|
echo "UUID=$UUID"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
|
|
# generate an fstab from a given mountpoint. Convert to UUID if possible
|
|
enumerate_fstab() {
|
|
local mnt="$1"
|
|
local fs_spec= fs_file= fs_vfstype= fs_mntops= fs_freq= fs_passno=
|
|
[ -z "$mnt" ] && return
|
|
local escaped_mnt=$(echo $mnt | sed -e 's:/*$::' -e 's:/:\\/:g')
|
|
awk "\$2 ~ /^$escaped_mnt(\/|\$)/ {print \$0}" /proc/mounts | \
|
|
sed "s:$mnt:/:g; s: :\t:g" | sed -E 's:/+:/:g' | \
|
|
while read fs_spec fs_file fs_vfstype fs_mntops fs_freq fs_passno; do
|
|
if [ "$fs_file" = / ]; then
|
|
fs_passno=1
|
|
else
|
|
fs_passno=2
|
|
fi
|
|
echo -e "$(uuid_or_device $fs_spec)\t${fs_file}\t${fs_vfstype}\t${fs_mntops} ${fs_freq} ${fs_passno}"
|
|
done
|
|
}
|
|
|
|
is_vmware() {
|
|
grep -q VMware /proc/scsi/scsi 2>/dev/null \
|
|
|| grep -q VMware /proc/ide/hd*/model 2>/dev/null
|
|
}
|
|
|
|
# return true (0) if given device is lvm
|
|
is_lvm() {
|
|
lvs "$1" >/dev/null 2>&1
|
|
}
|
|
|
|
is_efi() {
|
|
[ -d "/sys/firmware/efi" ] && return 0
|
|
return 1
|
|
}
|
|
|
|
# Find the disk device from given partition
|
|
disk_from_part() {
|
|
local path=${1%/*}
|
|
local dev=${1##*/}
|
|
echo $path/$(basename "$(readlink -f "/sys/class/block/$dev/..")")
|
|
}
|
|
|
|
# $1 partition type (swap,linux,raid,lvm,prep,esp)
|
|
# return partition type id based on table type
|
|
partition_id() {
|
|
local id
|
|
if [ "$DISKLABEL" = "gpt" ]; then
|
|
case "$1" in
|
|
swap) id=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F ;;
|
|
linux) id=0FC63DAF-8483-4772-8E79-3D69D8477DE4 ;;
|
|
raid) id=A19D880F-05FC-4D3B-A006-743F0F84911E ;;
|
|
lvm) id=E6D6D379-F507-44C2-A23C-238F2A3DF928 ;;
|
|
prep) id=9E1A2d38-C612-4316-AA26-8B49521E5A8B ;;
|
|
esp) id=C12A7328-F81F-11D2-BA4B-00A0C93EC93B ;;
|
|
*) die "Partition id \"$1\" is not supported!" ;;
|
|
esac
|
|
elif [ "$DISKLABEL" = "dos" ]; then
|
|
case "$1" in
|
|
swap) id=82 ;;
|
|
linux) id=83 ;;
|
|
raid) id=fd ;;
|
|
lvm) id=8e ;;
|
|
prep) id=41 ;;
|
|
esp) id=EF ;;
|
|
*) die "Partition id \"$1\" is not supported!" ;;
|
|
esac
|
|
elif [ "$DISKLABEL" = "eckd" ]; then
|
|
case "$1" in
|
|
native|lvm|swap|raid|gpfs) id="$1" ;;
|
|
esac
|
|
else
|
|
die "Partition label \"$DISKLABEL\" is not supported!"
|
|
fi
|
|
echo $id
|
|
}
|
|
|
|
# find partitions based on partition type from specified disk
|
|
# type can be any type from partition_id or the literal string "boot"
|
|
find_partitions() {
|
|
local dev="$1" type="$2" search=
|
|
if is_dasd "$dev" eckd; then
|
|
case "$type" in
|
|
boot) echo "$dev"1 ;;
|
|
*) fdasd -p "$dev" | grep "Linux $(partition_id "$type")" | awk '{print $1}' | tail -n 1 ;;
|
|
esac
|
|
return 0
|
|
fi
|
|
case "$type" in
|
|
boot)
|
|
search=bootable
|
|
[ -n "$USE_EFI" ] && search=$(partition_id esp)
|
|
sfdisk -d "$dev" | awk '/'$search'/ {print $1}'
|
|
;;
|
|
*)
|
|
search=$(partition_id "$type")
|
|
sfdisk -d "$dev" | awk '/type='$search'/ {print $1}'
|
|
;;
|
|
esac
|
|
}
|
|
|
|
unpack_apkovl() {
|
|
local ovl="$1"
|
|
local dest="$2"
|
|
local suffix=${ovl##*.}
|
|
local i
|
|
ovlfiles=/tmp/ovlfiles
|
|
if [ "$suffix" = "gz" ]; then
|
|
if ! tar -C "$dest" --numeric-owner -zxvf "$ovl" > $ovlfiles; then
|
|
echo -n "Continue anyway? [Y/n]: "
|
|
read i
|
|
case "$i" in
|
|
n*|N*) return 1;;
|
|
esac
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
apk add --quiet openssl
|
|
|
|
if ! openssl list-cipher-commands | grep "^$suffix$" > /dev/null; then
|
|
errstr="Cipher $suffix is not supported"
|
|
return 1
|
|
fi
|
|
local count=0
|
|
# beep
|
|
echo -e "\007"
|
|
while [ $count -lt 3 ]; do
|
|
openssl enc -d -$suffix -in "$ovl" | tar --numeric-owner \
|
|
-C "$dest" -zxv >$ovlfiles 2>/dev/null && return 0
|
|
count=$(( $count + 1 ))
|
|
done
|
|
ovlfiles=
|
|
return 1
|
|
}
|
|
|
|
# find filesystem of given mounted dir
|
|
find_mount_fs() {
|
|
local mount_point="$1"
|
|
awk "\$2 == \"$mount_point\" {print \$3}" /proc/mounts | tail -n 1
|
|
}
|
|
|
|
# find device for given mounted dir
|
|
find_mount_dev() {
|
|
local mnt="$1"
|
|
awk "\$2 == \"$mnt\" { print \$1 }" /proc/mounts | tail -n 1
|
|
}
|
|
|
|
supported_boot_fs() {
|
|
local supported="ext2 ext3 ext4 btrfs xfs vfat"
|
|
local fs=
|
|
for fs in $supported; do
|
|
[ "$fs" = "$1" ] && return 0
|
|
done
|
|
echo "$1 is not supported. Only supported are: $supported" >&2
|
|
return 1
|
|
}
|
|
|
|
supported_part_label() {
|
|
case "$1" in
|
|
dos|gpt|eckd) return 0 ;;
|
|
*) die "Partition label \"$DISKLABEL\" is not supported!" ;;
|
|
esac
|
|
}
|
|
|
|
find_volume_group() {
|
|
local lv=${1##*/}
|
|
lvs --noheadings "$1" | awk '{print $2}'
|
|
}
|
|
|
|
find_pvs_in_vg() {
|
|
local vg="$1"
|
|
pvs --noheadings | awk "\$2 == \"$vg\" {print \$1}"
|
|
}
|
|
|
|
# echo current grsecurity option and set new
|
|
set_grsec() {
|
|
local key="$1" value="$2"
|
|
if ! [ -e /proc/sys/kernel/grsecurity/$key ]; then
|
|
return 0
|
|
fi
|
|
cat /proc/sys/kernel/grsecurity/$key
|
|
echo $value > /proc/sys/kernel/grsecurity/$key
|
|
}
|
|
|
|
init_chroot_mounts() {
|
|
local mnt="$1" i=
|
|
for i in proc dev; do
|
|
mkdir -p "$mnt"/$i
|
|
mount --bind /$i "$mnt"/$i
|
|
done
|
|
}
|
|
|
|
cleanup_chroot_mounts() {
|
|
local mnt="$1" i=
|
|
for i in proc dev; do
|
|
umount "$mnt"/$i
|
|
done
|
|
}
|
|
|
|
get_bootopt() {
|
|
local opt="$1"
|
|
set -- $(cat /proc/cmdline)
|
|
for i; do
|
|
case "$i" in
|
|
"$opt"|"$opt"=*) echo "${i#*=}"; break;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
# setup GRUB bootloader
|
|
setup_grub() {
|
|
local mnt="$1" root="$2" modules="$3" kernel_opts="$4" bootdev="$5"
|
|
# install GRUB efi mode
|
|
if [ -n "$USE_EFI" ]; then
|
|
local target fwa
|
|
case "$ARCH" in
|
|
x86_64) target=x86_64-efi ; fwa=x64 ;;
|
|
x86) target=i386-efi ; fwa=ia32 ;;
|
|
arm*) target=arm-efi ; fwa=arm ;;
|
|
aarch64) target=arm64-efi ; fwa=aa64 ;;
|
|
esac
|
|
# currently disabling nvram so grub doesnt call efibootmgr
|
|
# installing to alpine directory so other distros dont overwrite it
|
|
grub-install --target=$target --efi-directory="$mnt"/boot/efi \
|
|
--bootloader-id=alpine --boot-directory="$mnt"/boot --no-nvram
|
|
# fallback mode will use boot/boot${fw arch}.efi
|
|
install -D "$mnt"/boot/efi/EFI/alpine/grub$fwa.efi \
|
|
"$mnt"/boot/efi/EFI/boot/boot$fwa.efi
|
|
# install GRUB for ppc64le
|
|
elif [ "$ARCH" = "ppc64le" ]; then
|
|
shift 5
|
|
local disks="${@}"
|
|
for disk in $disks; do
|
|
prep=$(find_partitions "$disk" "prep")
|
|
echo "Installing grub on $prep"
|
|
grub-install --boot-directory="$mnt"/boot $prep
|
|
done
|
|
# install GRUB in bios mode
|
|
else
|
|
local bootdisk=$(disk_from_part $bootdev)
|
|
case "$ARCH" in
|
|
x86|x86_64) grub-install --boot-directory="$mnt"/boot \
|
|
--target=i386-pc $bootdisk ;;
|
|
*) die "Cannot install GRUB in BIOS mode for $ARCH" ;;
|
|
esac
|
|
fi
|
|
|
|
# setup GRUB config
|
|
|
|
# all_video is needed to remove the video error on boot
|
|
cat > "$mnt"/boot/grub/grub.cfg <<- EOF
|
|
set timeout=2
|
|
insmod all_video
|
|
menuentry "Alpine Linux" {
|
|
linux /boot/vmlinuz-$KERNEL_FLAVOR modules=$modules root=$root $kernel_opts
|
|
initrd /boot/initramfs-$KERNEL_FLAVOR
|
|
}
|
|
EOF
|
|
}
|
|
|
|
# setup syslinux bootloader
|
|
setup_syslinux() {
|
|
local mnt="$1" root="$2" modules="$3" kernel_opts="$4" bootdev="$5"
|
|
local exlinux_raidopt=
|
|
|
|
sed -e "s:^root=.*:root=$root:" \
|
|
-e "s:^default_kernel_opts=.*:default_kernel_opts=\"$kernel_opts\":" \
|
|
-e "s:^modules=.*:modules=$modules:" \
|
|
/etc/update-extlinux.conf > "$mnt"/etc/update-extlinux.conf
|
|
if [ "$(rc --sys)" = "XEN0" ]; then
|
|
sed -i -e "s:^default=.*:default=xen-grsec:" \
|
|
"$mnt"/etc/update-extlinux.conf
|
|
fi
|
|
|
|
# Check if we boot from raid so we can pass proper option to
|
|
# extlinux later.
|
|
if [ -e "/sys/block/${bootdev#/dev/}/md" ]; then
|
|
extlinux_raidopt="--raid"
|
|
fi
|
|
|
|
extlinux $extlinux_raidopt --install "$mnt"/boot
|
|
}
|
|
|
|
install_mounted_root() {
|
|
local mnt="$1"
|
|
shift 1
|
|
local disks="${@}" mnt_boot= boot_fs= root_fs=
|
|
local initfs_features="ata base ide scsi usb virtio"
|
|
local pvs= dev= rootdev= bootdev= extlinux_raidopt= root= modules=
|
|
local kernel_opts="quiet"
|
|
[ "$ARCH" = "s390x" ] && initfs_features="$initfs_features qeth dasd_mod"
|
|
|
|
rootdev=$(find_mount_dev "$mnt")
|
|
if [ -z "$rootdev" ]; then
|
|
echo "$mnt does not seem to be a mount point" >&2
|
|
return 1
|
|
fi
|
|
root_fs=$(find_mount_fs "$mnt")
|
|
initfs_features="$initfs_features $root_fs"
|
|
|
|
if is_lvm "$rootdev"; then
|
|
initfs_features="$initfs_features lvm"
|
|
local vg=$(find_volume_group "$rootdev")
|
|
pvs=$(find_pvs_in_vg $vg)
|
|
fi
|
|
|
|
|
|
bootdev=$(find_mount_dev "$mnt"/boot)
|
|
if [ -z "$bootdev" ]; then
|
|
bootdev=$rootdev
|
|
mnt_boot="$mnt"
|
|
else
|
|
mnt_boot="$mnt"/boot
|
|
fi
|
|
boot_fs=$(find_mount_fs "$mnt_boot")
|
|
supported_boot_fs "$boot_fs" || return 1
|
|
|
|
# check if our root is on raid so we can feed mkinitfs and
|
|
# bootloader conf with the proper kernel module params
|
|
for dev in $rootdev $pvs; do
|
|
|
|
# check if we need hardware raid drivers
|
|
case $dev in
|
|
/dev/cciss/*)
|
|
initfs_features="${initfs_features% raid} raid"
|
|
;;
|
|
/dev/nvme*)
|
|
initfs_features="${initfs_features% nvme} nvme"
|
|
;;
|
|
/dev/mmc*)
|
|
initfs_features="${initfs_features% mmc} mmc"
|
|
;;
|
|
esac
|
|
|
|
[ -e "/sys/block/${dev#/dev/}/md" ] || continue
|
|
|
|
local md=${dev#/dev/}
|
|
initfs_features="${initfs_features% raid} raid"
|
|
local level=$(cat /sys/block/$md/md/level)
|
|
case "$level" in
|
|
raid1) raidmod="${raidmod%,raid1},raid1";;
|
|
raid[456]) raidmod="${raidmod%,raid456},raid456";;
|
|
esac
|
|
done
|
|
|
|
|
|
if [ -n "$VERBOSE" ]; then
|
|
echo "Root device: $rootdev"
|
|
echo "Root filesystem: $root_fs"
|
|
echo "Boot device: $bootdev"
|
|
echo "Boot filesystem: $boot_fs"
|
|
fi
|
|
|
|
if [ -z "$APKOVL" ]; then
|
|
ovlfiles=/tmp/ovlfiles
|
|
lbu package - | tar -C "$mnt" -zxv > "$ovlfiles"
|
|
# comment out local repositories
|
|
if [ -f "$mnt"/etc/apk/repositories ]; then
|
|
sed -i -e 's:^/:#/:' "$mnt"/etc/apk/repositories
|
|
fi
|
|
else
|
|
echo "Restoring backup from $APKOVL to $rootdev..."
|
|
unpack_apkovl "$APKOVL" "$mnt" || return 1
|
|
fi
|
|
|
|
# we should not try start modloop on sys install
|
|
rm -f "$mnt"/etc/runlevels/*/modloop
|
|
|
|
# generate mkinitfs.conf
|
|
mkdir -p "$mnt"/etc/mkinitfs/features.d
|
|
echo "features=\"$initfs_features\"" > "$mnt"/etc/mkinitfs/mkinitfs.conf
|
|
if [ -n "$raidmod" ]; then
|
|
echo "/sbin/mdadm" > "$mnt"/etc/mkinitfs/features.d/raid.files
|
|
echo "/etc/mdadm.conf" >> "$mnt"/etc/mkinitfs/features.d/raid.files
|
|
fi
|
|
|
|
# generate update-extlinux.conf
|
|
root=$(uuid_or_device $rootdev)
|
|
kernel_opts="$kernel_opts rootfstype=$root_fs"
|
|
if is_vmware; then
|
|
kernel_opts="pax_nouderef $kernel_opts"
|
|
fi
|
|
if [ -n "$(get_bootopt nomodeset)" ]; then
|
|
kernel_opts="nomodeset $kernel_opts"
|
|
fi
|
|
modules="sd-mod,usb-storage,${root_fs}${raidmod}"
|
|
|
|
# generate the fstab
|
|
if [ -f "$mnt"/etc/fstab ]; then
|
|
mv "$mnt"/etc/fstab "$mnt"/etc/fstab.old
|
|
fi
|
|
enumerate_fstab "$mnt" >> "$mnt"/etc/fstab
|
|
if [ -n "$SWAP_DEVICES" ]; then
|
|
local swap_dev
|
|
for swap_dev in $SWAP_DEVICES; do
|
|
echo -e "$(uuid_or_device ${swap_dev})\tswap\tswap\tdefaults\t0 0" \
|
|
>> "$mnt"/etc/fstab
|
|
done
|
|
fi
|
|
cat >>"$mnt"/etc/fstab <<-__EOF__
|
|
/dev/cdrom /media/cdrom iso9660 noauto,ro 0 0
|
|
/dev/usbdisk /media/usb vfat noauto 0 0
|
|
__EOF__
|
|
# remove the installed db in case its there so we force re-install
|
|
rm -f "$mnt"/var/lib/apk/installed "$mnt"/lib/apk/db/installed
|
|
echo "Installing system on $rootdev:"
|
|
case "$BOOTLOADER" in
|
|
grub) setup_grub "$mnt" "$root" "$modules" "$kernel_opts" "$bootdev" $disks ;;
|
|
syslinux) setup_syslinux "$mnt" "$root" "$modules" "$kernel_opts" "$bootdev" ;;
|
|
zipl) setup_zipl "$mnt" "$root" "$modules" "$kernel_opts" ;;
|
|
*) die "Bootloader \"$BOOTLOADER\" not supported!" ;;
|
|
esac
|
|
|
|
# apk reads config from target root so we need to copy the config
|
|
mkdir -p "$mnt"/etc/apk/keys/
|
|
cp /etc/apk/keys/* "$mnt"/etc/apk/keys/
|
|
|
|
local apkflags="--initdb --quiet --progress --update-cache --clean-protected"
|
|
local pkgs=$(grep -h -v -w sfdisk "$mnt"/etc/apk/world \
|
|
"$mnt"/var/lib/apk/world 2>/dev/null)
|
|
|
|
pkgs="$pkgs acct linux-$KERNEL_FLAVOR alpine-base"
|
|
if [ "$(rc --sys)" = "XEN0" ]; then
|
|
pkgs="$pkgs xen-hypervisor"
|
|
fi
|
|
local repos=$(sed -e 's/\#.*//' /etc/apk/repositories)
|
|
local repoflags=
|
|
for i in $repos; do
|
|
repoflags="$repoflags --repository $i"
|
|
done
|
|
|
|
chroot_caps=$(set_grsec chroot_caps 0)
|
|
init_chroot_mounts "$mnt"
|
|
apk add --root "$mnt" $apkflags --overlay-from-stdin \
|
|
$repoflags $pkgs <$ovlfiles
|
|
local ret=$?
|
|
cleanup_chroot_mounts "$mnt"
|
|
set_grsec chroot_caps $chroot_caps > /dev/null
|
|
return $ret
|
|
}
|
|
|
|
unmount_partitions() {
|
|
local mnt="$1"
|
|
|
|
# unmount the partitions
|
|
umount $(awk '{print $2}' /proc/mounts | egrep "^$mnt(/|\$)" | sort -r)
|
|
}
|
|
|
|
# figure out decent default swap size in mega bytes
|
|
find_swap_size() {
|
|
local memtotal_kb=$(awk '$1 == "MemTotal:" {print $2}' /proc/meminfo)
|
|
# use 2 * avaiable ram or no more than 1/3 of smallest disk space
|
|
local size=$(( $memtotal_kb * 2 / 1024 ))
|
|
local disk= disksize=
|
|
for disk in $@; do
|
|
local sysfsdev=$(echo ${disk#/dev/} | sed 's:/:!:g')
|
|
local sysfspath=/sys/block/$sysfsdev/size
|
|
# disksize = x * 512 / (1024 * 1024) = x / 2048
|
|
# maxsize = $disksize / 4 = x / (2048 * 4) = x / 8192
|
|
maxsize=$(awk '{ printf "%i", $0 / 8192 }' $sysfspath )
|
|
if [ $size -gt $maxsize ]; then
|
|
size=$maxsize
|
|
fi
|
|
done
|
|
if [ $size -gt 4096 ]; then
|
|
# dont ever use more than 4G
|
|
size=4096
|
|
elif [ $size -lt 64 ]; then
|
|
# dont bother create swap smaller than 64MB
|
|
size=0
|
|
fi
|
|
echo $size
|
|
}
|
|
|
|
has_mounted_part() {
|
|
local p
|
|
local sysfsdev=$(echo ${1#/dev/} | sed 's:/:!:g')
|
|
# parse /proc/mounts for mounted devices
|
|
for p in $(awk '$1 ~ /^\/dev\// {gsub("/dev/", "", $1); gsub("/", "!", $1); print $1}' \
|
|
/proc/mounts); do
|
|
[ "$p" = "$sysfsdev" ] && return 0
|
|
[ -e /sys/block/$sysfsdev/$p ] && return 0
|
|
done
|
|
return 1
|
|
}
|
|
|
|
has_holders() {
|
|
local i
|
|
# check if device is used by any md devices
|
|
for i in $1/holders/* $1/*/holders/*; do
|
|
[ -e "$i" ] && return 0
|
|
done
|
|
return 1
|
|
}
|
|
|
|
is_available_disk() {
|
|
local dev=$1
|
|
local b=$(echo $p | sed 's:/:!:g')
|
|
|
|
# check if its a "root" block device and not a partition
|
|
[ -e /sys/block/$b ] || return 1
|
|
|
|
# check so it does not have mounted partitions
|
|
has_mounted_part $dev && return 1
|
|
|
|
# check so its not part of an md setup
|
|
if has_holders /sys/block/$b; then
|
|
[ -n "$USE_RAID" ] && echo "Warning: $dev is part of a running raid" >&2
|
|
return 1
|
|
fi
|
|
|
|
# check so its not an md device
|
|
[ -e /sys/block/$b/md ] && return 1
|
|
|
|
return 0
|
|
}
|
|
|
|
find_disks() {
|
|
local p=
|
|
# filter out ramdisks (major=1)
|
|
for p in $(awk '$1 != 1 && $1 ~ /[0-9]+/ {print $4}' /proc/partitions); do
|
|
is_available_disk $p && echo -n " $p"
|
|
done
|
|
}
|
|
|
|
stop_all_raid() {
|
|
local rd
|
|
for rd in /dev/md*; do
|
|
[ -b $rd ] && mdadm --stop $rd
|
|
done
|
|
}
|
|
|
|
select_bootloader() {
|
|
local bootloader=syslinux
|
|
if [ "$ARCH" = "ppc64le" ]; then
|
|
bootloader=grub-ieee1275
|
|
elif [ "$ARCH" = "s390x" ]; then
|
|
bootloader=s390-tools
|
|
elif [ -n "$USE_EFI" ]; then
|
|
bootloader=grub-efi
|
|
elif [ "$BOOTLOADER" = "grub" ]; then
|
|
bootloader=grub-bios
|
|
fi
|
|
echo "$bootloader"
|
|
}
|
|
|
|
# install needed programs
|
|
init_progs() {
|
|
local raidpkg= lvmpkg= fs= fstools= grub=
|
|
[ -n "$USE_RAID" ] && raidpkg="mdadm"
|
|
[ -n "$USE_LVM" ] && lvmpkg="lvm2"
|
|
for fs in $BOOTFS $ROOTFS $VARFS; do
|
|
# we need load btrfs module early to avoid the error message:
|
|
# 'failed to open /dev/btrfs-control'
|
|
if ! grep -q -w "$fs" /proc/filesystems; then
|
|
modprobe $fs
|
|
fi
|
|
|
|
case $fs in
|
|
xfs) fstools="$fstools xfsprogs";;
|
|
ext*) fstools="$fstools e2fsprogs";;
|
|
btrfs) fstools="$fstools btrfs-progs";;
|
|
vfat) fstools="$fstools dosfstools";;
|
|
esac
|
|
done
|
|
apk add --quiet sfdisk $lvmpkg $raidpkg $fstools $@
|
|
}
|
|
|
|
show_disk_info() {
|
|
local disk= vendor= model= d= size= busid=
|
|
for disk in $@; do
|
|
local dev=${disk#/dev/}
|
|
d=$(echo $dev | sed 's:/:!:g')
|
|
vendor=$(cat /sys/block/$d/device/vendor 2>/dev/null)
|
|
model=$(cat /sys/block/$d/device/model 2>/dev/null)
|
|
busid=$(readlink -f /sys/block/$d/device 2>/dev/null)
|
|
size=$(awk '{gb = ($1 * 512)/1000000000; printf "%.1f GB\n", gb}' /sys/block/$d/size 2>/dev/null)
|
|
if is_dasd $dev eckd; then
|
|
echo " $dev ($size $vendor ${busid##*/})"
|
|
else
|
|
echo " $dev ($size $vendor $model)"
|
|
fi
|
|
done
|
|
}
|
|
|
|
confirm_erase() {
|
|
local answer=
|
|
local erasedisks="$@"
|
|
if [ "$ERASE_DISKS" = "$erasedisks" ]; then
|
|
return 0
|
|
fi
|
|
echo "WARNING: The following disk(s) will be erased:"
|
|
show_disk_info $@
|
|
echo -n "WARNING: Erase the above disk(s) and continue? [y/N]: "
|
|
|
|
read answer
|
|
case "$answer" in
|
|
y*|Y*) return 0;;
|
|
esac
|
|
return 1
|
|
}
|
|
|
|
# setup partitions on given disk dev in $1.
|
|
# usage: setup_partitions <diskdev> size1,type1 [size2,type2 ...]
|
|
setup_partitions() {
|
|
local diskdev="$1" start=1M line=
|
|
shift
|
|
supported_part_label "$DISKLABEL" || return 1
|
|
|
|
# initialize MBR for syslinux only
|
|
if [ "$BOOTLOADER" = "syslinux" ] && [ -f "$MBR" ]; then
|
|
cat "$MBR" > $diskdev
|
|
fi
|
|
|
|
# create new partitions
|
|
(
|
|
for line in "$@"; do
|
|
case "$line" in
|
|
0M*) ;;
|
|
*) echo "$start,$line"; start= ;;
|
|
esac
|
|
done
|
|
) | sfdisk --quiet --label $DISKLABEL $diskdev
|
|
|
|
# create device nodes if not exist
|
|
mdev -s
|
|
}
|
|
|
|
# set up optional raid and create filesystem on boot device.
|
|
setup_boot_dev() {
|
|
local disks="$@" disk= bootdev= mkfs_args=
|
|
[ "$BOOTFS" != "vfat" ] && mkfs_args="-q"
|
|
local part=$(for disk in $disks; do find_partitions "$disk" "boot"; done)
|
|
set -- $part
|
|
bootdev=$1
|
|
[ -z "$bootdev" ] && return 1
|
|
|
|
if [ "$ARCH" = "ppc64le" ]; then
|
|
# Change bootable partition to PReP partition
|
|
for disk in $disks; do
|
|
echo ',,,*' | sfdisk --quiet $disk -N1
|
|
echo ',,,-' | sfdisk --quiet $disk -N2
|
|
mdev -s
|
|
done
|
|
fi
|
|
|
|
echo "Creating file systems..."
|
|
if [ -n "$USE_RAID" ]; then
|
|
local missing=
|
|
local num=$#
|
|
if [ $# -eq 1 ]; then
|
|
missing="missing"
|
|
num=2
|
|
fi
|
|
# we only use raid level 1 for boot devices
|
|
mdadm --create /dev/md0 --level=1 --raid-devices=$num \
|
|
--metadata=0.90 --quiet --run $@ $missing || return 1
|
|
bootdev=/dev/md0
|
|
fi
|
|
case "$BOOTFS" in
|
|
btrfs) mkfs_args="";;
|
|
ext4) mkfs_args="$mkfs_args -O ^64bit";; # pv-grub does not support 64bit
|
|
esac
|
|
mkfs.$BOOTFS $MKFS_OPTS_BOOT $mkfs_args $bootdev
|
|
BOOT_DEV="$bootdev"
|
|
}
|
|
|
|
# $1 = index
|
|
# $2 = partition type
|
|
# $3... = disk devices
|
|
find_nth_non_boot_parts() {
|
|
local idx=$1 id=$2 disk= type=bootable
|
|
shift 2
|
|
local disks="$@"
|
|
[ -n "$USE_EFI" ] && type=$(partition_id esp)
|
|
for disk in $disks; do
|
|
if is_dasd $disk eckd; then
|
|
fdasd -p $disk | grep "Linux $id" | awk '{print $1}' | tail -n 1
|
|
else
|
|
sfdisk -d $disk | grep -v $type \
|
|
| awk "/(Id|type)=$id/ { i++; if (i==$idx) print \$1 }"
|
|
fi
|
|
done
|
|
}
|
|
|
|
setup_non_boot_raid_dev() {
|
|
local md_dev=$1
|
|
local idx=${md_dev#/dev/md}
|
|
[ -z "$md_dev" ] && return 0
|
|
if [ "$ARCH" = "ppc64le" ]; then
|
|
# increment idx as PReP partition is
|
|
# the bootable partition in ppc64le
|
|
idx=$((idx+1))
|
|
fi
|
|
shift
|
|
local level=1
|
|
local missing=
|
|
local pid=$(partition_id raid)
|
|
local raid_parts=$(find_nth_non_boot_parts $idx $pid $@)
|
|
set -- $raid_parts
|
|
# how many disks do we have?
|
|
case $# in
|
|
0) echo "No Raid partitions found" >&2; return 1;;
|
|
1) level=1; missing="missing"; num=2;;
|
|
2) level=1; missing= ; num=2;;
|
|
*) level=5; missing= ; num=$#;;
|
|
esac
|
|
mdadm --create $md_dev --level=$level --raid-devices=$num \
|
|
--quiet --run $@ $missing || return 1
|
|
}
|
|
|
|
# setup device for lvm, create raid array if needed
|
|
setup_lvm_volume_group() {
|
|
local vgname="$1"
|
|
shift
|
|
local lvmdev=
|
|
|
|
if [ -n "$USE_RAID" ]; then
|
|
setup_non_boot_raid_dev /dev/md1 $@ || return 1
|
|
lvmdev=/dev/md1
|
|
else
|
|
lvmdev=$(find_partitions "$1" "lvm")
|
|
fi
|
|
|
|
# be quiet on success
|
|
local errmsg=$(dd if=/dev/zero of=$lvmdev bs=1k count=1 2>&1) \
|
|
|| echo "$errmsg"
|
|
pvcreate --quiet $lvmdev \
|
|
&& vgcreate --quiet $vgname $lvmdev >/dev/null
|
|
}
|
|
|
|
# set up swap on given device(s)
|
|
setup_swap_dev() {
|
|
local swap_dev=
|
|
sed -i -e '/swap/d' /etc/fstab
|
|
SWAP_DEVICES=
|
|
for swap_dev in "$@"; do
|
|
mkswap $swap_dev >/dev/null
|
|
echo -e "$(uuid_or_device $swap_dev)\tswap\t\tswap\tdefaults 0 0" >> /etc/fstab
|
|
SWAP_DEVICES="$SWAP_DEVICES $swap_dev"
|
|
done
|
|
swapon -a
|
|
rc-update --quiet add swap boot
|
|
}
|
|
|
|
# setup and enable swap on given volumegroup if needed
|
|
setup_lvm_swap() {
|
|
local vgname="$1"
|
|
local swapname=lv_swap
|
|
if [ -z "$SWAP_SIZE" ] || [ "$SWAP_SIZE" -eq 0 ]; then
|
|
return
|
|
fi
|
|
lvcreate --quiet -n $swapname -L ${SWAP_SIZE}MB $vgname
|
|
setup_swap_dev /dev/$vgname/$swapname
|
|
}
|
|
|
|
# if /var is mounted, move out data and umount it
|
|
reset_var() {
|
|
[ -z "$(find_mount_dev /var)" ] && return 0
|
|
mkdir /.var
|
|
mv /var/* /.var/ 2>/dev/null
|
|
umount /var && rm -rf /var && mv /.var /var && rm -rf /var/lost+found
|
|
}
|
|
|
|
# set up /var on given device
|
|
setup_var() {
|
|
local var_dev="$1"
|
|
local varfs=${VARFS}
|
|
echo "Creating file systems..."
|
|
mkfs.$varfs $MKFS_OPTS_VAR $var_dev >/dev/null || return 1
|
|
sed -i -e '/[[:space:]]\/var[[:space:]]/d' /etc/fstab
|
|
echo -e "$(uuid_or_device ${var_dev})\t/var\t\t${varfs}\tdefaults 1 2" >> /etc/fstab
|
|
|
|
mv /var /.var
|
|
mkdir /var
|
|
mount /var
|
|
mv /.var/* /var/
|
|
rmdir /.var
|
|
|
|
service syslog --quiet condrestart
|
|
setup_mdadm_conf
|
|
}
|
|
|
|
setup_mdadm_conf() {
|
|
local mods= mod=
|
|
if [ -n "$USE_RAID" ]; then
|
|
mdadm --detail --scan > /etc/mdadm.conf
|
|
rc-update --quiet add mdadm-raid boot
|
|
mods=$(awk '/^raid/ {print $1}' /proc/modules)
|
|
for mod in $mods; do
|
|
if ! grep -q "^$mod" /etc/modules; then
|
|
echo $mod >> /etc/modules
|
|
fi
|
|
done
|
|
fi
|
|
}
|
|
|
|
data_only_disk_install_lvm() {
|
|
local diskdev=
|
|
local vgname=vg0
|
|
local var_dev=/dev/$vgname/lv_var
|
|
local lvm_part_type=$(partition_id lvm)
|
|
local size=
|
|
unset BOOTLOADER
|
|
|
|
init_progs || return 1
|
|
confirm_erase $@ || return 1
|
|
|
|
if [ "$USE_RAID" ]; then
|
|
lvm_part_type=$(partition_id raid)
|
|
stop_all_raid
|
|
fi
|
|
|
|
for diskdev in "$@"; do
|
|
setup_partitions $diskdev "${size}${size:+M},$lvm_part_type" || return 1
|
|
done
|
|
|
|
setup_lvm_volume_group $vgname $@ || return 1
|
|
setup_lvm_swap $vgname
|
|
lvcreate --quiet -n ${var_dev##*/} -l 100%FREE $vgname
|
|
setup_mdadm_conf
|
|
rc-update add lvm boot
|
|
setup_var $var_dev
|
|
}
|
|
|
|
data_only_disk_install() {
|
|
local diskdev=
|
|
local var_dev=
|
|
local var_part_type=$(partition_id linux)
|
|
local swap_part_type=$(partition_id swap)
|
|
local size=
|
|
local swap_dev= var_dev=
|
|
unset BOOTLOADER
|
|
|
|
init_progs || return 1
|
|
confirm_erase $@ || return 1
|
|
|
|
if [ "$USE_RAID" ]; then
|
|
var_part_type=$(partition_id raid)
|
|
swap_part_type=$(partition_id raid)
|
|
stop_all_raid
|
|
fi
|
|
|
|
for diskdev in "$@"; do
|
|
setup_partitions $diskdev \
|
|
"${SWAP_SIZE}M,$swap_part_type" \
|
|
"${size}${size:+M},$var_part_type" || return 1
|
|
done
|
|
|
|
if [ "$USE_RAID" ]; then
|
|
if [ $SWAP_SIZE -gt 0 ]; then
|
|
swap_dev=/dev/md1
|
|
var_dev=/dev/md2
|
|
else
|
|
swap_dev=
|
|
var_dev=/dev/md1
|
|
fi
|
|
setup_non_boot_raid_dev "$swap_dev" $@ || return 1
|
|
setup_non_boot_raid_dev "$var_dev" $@ || return 1
|
|
else
|
|
swap_dev=$(find_nth_non_boot_parts 1 "$swap_part_type" $@)
|
|
var_dev=$(find_nth_non_boot_parts 1 "$var_part_type" $@)
|
|
fi
|
|
[ $SWAP_SIZE -gt 0 ] && setup_swap_dev $swap_dev
|
|
setup_var $var_dev
|
|
}
|
|
|
|
# setup
|
|
setup_root() {
|
|
local root_dev="$1" boot_dev="$2"
|
|
shift 2
|
|
local disks="$@" mkfs_args="-q"
|
|
[ "$ROOTFS" = "btrfs" ] && mkfs_args=""
|
|
mkfs.$ROOTFS $MKFS_OPTS_ROOT $mkfs_args "$root_dev"
|
|
mkdir -p "$SYSROOT"
|
|
mount -t $ROOTFS $root_dev "$SYSROOT" || return 1
|
|
if [ -n "$boot_dev" ] && [ -z "$USE_EFI" ]; then
|
|
mkdir -p "$SYSROOT"/boot
|
|
mount -t $BOOTFS $boot_dev "$SYSROOT"/boot || return 1
|
|
fi
|
|
if [ -n "$boot_dev" ] && [ -n "$USE_EFI" ]; then
|
|
mkdir -p "$SYSROOT"/boot/efi
|
|
mount -t $BOOTFS $boot_dev "$SYSROOT"/boot/efi || return 1
|
|
fi
|
|
|
|
setup_mdadm_conf
|
|
install_mounted_root "$SYSROOT" "$disks" || return 1
|
|
unmount_partitions "$SYSROOT"
|
|
swapoff -a
|
|
|
|
echo ""
|
|
echo "Installation is complete. Please reboot."
|
|
}
|
|
|
|
native_disk_install_lvm() {
|
|
local diskdev= vgname=vg0
|
|
local lvm_part_type=$(partition_id lvm)
|
|
local boot_part_type=$(partition_id linux)
|
|
local boot_size=${BOOT_SIZE:-100}
|
|
local lvm_size=
|
|
local root_dev=/dev/$vgname/lv_root
|
|
|
|
init_progs $(select_bootloader) || return 1
|
|
confirm_erase $@ || return 1
|
|
|
|
if [ -n "$USE_RAID" ]; then
|
|
boot_part_type=$(partition_id raid)
|
|
lvm_part_type=$(partition_id raid)
|
|
stop_all_raid
|
|
fi
|
|
|
|
if [ -n "$USE_EFI" ]; then
|
|
boot_part_type=$(partition_id esp)
|
|
fi
|
|
|
|
for diskdev in "$@"; do
|
|
if is_dasd $diskdev eckd; then
|
|
root_part_type="lvm"
|
|
setup_partitions_eckd $diskdev \
|
|
$boot_size 0 $root_part_type || return 1
|
|
else
|
|
setup_partitions $diskdev \
|
|
"${boot_size}M,$boot_part_type,*" \
|
|
"${lvm_size}${lvm_size:+M},$lvm_part_type" || return 1
|
|
fi
|
|
done
|
|
|
|
# will find BOOT_DEV for us
|
|
setup_boot_dev $@
|
|
|
|
setup_lvm_volume_group $vgname $@ || return 1
|
|
setup_lvm_swap $vgname
|
|
lvcreate --quiet -n ${root_dev##*/} -l 100%FREE $vgname
|
|
rc-update add lvm boot
|
|
setup_root $root_dev $BOOT_DEV
|
|
}
|
|
|
|
native_disk_install() {
|
|
local prep_part_type=$(partition_id prep)
|
|
local root_part_type=$(partition_id linux)
|
|
local swap_part_type=$(partition_id swap)
|
|
local boot_part_type=$(partition_id linux)
|
|
local prep_size=8
|
|
local boot_size=${BOOT_SIZE:-100}
|
|
local swap_size=${SWAP_SIZE}
|
|
local root_size=
|
|
local root_dev= boot_dev= swap_dev=
|
|
init_progs $(select_bootloader) || return 1
|
|
confirm_erase $@ || return 1
|
|
|
|
if [ -n "$USE_RAID" ]; then
|
|
boot_part_type=$(partition_id raid)
|
|
root_part_type=$(partition_id raid)
|
|
swap_part_type=$(partition_id raid)
|
|
stop_all_raid
|
|
fi
|
|
|
|
if [ -n "$USE_EFI" ]; then
|
|
boot_part_type=$(partition_id esp)
|
|
fi
|
|
|
|
for diskdev in "$@"; do
|
|
if [ "$ARCH" = "ppc64le" ]; then
|
|
setup_partitions $diskdev \
|
|
"${prep_size}M,$prep_part_type" \
|
|
"${boot_size}M,$boot_part_type,*" \
|
|
"${swap_size}M,$swap_part_type" \
|
|
"${root_size}${root_size:+M},$root_part_type" \
|
|
|| return 1
|
|
elif is_dasd $diskdev eckd; then
|
|
swap_part_type="swap"
|
|
root_part_type="native"
|
|
setup_partitions_eckd $diskdev \
|
|
$boot_size $swap_size $root_part_type || return 1
|
|
else
|
|
setup_partitions $diskdev \
|
|
"${boot_size}M,$boot_part_type,*" \
|
|
"${swap_size}M,$swap_part_type" \
|
|
"${root_size}${root_size:+M},$root_part_type" \
|
|
|| return 1
|
|
fi
|
|
done
|
|
|
|
# will find BOOT_DEV for us
|
|
setup_boot_dev $@
|
|
|
|
if [ "$USE_RAID" ]; then
|
|
if [ $SWAP_SIZE -gt 0 ]; then
|
|
swap_dev=/dev/md1
|
|
root_dev=/dev/md2
|
|
else
|
|
swap_dev=
|
|
root_dev=/dev/md1
|
|
fi
|
|
setup_non_boot_raid_dev "$swap_dev" $@ || return 1
|
|
setup_non_boot_raid_dev "$root_dev" $@ || return 1
|
|
else
|
|
swap_dev=$(find_nth_non_boot_parts 1 "$swap_part_type" $@)
|
|
local index=
|
|
case "$ARCH" in
|
|
# use the second non botable partition on ppc64le,
|
|
# as PReP partition is the bootable partition
|
|
ppc64le) index=2;;
|
|
*) index=1;;
|
|
esac
|
|
root_dev=$(find_nth_non_boot_parts $index "$root_part_type" $@)
|
|
fi
|
|
|
|
[ $SWAP_SIZE -gt 0 ] && setup_swap_dev $swap_dev
|
|
setup_root $root_dev $BOOT_DEV $@
|
|
}
|
|
|
|
diskselect_help() {
|
|
cat <<-__EOF__
|
|
|
|
The disk you select can be used for a traditional disk install or for a
|
|
data-only install.
|
|
|
|
The disk will be erased.
|
|
|
|
Enter 'none' if you want to run diskless.
|
|
|
|
__EOF__
|
|
}
|
|
|
|
diskmode_help() {
|
|
cat <<-__EOF__
|
|
|
|
You can select between 'sys', 'data', 'lvm', 'lvmsys' or 'lvmdata'.
|
|
|
|
sys:
|
|
This mode is a traditional disk install. The following partitions will be
|
|
created on the disk: /boot, / (filesystem root) and swap.
|
|
|
|
This mode may be used for development boxes, desktops, virtual servers, etc.
|
|
|
|
data:
|
|
This mode uses your disk(s) for data storage, not for the operating system.
|
|
The system itself will run from tmpfs (RAM).
|
|
|
|
Use this mode if you only want to use the disk(s) for a mailspool, databases,
|
|
logs, etc.
|
|
|
|
lvm:
|
|
Enable logical volume manager and ask again for 'sys' or 'data'.
|
|
|
|
lvmsys:
|
|
Same as 'sys' but use logical volume manager for partitioning.
|
|
|
|
lvmdata:
|
|
Same as 'data' but use logical volume manager for partitioning.
|
|
|
|
__EOF__
|
|
}
|
|
|
|
# ask for a root or data disk
|
|
# returns answer in global variable $answer
|
|
ask_disk() {
|
|
local prompt="$1"
|
|
local help_func="$2"
|
|
local i=
|
|
shift 2
|
|
answer=
|
|
local default_disk=${DEFAULT_DISK:-$1}
|
|
|
|
while ! all_in_list "$answer" $@ "none" "abort"; do
|
|
echo "Available disks are:"
|
|
show_disk_info "$@"
|
|
echon "$prompt [$default_disk] "
|
|
default_read answer $default_disk
|
|
case "$answer" in
|
|
'abort') exit 0;;
|
|
'none') return 0;;
|
|
'?') $help_func;;
|
|
*) for i in $answer; do
|
|
if ! [ -b "/dev/$i" ]; then
|
|
echo "/dev/$i is not a block device" >&2
|
|
answer=
|
|
fi
|
|
done;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
usage() {
|
|
cat <<-__EOF__
|
|
usage: setup-disk [-hLqrv] [-k kernelflavor] [-m MODE] [-o apkovl] [-s SWAPSIZE]
|
|
[MOUNTPOINT | DISKDEV...]
|
|
|
|
Install alpine on harddisk.
|
|
|
|
If MOUNTPOINT is specified, then do a traditional disk install with MOUNTPOINT
|
|
as root.
|
|
|
|
If DISKDEV is specified, then use the specified disk(s) without asking. If
|
|
multiple disks are specified then set them up in a RAID array. If there are
|
|
mode than 2 disks, then use raid level 5 instead of raid level 1.
|
|
|
|
options:
|
|
-h Show this help
|
|
-m Use disk for MODE without asking, where MODE is either 'data' or 'sys'
|
|
-o Restore system from given apkovl file
|
|
-k Use kernelflavor instead of $KERNEL_FLAVOR
|
|
-L Use LVM to manage partitions
|
|
-q Exit quietly if no disks are found
|
|
-r Enable software raid1 with single disk
|
|
-s Use SWAPSIZE MB instead of autodetecting swap size (Use 0 to disable swap)
|
|
-v Be more verbose about what is happening
|
|
|
|
If BOOTLOADER is specified, the specified bootloader will be used.
|
|
If no bootloader is specified, the default bootloader is syslinux(extlinux)
|
|
except when EFI is detected or explicitly set by USE_EFI which will select grub.
|
|
Supported bootloaders are: grub, syslinux
|
|
|
|
If DISKLABEL is specified, the specified partition label will be used.
|
|
if no partition label is specified, the default label will be dos
|
|
except when EFI is detected or explicitly set by USE_EFI which will select gpt.
|
|
Supported partition labels are: dos, gpt
|
|
|
|
If BOOTFS, ROOTFS, VARFS are specified, then format a partition with specified
|
|
filesystem. If not specified, the default filesystem is ext4.
|
|
Supported filesystems for
|
|
boot: ext2, ext3, ext4, btrfs, xfs, vfat(EFI)
|
|
root: ext2, ext3, ext4, btrfs, xfs
|
|
var: ext2, ext3, ext4, btrfs, xfs
|
|
__EOF__
|
|
exit 1
|
|
}
|
|
|
|
kver=$(uname -r)
|
|
case $kver in
|
|
*-rc[0-9]*) KERNEL_FLAVOR=vanilla;;
|
|
*-[a-z]*) KERNEL_FLAVOR=${kver##*-};;
|
|
*) KERNEL_FLAVOR=vanilla;;
|
|
esac
|
|
|
|
DISK_MODE=
|
|
USE_LVM=
|
|
# Parse args
|
|
while getopts "hk:Lm:o:qrs:v" opt; do
|
|
case $opt in
|
|
m) DISK_MODE="$OPTARG";;
|
|
k) KERNEL_FLAVOR="$OPTARG";;
|
|
L) USE_LVM="_lvm";;
|
|
o) APKOVL="$OPTARG";;
|
|
q) QUIET=1;;
|
|
r) USE_RAID=1;;
|
|
s) SWAP_SIZE="$OPTARG";;
|
|
v) VERBOSE=1;;
|
|
*) usage;;
|
|
esac
|
|
done
|
|
shift $(( $OPTIND - 1))
|
|
|
|
if [ -d "$1" ]; then
|
|
# install to given mounted root
|
|
apk add --quiet syslinux
|
|
install_mounted_root "${1%/}" \
|
|
&& echo "You might need fix the MBR to be able to boot" >&2
|
|
exit $?
|
|
fi
|
|
|
|
reset_var
|
|
swapoff -a
|
|
|
|
# stop all volume groups in use
|
|
vgchange --ignorelockingfailure -a n >/dev/null 2>&1
|
|
|
|
if [ -n "$USE_RAID" ]; then
|
|
stop_all_raid
|
|
fi
|
|
|
|
check_dasd
|
|
|
|
disks=$(find_disks)
|
|
diskdevs=
|
|
|
|
# no disks so lets exit quietly.
|
|
if [ -z "$disks" ]; then
|
|
[ -z "$QUIET" ] && echo "No disks found." >&2
|
|
exit 0
|
|
fi
|
|
|
|
if [ $# -gt 0 ]; then
|
|
# check that they are
|
|
for i in "$@"; do
|
|
j=$(readlink -f "$i" | sed 's:^/dev/::; s:/:!:g')
|
|
if ! [ -e "/sys/block/$j/device" ]; then
|
|
die "$i is not a suitable for partitioning"
|
|
fi
|
|
diskdevs="$diskdevs /dev/${j//!//}"
|
|
done
|
|
else
|
|
ask_disk "Which disk(s) would you like to use? (or '?' for help or 'none')" \
|
|
diskselect_help $disks
|
|
if [ "$answer" != none ]; then
|
|
for i in $answer; do
|
|
diskdevs="$diskdevs /dev/$i"
|
|
done
|
|
else
|
|
DISK_MODE="none"
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$diskdevs" ] && [ -z "$DISK_MODE" ]; then
|
|
answer=
|
|
disk_is_or_disks_are="disk is"
|
|
it_them="it"
|
|
set -- $diskdevs
|
|
if [ $# -gt 1 ]; then
|
|
disk_is_or_disks_are="disks are"
|
|
it_them="them"
|
|
fi
|
|
|
|
while true; do
|
|
echo "The following $disk_is_or_disks_are selected${USE_LVM:+ (with LVM)}:"
|
|
show_disk_info $diskdevs
|
|
_lvm=${USE_LVM:-", 'lvm'"}
|
|
echon "How would you like to use $it_them? ('sys', 'data'${_lvm#_lvm} or '?' for help) [?] "
|
|
default_read answer '?'
|
|
case "$answer" in
|
|
'?') diskmode_help;;
|
|
sys|data) break;;
|
|
lvm) USE_LVM="_lvm" ;;
|
|
nolvm) USE_LVM="";;
|
|
lvmsys|lvmdata)
|
|
answer=${answer#lvm}
|
|
USE_LVM="_lvm"
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
DISK_MODE="$answer"
|
|
fi
|
|
|
|
if [ -z "$SWAP_SIZE" ]; then
|
|
SWAP_SIZE=$(find_swap_size $diskdevs)
|
|
fi
|
|
|
|
set -- $diskdevs
|
|
if is_dasd $1 eckd; then
|
|
DISKLABEL=eckd
|
|
fi
|
|
if [ $# -gt 1 ]; then
|
|
USE_RAID=1
|
|
fi
|
|
|
|
if is_efi || [ -n "$USE_EFI" ]; then
|
|
USE_EFI=1
|
|
DISKLABEL=gpt
|
|
BOOTLOADER=grub
|
|
BOOT_SIZE=512
|
|
BOOTFS=vfat
|
|
fi
|
|
|
|
case "$ARCH" in
|
|
ppc64le) BOOTLOADER=grub;;
|
|
s390x) BOOTLOADER=zipl;;
|
|
esac
|
|
|
|
dmesg -n1
|
|
|
|
# native disk install
|
|
case "$DISK_MODE" in
|
|
sys) native_disk_install$USE_LVM $diskdevs;;
|
|
data) data_only_disk_install$USE_LVM $diskdevs;;
|
|
none) exit 0;;
|
|
*) die "Not a valid install mode: $DISK_MODE" ;;
|
|
esac
|
|
|
|
RC=$?
|
|
echo "$DISK_MODE" > /tmp/alpine-install-diskmode.out
|
|
exit $RC
|