setup-disk.in

#!/bin/sh

PREFIX=
. "$PREFIX/lib/libalpine.sh"

MBR=${MBR:-"/usr/share/syslinux/mbr.bin"}
ROOTFS=${ROOTFS:-ext4}
BOOTFS=${BOOTFS:-ext4}
VARFS=${VARFS:-ext4}

# 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
}

# Find the disk device from given partition
disk_from_part() {
	# we need convert cciss/c0d0* cciss!c0d0*...
	local i= part=$(echo ${1#/dev/} | sed 's:/:!:g')
	for i in /sys/block/*/$part; do
		i=${i%/*}
		# ...and back from cciss!c0d0 to cciss/c0d0
		if [ -b "/dev/${i##*/}" ]; then
			echo "/dev/${i##*/}" | sed 's:!:/:g'
			return 0
		fi
	done
	return 1
}

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"
	local fs=
	for fs in $supported; do
		[ "$fs" = "$1" ] && return 0
	done
	echo "$1 is not supported. Only supported are: $supported" >&2
	return 1
}

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
}

has_bootopt() {
	local opt="$1"
	set -- $(cat /proc/cmdline)
	for i; do
		[ "$i" = "$opt" ] && return 0
	done
	return 1
}

# setup grub bootloader
setup_grub() {
	local mnt="$1" root="$2" modules="$3" kernel_opts="$4"
	shift 4
	local disks="${@}"

	for disk in $disks; do
		# install grub
		prep=$(find_prep_partition $disk)
		echo "Installing grub on $prep"
		grub-install --boot-directory="$mnt"/boot/ $prep
	done
	# create grub config
	cat > "$mnt"/boot/grub/grub.cfg  <<- EOF
	set timeout=2
	menuentry "Alpine Linux" {
		linux   /boot/vmlinuz $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 cdrom ext2 ext3 ext4 keymap kms mmc raid scsi usb virtio nvme"
	local pvs= dev= rootdev= bootdev= extlinux_raidopt= root= modules=
	local kernel_opts="quiet"

	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"
			;;
		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 has_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_DEVICE" ]; then
		echo -e "${SWAP_DEVICE}\tswap\tswap\tdefaults\t0 0" \
			>> "$mnt"/etc/fstab
	fi
	cat >>"$mnt"/etc/fstab <<-__EOF__
		/dev/cdrom	/media/cdrom	iso9660	noauto,ro 0 0
		/dev/fd0	/media/floppy	vfat	noauto	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 "$ARCH" in
                ppc64le) setup_grub "$mnt" "$root" "$modules" "$kernel_opts" $disks;;
                *) setup_syslinux "$mnt" "$root" "$modules" "$kernel_opts" "$bootdev";;
        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
}

# install needed programs
init_progs() {
	local raidpkg= lvmpkg= fs= fstools=
	[ -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";;
		esac
	done
	apk add --quiet sfdisk $lvmpkg $raidpkg $fstools $@
}

show_disk_info() {
	local disk= vendor= model= d= size=
	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)
		size=$(awk '{gb = ($1 * 512)/1000000000; printf "%.1f GB\n", gb}' /sys/block/$d/size 2>/dev/null)
		echo "  $dev	($size $vendor $model)"
	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"
	shift

	echo "Initializing partitions on $diskdev..."

	# new disks does not have an DOS signature in sector 0
	# this makes sfdisk complain. We can workaround this by letting
	# fdisk create that DOS signature, by just do a "w", a write.
	# http://bugs.alpinelinux.org/issues/show/145
	echo "w" | fdisk $diskdev >/dev/null

	# fix the MBR while here so extlinux can boot
	if [ -f "$MBR" ]; then
		cat "$MBR" > $diskdev
	fi

	local start=1M
	local line=
	# create new partitions
	(
		for line in "$@"; do
			echo "$start,$line"
			start=
		done
	) | sfdisk --quiet $diskdev >/dev/null || return 1

	# create device nodes if not exist
	mdev -s
}

# find the bootable partition on given disk
find_boot_partition() {
	sfdisk -d $1 | awk '/bootable/ {print $1}'
}

# find partition from PReP type on given disk
find_prep_partition() {
	sfdisk -d $1 | awk '/type=41/ {print $1}'
}

