setup-disk.in 21.9 KB
Newer Older
Natanael Copa's avatar
Natanael Copa committed
1
2
3
4
5
#!/bin/sh

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

6
MBR=${MBR:-"/usr/share/syslinux/mbr.bin"}
7
8
ROOTFS=${ROOTFS:-ext4}
BOOTFS=${BOOTFS:-ext4}
Natanael Copa's avatar
Natanael Copa committed
9
10
11
12
13
14
15
16
17
18
19

in_list() {
	local i="$1"
	shift
	while [ $# -gt 0 ]; do
		[ "$i" = "$1" ] && return 0
		shift
	done
	return 1
}

20
21
22
23
24
25
26
27
# 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=
28
29
30
	case "$1" in
		/dev/md*) echo "$1" && return 0;;
	esac
31
32
33
34
35
36
37
38
39
40
41
42
43
	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
44
enumerate_fstab() {
45
	local mnt="$1"
46
	local fs_spec= fs_file= fs_vfstype= fs_mntops= fs_freq= fs_passno=
47
	[ -z "$mnt" ] && return
48
49
	local escaped_mnt=$(echo $mnt | sed 's:/:\\/:g')
	awk "\$2 ~ /^$escaped_mnt/ {print \$0}" /proc/mounts | \
50
51
52
53
		sed "s:$mnt:/:g; s: :\t:g" | sed 's:/\+:/:g' | \
		while read fs_spec fs_file fs_vfstype fs_mntops fs_freq fs_passno; do
			echo -e "$(uuid_or_device $fs_spec)\t${fs_file}\t${fs_vfstype}\t${fs_mntops} ${fs_freq} ${fs_passno}"
		done
54
55
}

56
57
58
59
60
is_vmware() {
	grep -q VMware /proc/scsi/scsi 2>/dev/null \
		|| grep -q VMware /proc/ide/hd*/model 2>/dev/null
}

61
62
63
64
is_xen() {
	[ -d /proc/xen ]
}

65
66
67
68
69
# return true (0) if given device is lvm
is_lvm() {
	lvs "$1" >/dev/null 2>&1
}

70
71
# Find the disk device from given partition
disk_from_part() {
72
73
	# we need convert cciss/c0d0* cciss!c0d0*...
	local i= part=$(echo ${1#/dev/} | sed 's:/:!:g')
74
75
	for i in /sys/block/*/$part; do
		i=${i%/*}
76
		# ...and back from cciss!c0d0 to cciss/c0d0
77
78
79
80
		if [ -b "/dev/${i##*/}" ]; then
			echo "/dev/${i##*/}" | sed 's:!:/:g'
			return 0
		fi
81
82
83
84
	done
	return 1
}

85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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 -q 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
}

120
121
122
123
124
125
126
127
# 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() {
128
	local mnt="$1"
129
130
131
132
	awk "\$2 == \"$mnt\" { print \$1 }" /proc/mounts | tail -n 1
}

supported_boot_fs() {
133
	local supported="ext2 ext3 ext4 btrfs"
134
135
136
137
138
139
140
141
	local fs=
	for fs in $supported; do
		[ "$fs" = "$1" ] && return 0
	done
	echo "$1 is not supported. Only supported are: $supported" >&2
	return 1
}

