Betrifft OS:
FreeBSD

MultiBoot mit Grub2

Entwurf: Übernehme keine Haftung für eventuelle Schäden.

Verwandte Artikel

Das Wissen aus den folgenden Artikeln wird beim Lesen dieses Beitrages vorausgesetzt:

(BIOS/MBR:ZFS, geli)

Einrichtung der MBR-Partitionen

Da sich auf Medien mit solch einer vorsintflutlichen Partitionsmethode vermutlich eine Partition für NTFS/FAT befindet, wird diese mit gparted oder gleichartigen Partitionstool verkleinert.

Für eine bootbare ZFS-only Installation von FreeBSD/PCBSD benötigen wir zwei weitere Partitionen. Eine zfs-boot Partition, worauf sich /boot/ befindet und eine zfs-root Partition, die wahlweise auch auf einem geom_eli Provider aufsetzt. Somit verbleibt noch eine Partition für weitere Spielereien.

Ob sich Grub2 überreden lässt aus einem BSD Slice zu booten habe ich bis jetzt nicht getestet.

Da sich schon eine NTFS Partition auf meiner Festplatte befand und die 23 so schön aussieht legte ich mir diese zwei versteckte NTFS Partitionen für FreeBSD-ZFS an.

gpart add -a 2048 -t \!23 -s 2G ada0
gpart add -a 2048 -t \!23 ada0

 Gerät  boot.     Anfang        Ende     Blöcke   Id  System
/dev/sda1   *          63    41945087    20972512+   7  HPFS/NTFS/exFAT
/dev/sda2        41945148    46139372     2097112+  17  Verst. HPFS/NTFS
/dev/sda3        46139436   234440702    94150633+  17  Verst. HPFS/NTFS

zpool einrichten

Creating a writable /boot/zfs for temporary saving zpool.cache

mdmfs -s 5M md2 /boot/zfs

zfs-boot

zpool create -O mountpoint=legacy -O atime=off -O primarycache=metadata zfs-boot /dev/ada0s2
zfs create -o copies=2 zfs-boot/FreeBSD

zfs-root encrypted

geli init -s 4096 -b /dev/ada0s3
geli attach /dev/ada0s3
zpool create -O mountpoint=legacy -O atime=off -O primarycache=metadata zfs-root /dev/ada0s3.eli
zfs create zfs-root/FreeBSD

Installation

mount -t zfs zfs-root/FreeBSD /mnt
mkdir /mnt/zfs-boot
mount -t zfs zfs-boot/FreeBSD /mnt/zfs-boot
sh
cd /usr/freebsd-dist
export DESTDIR=/mnt
for file in base.txz lib32.txz kernel.txz doc.txz ports.txz src.txz;
do (cat $file | tar --unlink -xpJf - -C ${DESTDIR:-/}); done
mv /mnt/boot /mnt/zfs-boot/
cd /mnt && ln -s /zfs-boot/boot boot
cp /boot/zfs/zpool.cache /mnt/zfs-boot/boot/zfs/zpool.cache

/mnt/etc/fstab

#Device          Mountpoint      FStype  Options Dump    Pass#
zfs-root/FreeBSD /               zfs     rw      0       0
zfs-boot/FreeBSD /zfs-boot       zfs     rw      0       0

And change /mnt/etc/rc.conf to your preference. Set up your etc/grub.d/40_custom to include needed kernel modules if you're booting from a encrypted zfs-root.

(BIOS/GPT:ZFS/UFS)

Einrichtung der GPT-Partitionen

Für SSD im allgemeinen und Festplatten mit bs=4096:
Die Partitionen sollten auf einem Vielfachen von 1M starten.
z.B.: 2048*512=1024*1024; 129024*512=63*1024*1024

Ein Beispiel für ein GUID Partitionstabelle:

Partition   Start            Ende   Größe       Typ   gdisk-Bezeichnung
1              34            2047   1007.0 KiB  EF02  BIOS boot partition
2            2048          128896   61.9 MiB    0700  Linux/Windows data
3          128897          129023   63.5 KiB    A501  FreeBSD boot
4          129024       167901183   80.0 GiB    A504  FreeBSD ZFS
5       167901184       176289791   4.0 GiB     A502  FreeBSD swap
6       176289792       195371534   9.1 GiB     0700  Linux/Windows data