# find the partition(s) for LVM
# this is not marked as bootable and is type 8e
find_lvm_partition() {
	local type=8e
	sfdisk -d $1 | grep -v bootable | awk "/(Id|type)=$type/ {print \$1}"
}

# set up optional raid and create filesystem on boot device.
setup_boot_dev() {
	local disks="$@" disk= bootdev= mkfs_args="-q"
	local part=$(for disk in $disks; do find_boot_partition $disk; 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
	local id=$2
	local disk=
	shift
	shift
	for disk in $@; do
		sfdisk -d $disk | grep -v bootable \
			| awk "/(Id|type)=$id/ { i++; if (i==$idx) print \$1 }"
	done
}

setup_non_boot_raid_dev() {
	local md_dev=$1
	local idx=${md_dev#/dev/md}
	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 raid_parts=$(find_nth_non_boot_parts $idx "fd" $@)
	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_lvm_partition $1)
	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
	for swap_dev in "$@"; do
		mkswap $swap_dev >/dev/null
		echo -e "$swap_dev\tswap\t\tswap\tdefaults 0 0" >> /etc/fstab
	done
	SWAP_DEVICE="$(uuid_or_device $swap_dev)"
	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 "${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="8e"
	local part_type=$lvm_part_type
	local size=

	init_progs || return 1
	confirm_erase $@ || return 1

	if [ "$USE_RAID" ]; then
		# the paritition type for raid is "fd"
		part_type="fd"
		stop_all_raid
	fi

	for diskdev in "$@"; do
		setup_partitions $diskdev "${size}${size:+M},$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="83"
	local swap_part_type=82
	local size=
	local swap_dev= var_dev=

	init_progs || return 1
	confirm_erase $@ || return 1

	if [ "$USE_RAID" ]; then
		var_part_type="fd"
		swap_part_type="fd"
		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
		[ $SWAP_SIZE -gt 0 ] && setup_non_boot_raid_dev /dev/md1 $@
		setup_non_boot_raid_dev /dev/md2 $@ || return 1
		swap_dev=/dev/md1
		var_dev=/dev/md2
	else
		swap_dev=$(find_nth_non_boot_parts 1 82 $@)
		var_dev=$(find_nth_non_boot_parts 1 83 $@)
	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" ]; then
		mkdir -p "$SYSROOT"/boot
		mount -t $BOOTFS $boot_dev "$SYSROOT"/boot || 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="8e"
	local boot_part_type="83"
	local boot_size=${BOOT_SIZE:-100}
	local lvm_size=
	local root_dev=/dev/$vgname/lv_root

	init_progs syslinux || return 1
	confirm_erase $@ || return 1

	if [ -n "$USE_RAID" ]; then
		boot_part_type="fd"
		lvm_part_type="fd"
		stop_all_raid
	fi
	for diskdev in "$@"; do
		setup_partitions $diskdev \
			"${boot_size}M,$boot_part_type,*" \
			"${lvm_size}${lvm_size:+M},$lvm_part_type" || return 1
	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="41" root_part_type="83" swap_part_type="82" boot_part_type="83"
	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=
	local bootloader=

	case "$ARCH" in
		ppc64le) bootloader=grub-ieee1275;;
		*) bootloader=syslinux;;
	esac
	init_progs $bootloader || return 1
	confirm_erase $@ || return 1

	if [ -n "$USE_RAID" ]; then
		boot_part_type="fd"
		root_part_type="fd"
		swap_part_type="fd"
		stop_all_raid
	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

		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
		[ $SWAP_SIZE -gt 0 ] && setup_non_boot_raid_dev /dev/md1 $@
		setup_non_boot_raid_dev /dev/md2 $@ || return 1
		swap_dev=/dev/md1
		root_dev=/dev/md2
	else
		swap_dev=$(find_nth_non_boot_parts 1 82 $@)
		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 83 $@)
	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 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
		  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

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
			echo "$i is not a suitable for partitioning"
			exit 1
		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 [ $# -gt 1 ]; then
	USE_RAID=1
fi

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;;
*) echo "Not a valid install mode: $DISK_MODE" >&2; exit 1;;
esac

RC=$?
echo "$DISK_MODE" > /tmp/alpine-install-diskmode.out