142
143
144
145
146
147
148
149
150
151
find_volume_group() {
	local lv=${1##*/}
	lvs --noheadings "$1" | awk "\$1 == \"$lv\" {print \$2}"
}

find_pvs_in_vg() {
	local vg="$1"
	pvs --noheadings | awk "\$2 == \"$vg\" {print \$1}"
}

152
153
install_mounted_root() {
	local mnt="$1" mnt_boot="$1" boot_fs= root_fs=
154
	local initfs_features="ata base ide scsi usb virtio"
155
	local pvs= dev=
156

157
	rootdev=$(find_mount_dev "$mnt")
158
159
160
161
	if [ -z "$rootdev" ]; then
		echo "$mnt does not seem to be a mount point" >&2
		return 1
	fi
162
	root_fs=$(find_mount_fs "$mnt")
163
164
165
166
	initfs_features="$initfs_features $root_fs"

	if is_lvm "$rootdev"; then
		initfs_features="$initfs_features lvm"
167
168
		local vg=$(find_volume_group "$rootdev")
		pvs=$(find_pvs_in_vg $vg)
169
170
	fi

171

172
173
174
175
176
177
178
179
180
181
	bootdev=$(find_mount_dev "$mnt"/boot)
	if [ -z "$bootdev" ]; then
		bootdev=$rootdev
	else
		mnt_boot="$mnt"/boot
		bootdev=$(find_mount_dev "$mnt_boot")
	fi
	boot_fs=$(find_mount_fs "$mnt_boot")
	supported_boot_fs "$boot_fs" || return 1

182
	mbrdisk=$(disk_from_part $bootdev)
183
184
185
186
187
188
189
190
191
192
193

	for dev in $rootdev $pvs; do
		[ -e "/sys/block/${dev#/dev/}/md" ] || continue

		local md=${dev#/dev/}
		initfs_features="$(echo $initfs_features | sed 's/raid//') raid"
		local level=$(cat /sys/block/$md/md/level)
		case "$level" in
			raid1) raidmod="$raidmod,$level";;
			raid[456]) raidmod="$raidmod,raid456";;
		esac
194
195
		raidopt="-r"
		# get a list of slaves
196
		mbrdisk=
197
198
199
		for i in /sys/block/$md/slaves/*; do
			j=${i##*/}
			i=${j%[0-9]*}
200
201
202
			if [ -b "/dev/$i" ]; then
				mbrdisk="$mbrdisk /dev/${i}"
			fi
203
		done
204
	done
205
206
207
208
209
	if [ -n "$VERBOSE" ]; then
		echo "Root device:     $rootdev"
		echo "Root filesystem: $root_fs"
		echo "Boot device:     $bootdev"
		echo "Boot filesystem: $boot_fs"
210
		echo "MBR disk(s):    $mbrdisk"
211
	fi
212

213
	if [ -z "$APKOVL" ]; then
214
215
		ovlfiles=/tmp/ovlfiles
		lbu package - | tar -C "$mnt" -zxv > "$ovlfiles"
216
217
	else
		echo "Restoring backup from $APKOVL to $rootdev..."
218
		unpack_apkovl "$APKOVL" "$mnt" || return 1
219
	fi
220

221
	# generate mkinitfs.conf
222
	mkdir -p "$mnt"/etc/mkinitfs/files.d
223
	echo "features=\"$initfs_features\"" > "$mnt"/etc/mkinitfs/mkinitfs.conf
224
225
226
227
	if [ -n "$raidmod" ]; then
		echo "/sbin/mdadm" > "$mnt"/etc/mkinitfs/files.d/raid
		echo "/etc/mdadm.conf" >> "$mnt"/etc/mkinitfs/files.d/raid
	fi
228

229
230
231
232
233
234
235
236
237
238
239
	# generate the fstab
	if [ -f "$mnt"/etc/fstab ]; then
		mv "$mnt"/etc/fstab "$mnt"/etc/fstab.old
	fi
	enumerate_fstab "$mnt" >> "$mnt"/etc/fstab
	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

240
	# remove the installed db in case its there so we force re-install
241
	rm -f "$mnt"/var/lib/apk/installed "$mnt"/lib/apk/db/installed
242
	echo "Installing system on $rootdev:"
243
244
245
246
	# 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/

247

248
	local apkflags="--initdb --quiet --progress --update-cache --clean-protected"
249
	local pkgs=$(cat "$mnt"/etc/apk/world "$mnt"/var/lib/apk/world 2>/dev/null)
250
	pkgs="$pkgs acct linux-$KERNEL_FLAVOR alpine-base"
251
252
253
254
255
	local repos=$(sed -e 's/\#.*//' /etc/apk/repositories)
	local repoflags=
	for i in $repos; do
		repoflags="$repoflags --repository $i"
	done
256
257
	
	apk add --root "$mnt" $apkflags --overlay-from-stdin \
258
		$repoflags $pkgs <$ovlfiles>/dev/null || return 1
259
	echo ""
260

261
	# make things bootable
262
263
264
265
266
267
	if is_vmware; then
		pax_nouderef="pax_nouderef "
	else
		pax_nouderef=
	fi