Für Grub2 auf einem BIOS-System mit GPT braucht es eine separate „BIOS boot partition“, diese sollte direkt nach dem pmbr starten. Die optimale Größe für die Boot Partition ist mir nicht bekannt. Die „FreeBSD boot“ Partition kann auch direkt nach „BIOS boot partition“ und vor 2048 angelegt werden, wenn diese erwünscht ist (noch nicht getestet).

Anschließend braucht es noch zum gemeinsamen Konfigurieren von Grub eine ext2 Partition (entweder adxp2 oder adxp6 [ln -s in linux entfällt]), in der auch die Konfigurationsdateien nach /usr/local/etc/grub.d/ bzw. unter linux nach /etc/grub.d/ gelinkt werden. Außerdem muss Grub2 Module laden, diese sollten auf einer Partition liegen, auf der Grub2 lesen kann (wenn ich da nicht falsch denke, vielleicht lässt sich auch ein Grub2-loader bauen, der schon zfs/ufs Module implementiert hat).

Dann wird noch die „FreeBSD ZFS“ bzw UFS Partitionen erstellt. Wenn gewollt kann auch auf die „Linux/Windows data“ Partition am Ende des Datenträgers verzichtet werden und in ein reines FreeBSD-System mit mehreren Installationen gebootet werden.

gpart

Fixit# gpart create -s gpt adx
Fixit# gpart add -i 1 -s 2013 -t "\!21686148-6449-6E6F-744E-656564454649" adx
Fixit# gpart add -i 2 -b 2048 -s 126848 -t linux-data -l Linux/Windows\ data adx
Fixit# gpart add -i 3 -s 127 -t freebsd-boot adx
Fixit# gpart add -i 4 -b 129024 -s 80GB -t freebsd-zfs -l FreeBSD\ ZFS adx
Fixit# gpart add -i 5 -s 4G -t freebsd-swap l FreeBSD\ swap adx
Fixit# gpart add -i 6 -t linux-data -l Linux/Windows\ Data adx

gdisk in Linux

Einrichten der BIOS Boot Partition auch unter Linux möglich.
Erste 2013 Sektoren große Partition auf Typ EF02 setzen. (bios_grub)

o - neue GUID Partitionstabelle\\
l - Liste bekannter Partitionstypen\\
n - neue Partition\\
t - Typencode ändern\\

⇒ t → 1 → ef02

Grub2

Grub2 in Linux installieren

Mit einer von Haus aus kommenden Grub2-Unterstützung einfach auf /dev/sda schreiben.

Grub2 aus einer Ubuntu wubi Installation nutzen

Using a downloaded Ubuntu.iso for installing it inside your Windows partition using wubi.exe is a nice way to save one primary partition for grub2.

Just add your menuentry into grub2 custom configuration: /etc/grub.d/40_custom

Update your grub2 installation using following command will show up your FreeBSD menuentry on boot up.

sudo update-grub

You've to pipe changes to /boot/loader.conf and /boot/device.hint to this Grub2-Menuentry, because these are ignored with this boot loader.

Grub2 in FreeBSD installieren (nicht getestet:WIP)

Benötigte Distfiles von Grub2 und dessen Abhängigkeiten auf einen Datenträger ablegen, der von der Fixit-Umgebung erreichbar ist, oder die Fixit-Umgebung manuell für Internetzugang konfigurieren.

Mittels DHCP:

mkdir /var/db/
dhclient re0
echo 'nameserver 192.168.0.1' > /etc/resolv.conf

Manuelle Konfiguration:

ifconfig re0 192.168.0.10
route add default 192.168.0.1
echo 'nameserver 192.168.0.1' > /etc/resolv.conf

ext2 Partition auf /dev/adxp2 erstellen, mounten und Grub2 in chroot installieren