268
269
270
271
272
273
274
	if is_xen; then
		# create a menu.lst
		mkdir -p "$mnt"/boot/grub
		cat >"$mnt"/boot/grub/menu.lst <<EOF
default 0
title $KERNEL_FLAVOR
root (hd0,0)
275
kernel /boot/$KERNEL_FLAVOR root=$(uuid_or_device $rootdev) modules=${root_fs}${raidmod} quiet xen BOOT_IMAGE=/boot/$KERNEL_FLAVOR
276
277
278
279
280
initrd=/boot/initramfs-$KERNEL_FLAVOR
EOF
	else
		# create an extlinux.conf
		cat >"$mnt"/boot/extlinux.conf <<EOF
281
282
timeout 20
prompt 1
283
284
285
default $KERNEL_FLAVOR
label $KERNEL_FLAVOR
	kernel /boot/vmlinuz-$KERNEL_FLAVOR
286
	append initrd=/boot/initramfs-$KERNEL_FLAVOR root=$(uuid_or_device $rootdev) modules=sd-mod,usb-storage,${root_fs}${raidmod} ${pax_nouderef}quiet
287
EOF
288
289
	fi

290
291
	# install extlinux
	apk add -q syslinux
292
	is_xen || extlinux -i $raidopt "$mnt"/boot/
293
294
295
296
}

unmount_partitions() {
	local mnt="$1"
297
298
299

	# unmount the partitions
	umount $(awk '{print $2}' /proc/mounts | grep ^"$mnt" | sort -r)
300
}
301

302
fix_mbr_all_disks() {
303
	# fix mbr for all disk devices
304
	for i in $mbrdisk; do
305
306
307
308
		local errmsg
		echo "Writing MBR to $i"
		errmsg=$(dd if="$MBR" of=$i 2>&1) \
			|| echo "$errmsg"
309
	done
310
311
}

312
313
# figure out decent default swap size in mega bytes
find_swap_size() {
314
315
316
	if [ -n "$SWAP_SIZE" ]; then
		return
	fi
317
318
319
320
321
322
323
	local memtotal_kb=$(awk '$1 == "MemTotal:" {print $2}' /proc/meminfo)
	# use 2 * avaiable ram
	echo $(( $memtotal_kb * 2 / 1024 ))
}

has_mounted_part() {
	local p
Natanael Copa's avatar
Natanael Copa committed
324
	# parse /proc/mounts for mounted devices
325
326
	for p in $(awk '$1 ~ /^\/dev\// {gsub("/dev/", "", $1); print $1}' \
			/proc/mounts); do
327
		[ "$p" = "$1" ] && return 0
Natanael Copa's avatar
Natanael Copa committed
328
		[ -e /sys/block/$1/$p ] && return 0
329
330
331
332
	done
	return 1
}

Natanael Copa's avatar
Natanael Copa committed
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
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
353
354
355
356
	if has_holders /sys/block/$b; then
		[ -n "$USE_RAID" ] && echo "Warning: $dev is part of a running raid" >&2
		return 1
	fi
Natanael Copa's avatar
Natanael Copa committed
357
358
359
360
361
362
363

	# check so its not an md device
	[ -e /sys/block/$b/md ] && return 1

	return 0
}

364
find_disks() {
Natanael Copa's avatar
Natanael Copa committed
365
	local p=
366
	for p in $(awk '$1 ~ /[0-9]+/ {print $4}' /proc/partitions); do
Natanael Copa's avatar
Natanael Copa committed
367
		is_available_disk $p && echo -n " $p"
368
369
370
	done
}

371
372
373
374
375
376
377
stop_all_raid() {
	local rd
	for rd in /dev/md*; do
		[ -b $rd ] && mdadm --stop $rd
	done
}

378
379
# obsolete
old_native_disk_install() {
380
	local rootdisk_dev="$1"
Natanael Copa's avatar
Natanael Copa committed
381
	local i size
382
	local boot_size=100 boot_part_type="83" 
383
	local swap_size="$SWAP_SIZE" swap_part_type="82"
384
385
	local root_part_type="83"
	local raidpkg= partitions=
386
387
	local minimum_root_size=$(($boot_size * 2))
	local rootfs=ext4 bootfs=ext4
388
389
390
391
392
393
394
395

	if [ -n "$USE_RAID" ]; then
		boot_part_type="fd"
		swap_part_type="fd"
		root_part_type="fd"
		raidpkg="mdadm"
	fi

396
397
	dmesg -n1
	apk_add -q sfdisk e2fsprogs $raidpkg || return 1
398
399
400
401
402
403
404
405
406
407
408
409
	local root_size=$(( $(sfdisk -s $rootdisk_dev) / 1024 - $swap_size - $boot_size))
	if [ "$root_size" -lt "$minimum_root_size" ]; then
		echo "The $rootdisk_dev is too small. At least $(( $boot_size + $swap_size + $minimum_root_size)) is needed." >&2
		return 1
	fi

	echo ""
	echo "Creating the following partitions on $rootdisk_dev:"
	echo " /boot	${boot_size}MB"
	echo " swap	${swap_size}MB"
	echo " /	${root_size}MB"
	echo ""
410
411
412
	if [ -n "$APKOVL" ]; then
		echo "System from $APKOVL will be restored"
	fi
413
414
415
416
417
418
	echo -n "WARNING: All contents of $rootdisk_dev will be erased. Continue? [y/N]: "
	read i
	case "$i" in
		y*|Y*);;
		*) return 1;;
	esac
419
420
	
	echo "Initializing partitions..."
421
	[ -n "$USE_RAID" ] && stop_all_raid
422

423
424
425
426
427
428
	# 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 $rootdisk_dev >/dev/null

429
430
431
432
433
434
	# create new partitions
	(cat <<EOF
0,$boot_size,$boot_part_type,*
,$swap_size,$swap_part_type
,,$root_part_type
EOF
435
	) | sfdisk -q -L -uM $rootdisk_dev >>/tmp/sfdisk.out || return 1
436
437

	# create device nodes if not exist
Natanael Copa's avatar
Natanael Copa committed
438
439
	mdev -s

440
441
442
443
	if [ -n "$USE_RAID" ]; then
		local p= rd=
		for p in $(sfdisk -l $rootdisk_dev 2>/dev/null \
				| awk '/Linux raid/ {print $1}'); do
444
			local opt="--metadata=0.90"
445
446
			case "$p" in
				*1) rd=/dev/md0; boot_dev=/dev/md0;;
447
448
				*2) rd=/dev/md1; swap_dev=/dev/md1
				    opt= ;;
449
450
451
				*3) rd=/dev/md2; root_dev=/dev/md2;;
			esac
			mdadm --create $rd --level=1 --raid-devices=2 \
452
				$opt --quiet --run $p missing
453
454
455
456
457
458
459
460
461
462
463
464
		done
	else
		local p=
		for p in $(sfdisk -l $rootdisk_dev 2>/dev/null \
				| awk '$1 ~ /^\/dev/ {print $1}'); do
			case "$p" in
				*1) boot_dev=$p;;
				*2) swap_dev=$p;;
				*3) root_dev=$p;;
			esac
		done
	fi
465
	mkfs.$bootfs -q $boot_dev >/dev/null \
466
		&& mkswap $swap_dev >/dev/null \
467
		&& mkfs.$rootfs -q >/dev/null $root_dev \
468
469
470
		|| return 1

	mkdir -p /mnt
471
	mount -t $rootfs $root_dev /mnt || return 1
472
	mkdir -p /mnt/boot
473
	mount -t $bootfs $boot_dev /mnt/boot || return 1
474
475
476
477
	if [ -n "$USE_RAID" ]; then
		mdadm --detail --scan > /etc/mdadm.conf
		rc-update --quiet add mdadm-raid boot
	fi
478
479

	# manually add swap to local fstab and swapon (in case the install needs swap)
480
	sed -i -e '/swap/d' /etc/fstab
481
	echo -e "$(uuid_or_device $swap_dev)\tswap\t\tswap\tdefaults 0 0" >> /etc/fstab
482
483
484
485
486
487
	swapon -a

	install_mounted_root /mnt || return 1

	# manually add swap to mounted fstab and add the swap service to the boot runlevel
	echo -e "$(uuid_or_device $swap_dev)\tswap\t\tswap\tdefaults 0 0" >> /mnt/etc/fstab