Fixit# kldload /mnt2/boot/kernel/ext2fs.ko
Fixit# chroot /FreeBSD/8.1-RELEASE-amd64/
# pkg_add -r e2fsprogs
# mke2fs /dev/adxp2
# mount -t ext2fs /dev/adxp2 /mnt #should be /boot
# pkg_add -r grub2 # oder cd /usr/ports/sysutils/grub2 && make && make install
# /usr/local/sbin/grub-mkconfig #doesn't work
# /usr/local/sbin/grub-install <drive-to-install> --modules="gpt, ufs2, zfs" --root-directory=/mnt
# /usr/local/sbin/grub-probe -m /mnt/boot/grub/device.map -d /dev/adxp3 -t fs_uuid

Updaten, während die boot-Partition unter /mnt eingebunden ist (testing only).

# grub-mkconfig -o /mnt/boot/grub/grub.cfg

Grub2 Einträge in etc/grub.d/

FreeBSD ZFS

/boot/loader.conf wird unwirksam. Die Module über kFreeBSD laden. Booteinstellungen mit set KFreeBSD vornehmen.

Es wird empfohlen FreeBSD nicht direkt auf den zpool zu installieren, sondern in ein „Unterverzeichnis“. Somit können mit Grub2 mehrere Installationen {RELEASE|STABLE|CURRENT} gebootet werden, auch mit unterschiedlichen Architekturen (amd64/i386). Dabei müssen die Dateisysteme aber über /etc/fstab eingebunden werden.
Installieren nach GPTZFSBoot mit einigen Anpassungen (Punkt 2.6 kann weggelassen werden, wenn nur Grub2 eingesetzt werden soll kann auch Punkt 1.5 entfallen)

Fixit# mkdir /boot/zfs
Fixit# zpool create zpool /dev/gpt/disk0
Fixit# zfs create FreeBSD
Fixit# zfs create FreeBSD/8.1-RELEASE-amd64

  menuentry "FreeBSD/8.1-RELEASE-amd64 ZFS-Dataset auf zpool" {
            insmod zfs
            search -s -l zpool
            kfreebsd /FreeBSD/8.1-RELEASE-amd64@/boot/kernel/kernel
            kfreebsd_module_elf /FreeBSD/8.1-RELEASE-amd64@/boot/kernel/opensolaris.ko
            kfreebsd_module_elf /FreeBSD/8.1-RELEASE-amd64@/boot/kernel/zfs.ko
  #         kfreebsd_module_elf /FreeBSD/8.1-RELEASE-amd64@/boot/kernel/drm.ko # loading kernel modules here
            kfreebsd_module /FreeBSD/8.1-RELEASE-amd64@/boot/zfs/zpool.cache type=/boot/zfs/zpool.cache
            set kFreeBSD.vfs.root.mountfrom=zfs:zpool/FreeBSD/8.1-RELEASE-amd64
  #         set kFreeBSD.vm.kmem_size=x # Loader Tunables here
  #         set kFreeBSD.vm.kmem_size_max=x # Loader Tunables here
  }
  menuentry "FreeBSD ZFS auf zpool" {
            insmod zfs
            search -s -l zpool
            kfreebsd /@/boot/kernel/kernel
            kfreebsd_module_elf /@/boot/kernel/opensolaris.ko
            kfreebsd_module_elf /@/boot/kernel/zfs.ko
            kfreebsd_module /@/boot/zfs/zpool.cache type=/boot/zfs/zpool.cache
            set kFreeBSD.vfs.root.mountfrom=zfs:zpool
  }
menuentry "FreeBSD ZFS on zfs-boot" {
          insmod zfs
          search -s -l zfs-boot
          kfreebsd /FreeBSD@/boot/kernel/kernel
          kfreebsd_module_elf /FreeBSD@/boot/kernel/opensolaris.ko
          kfreebsd_module_elf /FreeBSD@/boot/kernel/zfs.ko
          kfreebsd_module_elf /FreeBSD@/boot/kernel/zlib.ko
          kfreebsd_module_elf /FreeBSD@/boot/kernel/crypto.ko
          kfreebsd_module_elf /FreeBSD@/boot/kernel/geom_eli.ko
          kfreebsd_module /FreeBSD@/boot/zfs/zpool.cache type=/boot/zfs/zpool.cache
          set kFreeBSD.vfs.root.mountfrom=zfs:zfs-root/FreeBSD
          set kFreeBSD.vm.kmem_size="512M"
          set kFreeBSD.vm.kmem_size_max="512M"
          set kFreeBSD.zfs.arc_max="40M"
          set kFreeBSD.zfs.vdev.cache.size="5M"
}