488
489
	chroot /mnt rc-update --quiet add swap boot
	chroot /mnt rc-update --quiet add urandom boot
490
491
492
493
494
495
496
497

	unmount_partitions /mnt
	swapoff -a
	fix_mbr_all_disks

	echo ""
	echo "Installation is done. Please reboot."
	apk del -q syslinux
Natanael Copa's avatar
Natanael Copa committed
498
499
}

500
501
502
503
# install needed programs
init_progs() {
	local raidpkg=
	[ -n "$USE_RAID" ] && raidpkg="mdadm"
504
	apk_add -q sfdisk e2fsprogs lvm2 $raidpkg $@
505
506
}

507
508
509
510
511
512
513
show_disk_info() {
	local disk=
	for disk in $@; do
		# TODO: extend ifo with size, model etc...
		echo "  $disk"
	done
}
514

515
516
517
518
519
520
confirm_erase() {
	local answer=
	echo "WARNING: the following disks will be erased:"
	show_disk_info $@
	echo -n "WARNING: Erase the above disks and continue? [y/N]: "
	
521
522
	read answer
	case "$answer" in
523
		y*|Y*) return 0;;
524
	esac
525
526
527
528
529
530
531
532
533
534
	return 1	
}

# setup disk dev in $1 for LVM usage.
# usage: setup_partitions <diskdev> size1,type1 [size2,type2 ...] 
setup_partitions() {
	local diskdev="$1"
	shift

	echo "Initializing partitions on $diskdev..."
535
536
537
538
539
540
541

	# 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

542
543
	local start=0
	local line=
544
545
	# create new partitions
	(
546
547
548
549
		for line in "$@"; do
			echo "$start,$line"
			start=
		done
550
551
552
553
554
555
556
557
558
559
560
561
	) | sfdisk -q -L -uM $diskdev >>/tmp/sfdisk.out || 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 the partition(s) for LVM
562
# this is not marked as bootable and is type 8e
563
564
565
566
567
find_lvm_partition() {
	local type=8e
	sfdisk -d $1 | grep -v bootable | awk "/Id=$type/ {print \$1}"
}

568
# set up boot device. We only use raid1 for boot devices if any raid
569
setup_boot_dev() {
570
571
572
573
	local disk= bootdev=
	local part=$(for disk in $@; do find_boot_partition $disk; done)
	set -- $part
	bootdev=$1
574
575
	[ -z "$bootdev" ] && return 1
	if [ -n "$USE_RAID" ]; then
576
577
578
579
580
581
582
583
		local missing=
		local num=$#
		if [ $# -eq 1 ]; then
			missing="missing"
			num=2
		fi
		mdadm --create /dev/md0 --level=1 --raid-devices=$num \
			--metadata=0.90 --quiet --run $@ $missing || return 1
584
585
		bootdev=/dev/md0
	fi
586
	mkfs.$BOOTFS -q $bootdev
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
	BOOT_DEV="$bootdev"
}

# $1 = index
# $2... = disk devices
find_nth_non_boot_raid_parts() {
	local idx=$1
	local disk=
	shift
	for disk in $@; do
		sfdisk -d $disk | grep -v bootable \
			| awk "/Id=fd/ { i++; if (i==$idx) print \$1 }"
	done
}

setup_non_boot_raid_dev() {
	local md_dev=$1
	local idx=${md_dev#/dev/md}
	shift
	local level=1
	local numdevs=$#
	local missing=
	local raid_parts=$(find_nth_non_boot_raid_parts $idx $@)
	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 /dev/md$idx --level=$level --raid-devices=$num \
		--quiet --run $@ $missing || return 1
620
621
622
623
}

# setup device for lvm, create raid array if needed
setup_lvm_volume_group() {
624
625
626
	local vgname="$1"
	shift
	local lvmdev=
627
628

	if [ -n "$USE_RAID" ]; then
629
630
631
632
		setup_non_boot_raid_dev /dev/md1 $@ || return 1
		lvmdev=/dev/md1
	else	
		lvmdev=$(find_lvm_partition $1)
633
634
635
636
637
	fi

	# be quiet on success
	local errmsg=$(dd if=/dev/zero of=$lvmdev bs=1k count=1 2>&1) \
		|| echo "$errmsg"
638
639
640
641
642
643
644
645
646
647
648
649
650
651
	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
	swapon -a
	rc-update --quiet add swap boot
652
653
654
}

# setup and enable swap on given volumegroup if needed
655
setup_lvm_swap() {
656
	local vgname="$1"
657
	local swapname=lv_swap
658
659
660
	if [ -z "$SWAP_SIZE" ] || [ "$SWAP_SIZE" -eq 0 ]; then
		return
	fi
661
662
	lvcreate --quiet -n $swapname -L ${SWAP_SIZE}MB $vgname
	setup_swap_dev /dev/$vgname/$swapname
663
664
665
666
667
668
669
670
671
672
}

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

673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
# set up /var on given device
setup_var() {
	local var_dev="$1"
	local varfs=ext4
	mkfs.$varfs -q $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

	/etc/init.d/syslog --quiet restart
}

690
691
692
693
694
695
696
setup_mdadm_conf() {
	if [ -n "$USE_RAID" ]; then
		mdadm --detail --scan > /etc/mdadm.conf
		rc-update --quiet add mdadm-raid boot
	fi
}

697
data_only_disk_install() {
698
	local diskdev=
699
700
	local vgname=vg0
	local var_dev=/dev/$vgname/lv_var
701
702
703
704
	local lvm_part_type="8e"
	local raid_part_type="fd"
	local part_type=$lvm_part_type
	local size=
705
706

	init_progs || return 1
707
	confirm_erase $@ || return 1
708

709
710
711
712
	if [ "$USE_RAID" ]; then
		part_type=$raid_part_type
		stop_all_raid
	fi
713

714
715
716
717
718
719
	for diskdev in "$@"; do
		setup_partitions $diskdev "$size,$part_type" || return 1
	done
	
	setup_lvm_volume_group $vgname $@ || return 1
	setup_lvm_swap $vgname
720
	lvcreate --quiet -n ${var_dev##*/} -l 100%FREE $vgname
721
	setup_mdadm_conf
722
	setup_var $var_dev
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
}

# setup 
setup_root() {
	local root_dev="$1" boot_dev="$2"
	mkfs.$ROOTFS -q "$root_dev"
	mkdir -p /mnt
	mount -t $ROOTFS $root_dev /mnt || return 1
	if [ -n "$boot_dev" ]; then
		mkdir -p /mnt/boot
		mount -t $BOOTFS $boot_dev /mnt/boot || return 1
	fi

	setup_mdadm_conf
	install_mounted_root /mnt || return 1
	unmount_partitions /mnt
	swapoff -a
	fix_mbr_all_disks

	echo ""
	echo "Installation is done. Please reboot."
}

native_disk_install() {
	local diskdev= vgname=vg0
	local lvm_part_type="8e"
	local raid_part_type="fd"
	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
757
758

	if [ -n "$USE_RAID" ]; then
759
760
761
		boot_part_type="fd"
		lvm_part_type="fd"
		stop_all_raid
762
	fi
763
764
765
766
767
768
769
770
771
772
773
774
775
	for diskdev in "$@"; do
		setup_partitions $diskdev \
			"$boot_size,$boot_part_type,*" \
			"$lvm_size,$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
	setup_root $root_dev $BOOT_DEV
Natanael Copa's avatar
Natanael Copa committed
776
777
}

778
diskselect_help() {
779
780
	cat <<__EOF__

781
782
783
784
785
786
The disk you select can be used for either traditional disk install
data-only install.

The disk will be erased.

Select 'none' if you want run diskless.
787
788
789
790

__EOF__
}

791
diskmode_help() {
792
793
	cat <<__EOF__

794
795
796
797
798
799
800
801
802
803
804
805
806
You can select between 'root' or 'data'.

* root
  This mode is a traditional disk install. A /boot partition, / (root) and
  swap will be created.
  
  Use this mode for development boxes, desktops, virtual servers etc.

* data
  This mode let you use your disk for data-only. The system itself will run
  from tmpfs (RAM).

  Use this mode is you want use disk only for mailspool, databases, logs  etc.
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834

__EOF__
}

# ask for a root or data disk
# returns answer in global variable $answer
ask_disk() {
	local prompt="$1"
	local help_func="$2"
	shift 2
	answer=

	while ! in_list "$answer" $@ "none" "abort"; do
		echo "Available disks are: $@"
		echon "$prompt [$1] "
		default_read answer $1
		case "$answer" in
			'abort') exit 0;;
			'none') return 0;;
			'?') $help_func;;
			*) if ! [ -b "/dev/$answer" ]; then
				echo "/dev/$answer is not a block device" >&2
				answer=
			   fi;;
		esac
	done
}

835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
usage() {
	cat <<__EOF__
usage: setup-disk [-hqr] [-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 'root'
 -o  Restore system from given apkovl file
 -k  Use kernelflavor instead of $KERNEL_FLAVOR
 -q  Exit quietly if no disks are found
 -r  Enable software raid1 with single disk
 -s  Use SWAPSIZE MB instead of $SWAP_SIZE MB for swap (Use 0 to disable swap)
 -v  Be more verbose about what is happening
__EOF__
	exit 1
}

862
863
864
KERNEL_FLAVOR=grsec
case "$(uname -r)" in
	*-vs[0-9]*) KERNEL_FLAVOR=vserver;;
865
	*-pae) KERNEL_FLAVOR=pae;;
866
867
esac

868
DISK_MODE=
869
SWAP_SIZE=$(find_swap_size)
870
# Parse args
871
while getopts "hk:Lm:o:qrs:v" opt; do
872
	case $opt in
873
		m) DISK_MODE="$OPTARG";;
874
		k) KERNEL_FLAVOR="$OPTARG";;
875
		L) USE_LVM=1;;
876
		o) APKOVL="$OPTARG";;
877
878
		q) QUIET=1;;
		r) USE_RAID=1;;
879
		s) SWAP_SIZE="$OPTARG";;