FreeBSD UFS (nicht getestet)

direkt

Mit grub-probe die fs_uuid herausfinden und ${fs_uuid} damit ersetzen.

# /usr/local/sbin/grub-probe -d /dev/ad0s1 -t fs_uuid

menuentry "FreeBSD, ufs direct" {
	insmod ufs2
	set root=(hd0,1,a) (oder (hd0,1)?)
	search --no-floppy --fs-uuid --set ${fs_uuid}
	freebsd                 /boot/kernel/kernel
	freebsd_loadenv         /boot/device.hints
	set FreeBSD.vfs.root.mountfrom=ufs:/dev/ad0s1a (oder ad0s1?)
	set FreeBSD.vfs.root.mountfrom.options=rw
}
über /boot/loader
menuentry "FreeBSD, ufs mit /boot/loader" {
	insmod ufs2
	set root=(hd0,1,a)  (oder (hd0,1)?)
	kfreebsd /boot/loader
}

FreeBSD Chainloader

Fixit# gpart bootcode -b /mnt2/boot/pmbr ad0
Chainloading pmbr von seperater Festplatte (hd0=ad0) funktioniert:

menuentry "FreeBSD 8.1" {
	set root=(hd0)
	chainloader +1
}

(nicht getestet):

Fixit# gpart bootcode -p /mnt2/boot/gptzfsboot -i 3 adx

menuentry "FreeBSD 8.1" {
	set root=(hd0,3)
	chainloader +1
}

Script (WIP)

Passend als kleines Tool das auf der separaten Partition Platz findet. Aufzurufen in der Fixit-Umgebung.

Gebrauch auf eigene Gefahr! Wird noch getestet

install.sh

#!/bin/sh

#FreeBSD
#May not set OSRELEASE and ARCH manually
OSRELEASE=`sysctl -n kern.osrelease`
ARCH=`sysctl -n hw.machine_arch`
ZPOOL='zpool'

PREFIX='FreeBSD' # or system or PCBSD or whatever you like, must reside on ${ZPOOL}
PREFIXSET=${ZPOOL}/${PREFIX}
PREFIXDIR=/${ZPOOL}/${PREFIX}

# Persistent data across several installations, replace ${ZPOOL} in PERSISTENT{SET&DIR} with ${PREFIXSET} or ${PREFIXSET} in INSTALL{SET&DIR} with ${ZPOOL} if you like.
PERSISTENT='data'
PERSISTENTSET=${ZPOOL}/${PERSISTENT}
PERSISTENTDIR=/${ZPOOL}/${PERSISTENT}
INSTALL=${OSRELEASE}-${ARCH}
INSTALLSET=${PREFIXSET}/${INSTALL}
INSTALLDIR=/${PREFIXSET}/${INSTALL}

#change disk
DISK='adx' 

#Grub2 boot-partition
GRUB2PARTITION='1'
GRUB2SIZE='2013'

#GPTZFSBoot freebsd-boot partition
BOOTCODEPARTITION='3'
BOOTCODESIZE='128'

#ext2 or UFS partition
BOOTPARTITION='2'
BOOTSIZE='126847' #sectors between 2048 - 129024-${BOOTCODESIZE}, max 62M=126976 sectors
BOOTLABEL='boot0'

#ZFS
ZFSPARTITION='4'
ZFSSIZE='80G' # only sector K, M, G and other gpart values
ZFSLABEL='disk0'

#SWAP
SWAPPARTITION='5'
SWAPSIZE='4G'
SWAPLABEL='swap0'

#Linuxpartition
LINUXPARTITION='6'
LINUXLABEL='linux0'



echo 'Script (stage1): GUID Partitioning ${DISK} with Grub2 or gptzfsboot support.'
echo 'Script (stage2): Install FreeBSD in ZFS dataset' ${INSTALL} 'on zfs:'${PREFIXSET}
echo 'Script (stage3): Cleanup'
echo 'Please provide a parameter(GRUB2FreeBSDZFS or GPTZFSBoot -> stage2 -> stage3) & check the source!'

case "$1" in
	'GRUB2FreeBSDZFS')
		echo "GRUB2FreeBSDZFS."
		gpart create -s GPT ${DISK}
		#Grub2 method !21686148-6449-6E6F-744E-656564454649 has to be escaped with \
		gpart add -i ${GRUB2PARTITION} -s ${GRUB2SIZE} -t \!21686148-6449-6E6F-744E-656564454649 ${DISK}
		gpart add -i ${BOOTPARTITION} -b 2048 -s ${BOOTSIZE} -t linux-data -l ${BOOTLABEL} ${DISK}
		#(optional: gpart add -i ${BOOTCODEPARTITION} -s ${BOOTCODESIZE} -t freebsd-boot ${DISK})
		gpart add -i ${ZFSPARTITION} -b 129024 -s ${ZFSSIZE} -t freebsd-zfs -l ${ZFSLABEL} ${DISK}
		gpart add -i ${SWAPPARTITION} -s ${SWAPSIZE} -t freebsd-swap -l ${SWAPLABEL} ${DISK}
		gpart add -i ${LINUXPARTITION} -t linux-data -l ${LINUXLABEL} ${DISK}
	;;
	'GPTZFSBoot')
		echo "GPTZFSBoot."
		gpart create -s GPT ${DISK}
		#GPTZFSboot
		gpart bootcode -b /mnt2/boot/pmbr ${DISK}
		#gpart add -i ${GRUB2PARTITION} -s ${GRUB2SIZE} -t \!21686148-6449-6E6F-744E-656564454649 ${DISK}
		gpart add -i ${BOOTPARTITION} -b 2048 -s ${BOOTSIZE} -t freebsd-ufs -l ${BOOTLABEL} ${DISK}
		gpart add -i ${BOOTCODEPARTITION} -s ${BOOTCODESIZE} -t freebsd-boot ${DISK}
		gpart bootcode -p /mnt2/boot/gptzfsboot -i ${BOOTCODEPARTITION} ${DISK}
		gpart add -i ${ZFSPARTITION} -b 129024 -s ${ZFSSIZE} -t freebsd-zfs -l ${ZFSLABEL} ${DISK}
		gpart add -i ${SWAPPARTITION} -s ${SWAPSIZE} -t freebsd-swap -l ${SWAPLABEL} ${DISK}
	;;
	'stage2')
# Begin of stage2

mkdir /boot/zfs
kldload /mnt2/boot/kernel/opensolaris.ko
kldload /mnt2/boot/kernel/zfs.ko

#Create or Import ${ZPOOL}
zpool import -f ${ZPOOL}
zpool create ${ZPOOL} /dev/gpt/${ZFSLABEL}
#zpool create ${ZPOOL} /dev/${DISK}p${ZFSPARTITION}

# Set defaults
zfs set checksum=fletcher4 ${ZPOOL}
#zpool set bootfs=${ZPOOL} ${ZPOOL}
#zfs set mountpoint=/${ZPOOL} ${ZPOOL}

#Create ${PREFIX} under ${ZPOOL}
zfs create ${PREFIXSET}
#Create ${PERSISTENTSET} under ${PREFIXSET}
zfs create ${PERSISTENTSET}

#Backup previous install with ${INSTALLSET}
zfs snapshots ${INSTALLSET}@backup
#Backup previous ports/src (etc vor oder nach jedem Install machen, wenn nicht schon vorhanden?)
zfs snapshots ${PERSISTENTSET}/usr/ports@backup
zfs snapshots ${PERSISTENTSET}/usr/src@backup

#Create ZFS boot environments

#structure of specific start
#boot environment specific, mountpoints will be set later to legacy and controlled with /etc/fstab
zfs create -o checksum=fletcher4				-o mountpoint=${INSTALLDIR}		${INSTALLSET}
zfs create -o compression=on	-o exec=on	-o setuid=off	-o mountpoint=${INSTALLDIR}/tmp		${INSTALLSET}/tmp
chmod 1777 ${INSTALLDIR}/tmp
zfs create							-o mountpoint=${INSTALLDIR}/usr		${INSTALLSET}/usr
zfs create 							-o mountpoint=${INSTALLDIR}/var		${INSTALLSET}/var
#structure of specific stop