880
		v) VERBOSE=1;;
Natanael Copa's avatar
Natanael Copa committed
881
		*) usage;;
882
883
	esac
done
884
shift $(( $OPTIND - 1))
885

886
887
if [ -d "$1" ]; then
	# install to given mounted root
888
	install_mounted_root "${1%/}"
889
890
891
	exit $?
fi

892
893
894
895
896
897
898
899
900
901
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

902
disks=$(find_disks)
903
diskdevs=
Natanael Copa's avatar
Natanael Copa committed
904
905

# no disks so lets exit quietly.
906
907
908
909
if [ -z "$disks" ]; then
	[ -z "$QUIET" ] && echo "No disks found." >&2
	exit 0
fi
Natanael Copa's avatar
Natanael Copa committed
910

911
912
913
914
915
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
Natanael Copa's avatar
Natanael Copa committed
916
			echo "$i is not a suitable for partitioning"
917
918
			exit 1
		fi
919
		diskdevs="$diskdevs /dev/$j"
920
921
	done
else
922
923
	ask_disk "Which disk would you like to use? (or '?' for help or 'none')" \
		diskselect_help $disks
924
925
926
	if [ "$answer" != none ]; then
		diskdevs=/dev/$answer
	fi
927
fi
Natanael Copa's avatar
Natanael Copa committed
928

929
if [ -n "$diskdevs" ] && [ -z "$DISK_MODE" ]; then
930
931
	answer=
	while true; do
932
933
934
		echo "The following disks are selected:"
		show_disk_info $diskdevs
		echon "How would you like to use them? ('root', 'data' or '?' for help) [?] "
935
936
937
938
939
940
		default_read answer '?'
		case "$answer" in
		'?') diskmode_help;;
		root|data) break;;
		esac
	done
941
	DISK_MODE="$answer"
942
fi
Natanael Copa's avatar
Natanael Copa committed
943

944
945
946
947
set -- $diskdevs
if [ $# -gt 1 ]; then
	USE_RAID=1
fi
948

949
950
dmesg -n1

951
# native disk install
952
case "$DISK_MODE" in
953
954
root) native_disk_install $diskdevs;;
data) data_only_disk_install $diskdevs;;
955
*) echo "Not a valid install mode: $DISK_MODE" >&2; exit 1;;
956
esac
Natanael Copa's avatar
Natanael Copa committed
957