#structure of persistent start
#Persistence across multiple boot environments - mountpoint will be set later to absolute path (dangerous if imported from another system, maybe set to ${PERSISTENTSET})
zfs create 							-o mountpoint=none			${PERSISTENTSET}/usr
zfs create 							-o mountpoint=${INSTALLDIR}/usr/home	${PERSISTENTSET}/usr/home
zfs create -o compression=lzjb			-o setuid=off	-o mountpoint=${INSTALLDIR}/usr/ports	${PERSISTENTSET}/usr/ports
zfs create -o compression=off   -o exec=off     -o setuid=off	-o mountpoint=${INSTALLDIR}/ports/distfiles	${PERSISTENTSET}/usr/ports/distfiles
zfs create -o compression=off   -o exec=off     -o setuid=off	-o mountpoint=${INSTALLDIR}/usr/ports/packages	${PERSISTENTSET}/usr/ports/packages-${OSRELEASE}-${ARCH}
zfs create -o compression=lzjb  -o exec=off     -o setuid=off	-o mountpoint=${INSTALLDIR}/usr/src	${PERSISTENTSET}/usr/src
zfs create -o compression=off 					-o mountpoint=${INSTALLDIR}/usr/jails	${PERSISTENTSET}/usr/jails
zfs create 							-o mountpoint=none			${PERSISTENTSET}/var
zfs create -o compression=lzjb	-o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/log	${PERSISTENTSET}/var/log
zfs create -o compression=gzip	-o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/mail	${PERSISTENTSET}/var/mail
zfs create -o compression=lzjb	-o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/www	${PERSISTENTSET}/var/www
#structure of persistent stop

#structure of specific start
#zfs create 							-o mountpoint=${INSTALLDIR}/usr/local	${INSTALLSET}/usr/local
zfs create -o compression=lzjb  -o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/crash	${INSTALLSET}/var/crash
zfs create                      -o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/db	${INSTALLSET}/var/db
zfs create -o compression=lzjb  -o exec=on	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/db/pkg	${INSTALLSET}/var/db/pkg
zfs create 			-o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/empty   ${INSTALLSET}/var/empty
zfs create                      -o exec=off	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/run	${INSTALLSET}/var/run
zfs create -o compression=lzjb	-o exec=on	-o setuid=off	-o mountpoint=${INSTALLDIR}/var/tmp	${INSTALLSET}/var/tmp
chmod 1777 ${INSTALLDIR}/var/tmp
cd ${INSTALLDIR} ; ln -s /usr/home home
#structure of specific stop


zfs umount -a
#Setting persistent mountpoints from previous installations, after installation set back with Stage3 to /
zfs set mountpoint=${INSTALLDIR}/usr/home 		${PERSISTENTSET}/usr/home
zfs set mountpoint=${INSTALLDIR}/usr/ports 		${PERSISTENTSET}/usr/ports
zfs set mountpoint=${INSTALLDIR}/usr/ports/distfiles 	${PERSISTENTSET}/usr/ports/distfiles
zfs set mountpoint=${INSTALLDIR}/usr/ports/packages 	${PERSISTENTSET}/usr/ports/packages-${OSRELEASE}-${ARCH}
zfs set mountpoint=${INSTALLDIR}/usr/src 		${PERSISTENTSET}/usr/src
zfs set mountpoint=${INSTALLDIR}/usr/jails 		${PERSISTENTSET}/usr/jails
zfs set mountpoint=${INSTALLDIR}/var/log 		${PERSISTENTSET}/var/log
zfs set mountpoint=${INSTALLDIR}/var/mail 		${PERSISTENTSET}/var/mail
zfs set mountpoint=${INSTALLDIR}/var/www 		${PERSISTENTSET}/var/www
#Mount persistent into bootenvironment
zfs mount -a

#Installing

cd /dist/${OSRELEASE}
export DESTDIR=${INSTALLDIR}
for dir in base catpages dict doc games info lib32 manpages ports; \
do (cd $dir ; ./install.sh) ; done
cd src ; ./install.sh all
cd ../kernels ; ./install.sh generic
cd ${INSTALLDIR}/boot ; cp -Rlp GENERIC/* ${INSTALLDIR}/boot/kernel
zfs set readonly=on ${INSTALLSET}/var/empty

#Setting up rc.conf and loader.conf
echo 'zfs_enable="YES"' > ${INSTALLDIR}/etc/rc.conf
echo 'hostname="beastie.mydomain.local"' >> ${INSTALLDIR}/etc/rc.conf
echo 'ifconfig_re0="DHCP"' >> ${INSTALLDIR}/etc/rc.conf
echo 'keymap="german.iso"' >> ${INSTALLDIR}/etc/rc.conf
echo 'zfs_load="YES"' > ${INSTALLDIR}/boot/loader.conf
echo 'vfs.root.mountfrom="zfs:${INSTALLSET}"' >> ${INSTALLDIR}/boot/loader.conf

#Generating /etc/fstab for independent child datasets for ${INSTALLSET} and for ${PERSISTENTSET} with late option.
echo "#Device				Mountpoint		FStype	Options	Dump	Pass#" > ${INSTALLDIR}/etc/fstab
echo "#${INSTALLSET}			/			zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/tmp			/tmp			zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/usr			/usr			zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/home		/usr/home		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/ports	/usr/ports		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/ports/distfiles	/usr/ports/distfiles	zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/ports/packages-${OSRELEASE}-${ARCH}	/usr/ports/packages	zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/src		/usr/src		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/usr/jails	/usr/jails		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var			/var			zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var/crash		/var/crash		zfs	rw	1	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var/db		/var/db			zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var/db/pkg		/var/db/pkg		zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var/empty		/var/empty		zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/var/log		/var/log		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/var/mail		/var/mail		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${PERSISTENTSET}/var/www		/var/www		zfs	rw,late	0	0" >> ${INSTALLDIR}/etc/fstab
echo "${INSTALLSET}/var/tmp		/var/tmp		zfs	rw	0	0" >> ${INSTALLDIR}/etc/fstab

cp /boot/zfs/zpool.cache ${INSTALLDIR}/boot/zfs/zpool.cache
#chroot
echo 'Time to chroot into '${INSTALLDIR}' and set up the password, mail, tzsetup, etc. umount /dev and exit. Then run stage3'
#exit chroot

# End of stage2
	;;
	'stage3')
# Begin of stage3

echo 'Cleaning up mountpoints'
zfs umount -a

#May set mountpoints to / for persistent data and legacy for ${INSTALLSET}, arch or installation specific.
zfs set mountpoint=none		${ZPOOL}
zfs set mountpoint=none		${PERSISTENTSET}/usr
zfs set mountpoint=none		${PERSISTENTSET}/var
zfs set mountpoint=legacy	${INSTALLSET}
zfs set mountpoint=legacy	${INSTALLSET}/tmp
zfs set mountpoint=legacy	${INSTALLSET}/usr
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/home
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/ports
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/ports/distfiles
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/ports/packages-${OSRELEASE}-${ARCH}
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/src
zfs set mountpoint=legacy	${PERSISTENTSET}/usr/jails
zfs set mountpoint=legacy	${INSTALLSET}/var
zfs set mountpoint=legacy	${INSTALLSET}/var/crash
zfs set mountpoint=legacy	${INSTALLSET}/var/db
zfs set mountpoint=legacy	${INSTALLSET}/var/db/pkg
zfs set mountpoint=legacy	${INSTALLSET}/var/run
zfs set mountpoint=legacy	${INSTALLSET}/var/empty
zfs set mountpoint=legacy	${PERSISTENTSET}/var/log
zfs set mountpoint=legacy	${PERSISTENTSET}/var/mail
zfs set mountpoint=legacy	${PERSISTENTSET}/var/www
zfs set mountpoint=legacy	${INSTALLSET}/var/tmp

echo 'Deleting mountpoint '${ZPOOL}
rm -r /${ZPOOL}

# End of stage3
	;;
	'')
		echo "No parameter given."
	;;
	[0-9])
		echo "'$1' is a digit."
	;;
	--* | -?)
		echo "'$1' is an unknown option."
		return 1
	;;
	*)
		echo "'$1' is unknown."
	;;
esac
#EOF

Weiterführende Literatur

Titel Mit Grub2 von GPT und MBR booten
Namespace HowTo
Kategorien HowTo FreeBSD