Raspi2-3_GenImage Commit - r66:061173da65b0 · Collaboration Tremplin des Sciences

Added ENABLE_SPLITFS option to produce distinct /boot/firmware and root images

Vincent Knecht -

r66:061173da65b0

parent child

Context file:

r66:061173da65b0

Collapse all files

.gitignore created 644 +3 0

@@ -0,0 +1,3
	1	images
	2	custom.d
	3	*.swp

bootstrap.d/10-bootstrap.sh created 644 +27 0

@@ -0,0 +1,27
	1	#
	2	# Debootstrap basic system
	3	#
	4
	5	. ./functions.sh
	6
	7	# Base debootstrap (unpack only)
	8	if [ "$ENABLE_MINBASE" = true ] ; then
	9	http_proxy=${APT_PROXY} debootstrap --arch=armhf --variant=minbase --foreign --include=${APT_INCLUDES} $RELEASE $R http://${APT_SERVER}/debian
	10	else
	11	http_proxy=${APT_PROXY} debootstrap --arch=armhf --foreign --include=${APT_INCLUDES} $RELEASE $R http://${APT_SERVER}/debian
	12	fi
	13
	14	# Copy qemu emulator binary to chroot
	15	cp /usr/bin/qemu-arm-static $R/usr/bin
	16
	17	# Copy debian-archive-keyring.pgp
	18	mkdir -p $R/usr/share/keyrings
	19	cp /usr/share/keyrings/debian-archive-keyring.gpg $R/usr/share/keyrings/debian-archive-keyring.gpg
	20
	21	# Complete the bootstrapping process
	22	chroot_exec /debootstrap/debootstrap --second-stage
	23
	24	# Mount required filesystems
	25	mount -t proc none $R/proc
	26	mount -t sysfs none $R/sys
	27	mount --bind /dev/pts $R/dev/pts

bootstrap.d/11-apt.sh created 644 +40 0

@@ -0,0 +1,40
	1	#
	2	# Setup APT repositories
	3	#
	4
	5	. ./functions.sh
	6
	7	# Use proxy inside chroot
	8	if [ -z "$APT_PROXY" ] ; then
	9	echo "Acquire::http::Proxy \"$APT_PROXY\";" >> $R/etc/apt/apt.conf.d/10proxy
	10	fi
	11
	12	# Pin package flash-kernel to repositories.collabora.co.uk
	13	cat <<EOM >$R/etc/apt/preferences.d/flash-kernel
	14	Package: flash-kernel
	15	Pin: origin repositories.collabora.co.uk
	16	Pin-Priority: 1000
	17	EOM
	18
	19	# Upgrade collabora package index and install collabora keyring
	20	echo "deb https://repositories.collabora.co.uk/debian ${RELEASE} rpi2" >$R/etc/apt/sources.list
	21	chroot_exec apt-get -qq -y update
	22	chroot_exec apt-get -qq -y --force-yes install collabora-obs-archive-keyring
	23
	24	# Set up initial sources.list
	25	cat <<EOM >$R/etc/apt/sources.list
	26	deb http://${APT_SERVER}/debian ${RELEASE} main contrib
	27	#deb-src http://${APT_SERVER}/debian ${RELEASE} main contrib
	28
	29	deb http://${APT_SERVER}/debian/ ${RELEASE}-updates main contrib
	30	#deb-src http://${APT_SERVER}/debian/ ${RELEASE}-updates main contrib
	31
	32	deb http://security.debian.org/ ${RELEASE}/updates main contrib
	33	#deb-src http://security.debian.org/ ${RELEASE}/updates main contrib
	34
	35	deb https://repositories.collabora.co.uk/debian ${RELEASE} rpi2
	36	EOM
	37
	38	# Upgrade package index and update all installed packages and changed dependencies
	39	chroot_exec apt-get -qq -y update
	40	chroot_exec apt-get -qq -y -u dist-upgrade

bootstrap.d/12-locale.sh created 644 +52 0

@@ -0,0 +1,52
	1	#
	2	# Setup locales and keyboard settings
	3	#
	4
	5	. ./functions.sh
	6
	7	# Set up timezone
	8	echo ${TIMEZONE} >$R/etc/timezone
	9	chroot_exec dpkg-reconfigure -f noninteractive tzdata
	10
	11	# Set up default locale and keyboard configuration
	12	if [ "$ENABLE_MINBASE" = false ] ; then
	13	# Set locale choice in debconf db, even though dpkg-reconfigure ignores and overwrites them due to some bug
	14	# https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=684134 https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=685957
	15	# ... so we have to set locales manually
	16	if [ "$DEFLOCAL" = "en_US.UTF-8" ] ; then
	17	chroot_exec echo "locales locales/locales_to_be_generated multiselect ${DEFLOCAL} UTF-8" \| debconf-set-selections
	18	else
	19	# en_US.UTF-8 should be available anyway : https://www.debian.org/doc/manuals/debian-reference/ch08.en.html#_the_reconfiguration_of_the_locale
	20	chroot_exec echo "locales locales/locales_to_be_generated multiselect en_US.UTF-8 UTF-8, ${DEFLOCAL} UTF-8" \| debconf-set-selections
	21	chroot_exec sed -i "/en_US.UTF-8/s/^#//" /etc/locale.gen
	22	fi
	23	chroot_exec sed -i "/${DEFLOCAL}/s/^#//" /etc/locale.gen
	24	chroot_exec echo "locales locales/default_environment_locale select ${DEFLOCAL}" \| debconf-set-selections
	25	chroot_exec locale-gen
	26	chroot_exec update-locale LANG=${DEFLOCAL}
	27
	28	# Keyboard configuration, if requested
	29	if [ "$XKBMODEL" != "" ] ; then
	30	chroot_exec sed -i "s/^XKBMODEL.*/XKBMODEL=\"${XKBMODEL}\"/" /etc/default/keyboard
	31	fi
	32	if [ "$XKBLAYOUT" != "" ] ; then
	33	chroot_exec sed -i "s/^XKBLAYOUT.*/XKBLAYOUT=\"${XKBLAYOUT}\"/" /etc/default/keyboard
	34	fi
	35	if [ "$XKBVARIANT" != "" ] ; then
	36	chroot_exec sed -i "s/^XKBVARIANT.*/XKBVARIANT=\"${XKBVARIANT}\"/" /etc/default/keyboard
	37	fi
	38	if [ "$XKBOPTIONS" != "" ] ; then
	39	chroot_exec sed -i "s/^XKBOPTIONS.*/XKBOPTIONS=\"${XKBOPTIONS}\"/" /etc/default/keyboard
	40	fi
	41	chroot_exec dpkg-reconfigure -f noninteractive keyboard-configuration
	42	# Set up font console
	43	case "${DEFLOCAL}" in
	44	*UTF-8)
	45	chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="UTF-8"/' /etc/default/console-setup
	46	;;
	47	*)
	48	chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="guess"/' /etc/default/console-setup
	49	;;
	50	esac
	51	chroot_exec dpkg-reconfigure -f noninteractive console-setup
	52	fi

bootstrap.d/13-kernel.sh created 644 +109 0

@@ -0,0 +1,109
	1	#
	2	# Kernel installation
	3	#
	4
	5	. ./functions.sh
	6
	7	# Fetch and build latest raspberry kernel
	8	if [ "$BUILD_KERNEL" = true ] ; then
	9	# Fetch current raspberrypi kernel sources
	10	git -C $R/usr/local/src clone --depth=1 https://github.com/raspberrypi/linux
	11
	12	# Load default raspberry kernel configuration
	13	make -C $R/usr/local/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- bcm2709_defconfig
	14
	15	# Cross compile kernel and modules
	16	make -C $R/usr/local/src/linux -j$(grep -c processor /proc/cpuinfo) ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- zImage modules dtbs
	17
	18	# Install kernel modules
	19	make -C $R/usr/local/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- INSTALL_MOD_PATH=../.. modules_install
	20
	21	# Install kernel headers
	22	if [ "$KERNEL_HEADERS" = true ]; then
	23	make -C $R/usr/local/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- INSTALL_HDR_PATH=../../usr headers_install
	24	fi
	25
	26	# Copy and rename compiled kernel to boot directory
	27	mkdir $R/boot/firmware/
	28	$R/usr/local/src/linux/scripts/mkknlimg $R/usr/local/src/linux/arch/arm/boot/zImage $R/boot/firmware/kernel7.img
	29
	30	# Copy dts and dtb device definitions
	31	mkdir $R/boot/firmware/overlays/
	32	cp $R/usr/local/src/linux/arch/arm/boot/dts/*.dtb $R/boot/firmware/
	33	cp $R/usr/local/src/linux/arch/arm/boot/dts/overlays/.dtb $R/boot/firmware/overlays/
	34	cp $R/usr/local/src/linux/arch/arm/boot/dts/overlays/README $R/boot/firmware/overlays/
	35
	36	# Install raspberry bootloader and flash-kernel
	37	chroot_exec apt-get -qq -y --no-install-recommends install raspberrypi-bootloader-nokernel
	38	else
	39	# Kernel installation
	40	chroot_exec apt-get -qq -y --no-install-recommends install linux-image-${KERNEL} raspberrypi-bootloader-nokernel
	41
	42	# Install flash-kernel last so it doesn't try (and fail) to detect the platform in the chroot
	43	chroot_exec apt-get -qq -y install flash-kernel
	44
	45	VMLINUZ="$(ls -1 $R/boot/vmlinuz-* \| sort \| tail -n 1)"
	46	[ -z "$VMLINUZ" ] && exit 1
	47	cp $VMLINUZ $R/boot/firmware/kernel7.img
	48	fi
	49
	50	# Set up firmware boot cmdline
	51	if [ "$ENABLE_SPLITFS" = true ] ; then
	52	CMDLINE="dwc_otg.lpm_enable=0 root=/dev/sda1 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1 ${CMDLINE}"
	53	else
	54	CMDLINE="dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1 ${CMDLINE}"
	55	fi
	56
	57	# Set up serial console support (if requested)
	58	if [ "$ENABLE_CONSOLE" = true ] ; then
	59	CMDLINE="${CMDLINE} console=ttyAMA0,115200 kgdboc=ttyAMA0,115200"
	60	fi
	61
	62	# Set up IPv6 networking support
	63	if [ "$ENABLE_IPV6" = false ] ; then
	64	CMDLINE="${CMDLINE} ipv6.disable=1"
	65	fi
	66
	67	echo "${CMDLINE}" >$R/boot/firmware/cmdline.txt
	68
	69	# Set up firmware config
	70	install -o root -g root -m 644 files/config.txt $R/boot/firmware/config.txt
	71
	72	# Load snd_bcm2835 kernel module at boot time
	73	if [ "$ENABLE_SOUND" = true ] ; then
	74	echo "snd_bcm2835" >>$R/etc/modules
	75	fi
	76
	77	# Set smallest possible GPU memory allocation size: 16MB (no X)
	78	if [ "$ENABLE_MINGPU" = true ] ; then
	79	echo "gpu_mem=16" >>$R/boot/firmware/config.txt
	80	fi
	81
	82	# Create symlinks
	83	ln -sf firmware/config.txt $R/boot/config.txt
	84	ln -sf firmware/cmdline.txt $R/boot/cmdline.txt
	85
	86	# Prepare modules-load.d directory
	87	mkdir -p $R/lib/modules-load.d/
	88
	89	# Load random module on boot
	90	if [ "$ENABLE_HWRANDOM" = true ] ; then
	91	cat <<EOM >$R/lib/modules-load.d/rpi2.conf
	92	bcm2708_rng
	93	EOM
	94	fi
	95
	96	# Prepare modprobe.d directory
	97	mkdir -p $R/etc/modprobe.d/
	98
	99	# Blacklist sound modules
	100	install -o root -g root -m 644 files/modprobe.d/raspi-blacklist.conf $R/etc/modprobe.d/raspi-blacklist.conf
	101
	102	# Create default fstab
	103	install -o root -g root -m 644 files/fstab $R/etc/fstab
	104	if [ "$ENABLE_SPLITFS" = true ] ; then
	105	sed -i 's/mmcblk0p2/sda1/' $R/etc/fstab
	106	fi
	107
	108	# Avoid swapping and increase cache sizes
	109	install -o root -g root -m 644 files/sysctl.d/81-rpi-vm.conf $R/etc/sysctl.d/81-rpi-vm.conf

bootstrap.d/20-networking.sh created 644 +78 0

@@ -0,0 +1,78
	1	#
	2	# Setup networking
	3	#
	4
	5	. ./functions.sh
	6
	7	# Set up IPv4 hosts
	8	echo ${HOSTNAME} >$R/etc/hostname
	9	cat <<EOM >$R/etc/hosts
	10	127.0.0.1 localhost
	11	127.0.1.1 ${HOSTNAME}
	12	EOM
	13
	14	if [ "$NET_ADDRESS" != "" ] ; then
	15	NET_IP=$(echo ${NET_ADDRESS} \| cut -f 1 -d'/')
	16	sed -i "s/^127.0.1.1/${NET_IP}/" $R/etc/hosts
	17	fi
	18
	19	# Set up IPv6 hosts
	20	if [ "$ENABLE_IPV6" = true ] ; then
	21	cat <<EOM >>$R/etc/hosts
	22
	23	::1 localhost ip6-localhost ip6-loopback
	24	ff02::1 ip6-allnodes
	25	ff02::2 ip6-allrouters
	26	EOM
	27	fi
	28
	29	# Place hint about network configuration
	30	cat <<EOM >$R/etc/network/interfaces
	31	# Debian switched to systemd-networkd configuration files.
	32	# please configure your networks in '/etc/systemd/network/'
	33	source /etc/interfaces.d/*.conf
	34	EOM
	35
	36	if [ "$ENABLE_DHCP" = true ] ; then
	37	# Enable systemd-networkd DHCP configuration for interface eth0
	38	cat <<EOM >$R/etc/systemd/network/eth.network
	39	[Match]
	40	Name=eth0
	41
	42	[Network]
	43	DHCP=yes
	44	EOM
	45
	46	# Set DHCP configuration to IPv4 only
	47	if [ "$ENABLE_IPV6" = false ] ; then
	48	sed -i "s/^DHCP=yes/DHCP=v4/" $R/etc/systemd/network/eth.network
	49	fi
	50	else # ENABLE_DHCP=false
	51	cat <<EOM >$R/etc/systemd/network/eth.network
	52	[Match]
	53	Name=eth0
	54
	55	[Network]
	56	DHCP=no
	57	Address=${NET_ADDRESS}
	58	Gateway=${NET_GATEWAY}
	59	DNS=${NET_DNS_1}
	60	DNS=${NET_DNS_2}
	61	Domains=${NET_DNS_DOMAINS}
	62	NTP=${NET_NTP_1}
	63	NTP=${NET_NTP_2}
	64	EOM
	65	fi
	66
	67	# Enable systemd-networkd service
	68	chroot_exec systemctl enable systemd-networkd
	69
	70	# Enable network stack hardening
	71	if [ "$ENABLE_HARDNET" = true ] ; then
	72	install -o root -g root -m 644 files/sysctl.d/82-rpi-net-hardening.conf $R/etc/sysctl.d/82-rpi-net-hardening.conf
	73
	74	# Enable resolver warnings about spoofed addresses
	75	cat <<EOM >>$R/etc/host.conf
	76	spoof warn
	77	EOM
	78	fi

bootstrap.d/21-firewall.sh created 644 +43 0

@@ -0,0 +1,43
	1	#
	2	# Enable firewall based on iptables started by systemd service
	3	#
	4
	5	. ./functions.sh
	6
	7	if [ "$ENABLE_IPTABLES" = true ] ; then
	8	# Create iptables configuration directory
	9	mkdir -p "$R/etc/iptables"
	10
	11	# Create iptables systemd service
	12	install -o root -g root -m 644 files/iptables/iptables.service $R/etc/systemd/system/iptables.service
	13
	14	# Create flush-table script called by iptables service
	15	install -o root -g root -m 755 files/iptables/flush-iptables.sh $R/etc/iptables/flush-iptables.sh
	16
	17	# Create iptables rule file
	18	install -o root -g root -m 644 files/iptables/iptables.rules $R/etc/iptables/iptables.rules
	19
	20	# Reload systemd configuration and enable iptables service
	21	chroot_exec systemctl daemon-reload
	22	chroot_exec systemctl enable iptables.service
	23
	24	if [ "$ENABLE_IPV6" = true ] ; then
	25	# Create ip6tables systemd service
	26	install -o root -g root -m 644 files/iptables/ip6tables.service $R/etc/systemd/system/ip6tables.service
	27
	28	# Create ip6tables file
	29	install -o root -g root -m 755 files/iptables/flush-ip6tables.sh $R/etc/iptables/flush-ip6tables.sh
	30
	31	install -o root -g root -m 644 files/iptables/ip6tables.rules $R/etc/iptables/ip6tables.rules
	32
	33	# Reload systemd configuration and enable iptables service
	34	chroot_exec systemctl daemon-reload
	35	chroot_exec systemctl enable ip6tables.service
	36	fi
	37	fi
	38
	39	# Remove SSHD related iptables rules
	40	if [ "$ENABLE_SSHD" = false ] ; then
	41	sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/iptables.rules 2> /dev/null
	42	sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/ip6tables.rules 2> /dev/null
	43	fi

bootstrap.d/30-security.sh created 644 +30 0

@@ -0,0 +1,30
	1	#
	2	# Setup users and security settings
	3	#
	4
	5	. ./functions.sh
	6
	7	# Generate crypt(3) password string
	8	ENCRYPTED_PASSWORD=`mkpasswd -m sha-512 ${PASSWORD}`
	9
	10	# Set up default user
	11	if [ "$ENABLE_USER" = true ] ; then
	12	chroot_exec adduser --gecos pi --add_extra_groups --disabled-password pi
	13	chroot_exec usermod -a -G sudo -p "${ENCRYPTED_PASSWORD}" pi
	14	fi
	15
	16	# Set up root password or not
	17	if [ "$ENABLE_ROOT" = true ]; then
	18	chroot_exec usermod -p "${ENCRYPTED_PASSWORD}" root
	19
	20	if [ "$ENABLE_ROOT_SSH" = true ]; then
	21	sed -i 's\|[#]PermitRootLogin.\|PermitRootLogin yes\|g' $R/etc/ssh/sshd_config
	22	fi
	23	else
	24	chroot_exec usermod -p \'!\' root
	25	fi
	26
	27	# Enable serial console systemd style
	28	if [ "$ENABLE_CONSOLE" = true ] ; then
	29	chroot_exec systemctl enable serial-getty\@ttyAMA0.service
	30	fi

bootstrap.d/31-logging.sh created 644 +12 0

@@ -0,0 +1,12
	1	#
	2	# Setup logging
	3	#
	4
	5	. ./functions.sh
	6
	7	# Disable rsyslog
	8	if [ "$ENABLE_RSYSLOG" = false ]; then
	9	sed -i 's\|[#]*ForwardToSyslog=yes\|ForwardToSyslog=no\|g' $R/etc/systemd/journald.conf
	10	chroot_exec systemctl disable rsyslog
	11	chroot_exec apt-get purge -q -y --force-yes rsyslog
	12	fi

bootstrap.d/41-uboot.sh created 644 +44 0

@@ -0,0 +1,44
	1	#
	2	# Setup Uboot
	3	#
	4
	5	. ./functions.sh
	6
	7	# Install gcc/c++ build environment inside the chroot
	8	if [ "$ENABLE_UBOOT" = true ] \|\| [ "$ENABLE_FBTURBO" = true ]; then
	9	chroot_exec apt-get install -q -y --force-yes --no-install-recommends linux-compiler-gcc-4.9-arm g++ make bc
	10	fi
	11
	12	# Fetch and build U-Boot bootloader
	13	if [ "$ENABLE_UBOOT" = true ] ; then
	14	# Fetch U-Boot bootloader sources
	15	git -C $R/tmp clone git://git.denx.de/u-boot.git
	16
	17	# Build and install U-Boot inside chroot
	18	chroot_exec make -C /tmp/u-boot/ rpi_2_defconfig all
	19
	20	# Copy compiled bootloader binary and set config.txt to load it
	21	cp $R/tmp/u-boot/u-boot.bin $R/boot/firmware/
	22	printf "\n# boot u-boot kernel\nkernel=u-boot.bin\n" >> $R/boot/firmware/config.txt
	23
	24	# Set U-Boot command file
	25	cat <<EOM >$R/boot/firmware/uboot.mkimage
	26	# Tell Linux that it is booting on a Raspberry Pi2
	27	setenv machid 0x00000c42
	28
	29	# Set the kernel boot command line
	30	setenv bootargs "earlyprintk ${CMDLINE}"
	31
	32	# Save these changes to u-boot's environment
	33	saveenv
	34
	35	# Load the existing Linux kernel into RAM
	36	fatload mmc 0:1 \${kernel_addr_r} kernel7.img
	37
	38	# Boot the kernel we have just loaded
	39	bootz \${kernel_addr_r}
	40	EOM
	41
	42	# Generate U-Boot image from command file
	43	chroot_exec mkimage -A arm -O linux -T script -C none -a 0x00000000 -e 0x00000000 -n "RPi2 Boot Script" -d /boot/firmware/uboot.mkimage /boot/firmware/boot.scr
	44	fi

bootstrap.d/42-fbturbo.sh created 644 +34 0

@@ -0,0 +1,34
	1	#
	2	# Fetch and build fbturbo Xorg driver
	3	#
	4
	5	. ./functions.sh
	6
	7	if [ "$ENABLE_FBTURBO" = true ] ; then
	8	# Fetch fbturbo driver sources
	9	git -C $R/tmp clone https://github.com/ssvb/xf86-video-fbturbo.git
	10
	11	# Install Xorg build dependencies
	12	chroot_exec apt-get install -q -y --no-install-recommends xorg-dev xutils-dev x11proto-dri2-dev libltdl-dev libtool automake libdrm-dev
	13
	14	# Build and install fbturbo driver inside chroot
	15	chroot_exec /bin/bash -c "cd /tmp/xf86-video-fbturbo; autoreconf -vi; ./configure --prefix=/usr; make; make install"
	16
	17	# Add fbturbo driver to Xorg configuration
	18	cat <<EOM >$R/usr/share/X11/xorg.conf.d/99-fbturbo.conf
	19	Section "Device"
	20	Identifier "Allwinner A10/A13 FBDEV"
	21	Driver "fbturbo"
	22	Option "fbdev" "/dev/fb0"
	23	Option "SwapbuffersWait" "true"
	24	EndSection
	25	EOM
	26
	27	# Remove Xorg build dependencies
	28	chroot_exec apt-get -q -y purge --auto-remove xorg-dev xutils-dev x11proto-dri2-dev libltdl-dev libtool automake libdrm-dev
	29	fi
	30
	31	# Remove gcc/c++ build environment from the chroot
	32	if [ "$ENABLE_UBOOT" = true ] \|\| [ "$ENABLE_FBTURBO" = true ]; then
	33	chroot_exec apt-get -y -q purge --auto-remove bc binutils cpp cpp-4.9 g++ g++-4.9 gcc gcc-4.9 libasan1 libatomic1 libc-dev-bin libc6-dev libcloog-isl4 libgcc-4.9-dev libgomp1 libisl10 libmpc3 libmpfr4 libstdc++-4.9-dev libubsan0 linux-compiler-gcc-4.9-arm linux-libc-dev make
	34	fi

bootstrap.d/50-firstboot.sh created 644 +24 0

@@ -0,0 +1,24
	1	#
	2	# First boot actions
	3	#
	4
	5	. ./functions.sh
	6
	7	cat files/firstboot/10-begin.sh > $R/etc/rc.firstboot
	8
	9	# Ensure openssh server host keys are regenerated on first boot
	10	if [ "$ENABLE_SSHD" = true ] ; then
	11	cat files/firstboot/21-generate-ssh-keys.sh >> $R/etc/rc.firstboot
	12	rm -f $R/etc/ssh/ssh_host_*
	13	fi
	14
	15	if [ "$EXPANDROOT" = true ] ; then
	16	cat files/firstboot/22-expandroot.sh >> $R/etc/rc.firstboot
	17	fi
	18
	19	cat files/firstboot/99-finish.sh >> $R/etc/rc.firstboot
	20	chmod +x $R/etc/rc.firstboot
	21
	22	sed -i '/exit 0/d' $R/etc/rc.local
	23	echo /etc/rc.firstboot >> $R/etc/rc.local
	24	echo exit 0 >> $R/etc/rc.local

functions.sh created 644 +23 0

@@ -0,0 +1,23
	1	cleanup (){
	2	# Clean up all temporary mount points
	3	set +x
	4	set +e
	5	echo "killing processes using mount point ..."
	6	fuser -k $R
	7	sleep 3
	8	fuser -9 -k -v $R
	9	echo "removing temporary mount points ..."
	10	umount -l $R/proc 2> /dev/null
	11	umount -l $R/sys 2> /dev/null
	12	umount -l $R/dev/pts 2> /dev/null
	13	umount "$BUILDDIR/mount/boot/firmware" 2> /dev/null
	14	umount "$BUILDDIR/mount" 2> /dev/null
	15	losetup -d "$ROOT_LOOP" 2> /dev/null
	16	losetup -d "$FRMW_LOOP" 2> /dev/null
	17	trap - 0 1 2 3 6
	18	}
	19
	20	chroot_exec() {
	21	# Exec command in chroot
	22	LANG=C LC_ALL=C DEBIAN_FRONTEND=noninteractive chroot $R $*
	23	}

README.md +38 -1

             # rpi2-gen-image
             ## Introduction
             `rpi2-gen-image.sh` is an advanced Debian Linux bootstrapping shell script for generating Debian OS images for the Raspberry 2 (RPi2) computer. The script at this time only supports the bootstrapping of the current stable Debian 8 "jessie" release.
             ## Build dependencies
             The following list of Debian packages must be installed on the build system because they are essentially required for the bootstrapping process. The script will check if all required packages are installed and missing packages will be installed automatically if confirmed by the user.
               ```debootstrap debian-archive-keyring qemu-user-static dosfstools rsync bmap-tools whois git-core```
             ## Command-line parameters
             The script accepts certain command-line parameters to enable or disable specific OS features, services and configuration settings. These parameters are passed to the `rpi2-gen-image.sh` script via (simple) shell-variables. Unlike environment shell-variables (simple) shell-variables are defined at the beginning of the command-line call of the `rpi2-gen-image.sh` script.
             #####Command-line examples:
             ```shell
             ENABLE_UBOOT=true ./rpi2-gen-image.sh
             ENABLE_CONSOLE=false ENABLE_IPV6=false ./rpi2-gen-image.sh
             ENABLE_WM=xfce4 ENABLE_FBTURBO=true ENABLE_MINBASE=true ./rpi2-gen-image.sh
             ENABLE_HARDNET=true ENABLE_IPTABLES=true /rpi2-gen-image.sh
             APT_SERVER=ftp.de.debian.org APT_PROXY="http://127.0.0.1:3142/" ./rpi2-gen-image.sh
             ENABLE_MINBASE=true ./rpi2-gen-image.sh
              ```
             #### APT settings:
             ##### `APT_SERVER`="ftp.debian.org"
             Set Debian packages server address. Choose a server from the list of Debian worldwide [mirror sites](https://www.debian.org/mirror/list). Using a nearby server will probably speed-up all required downloads within the bootstrapping process.
             ##### `APT_PROXY`=""
             Set Proxy server address. Using a local Proxy-Cache like `apt-cacher-ng` will speed-up the bootstrapping process because all required Debian packages will only be downloaded from the Debian mirror site once.
             ##### `APT_INCLUDES`=""
             A comma seperated list of additional packages to be installed during bootstrapping.
             #### General system settings:
             ##### `HOSTNAME`="rpi2-jessie"
             Set system host name. It's recommended that the host name is unique in the corresponding subnet.
             ##### `PASSWORD`="raspberry"
             Set system `root` password. The same password is used for the created user `pi`. It's **STRONGLY** recommended that you choose a custom password.
             ##### `DEFLOCAL`="en_US.UTF-8"
             Set default system locale. This setting can also be changed inside the running OS using the `dpkg-reconfigure locales` command. The script variant `minbase` (ENABLE_MINBASE=true) doesn't install `locales`.
             ##### `TIMEZONE`="Europe/Berlin"
             Set default system timezone. All available timezones can be found in the `/usr/share/zoneinfo/` directory. This setting can also be changed inside the running OS using the `dpkg-reconfigure tzdata` command.
             ##### `EXPANDROOT`=true
             Expand the root partition and filesystem automatically on first boot.
             #### Keyboard settings:
             These options are used to configure keyboard layout in `/etc/default/keyboard` for console and Xorg. These settings can also be changed inside the running OS using the `dpkg-reconfigure keyboard-configuration` command.
             ##### `XKBMODEL`=""
             Set the name of the model of your keyboard type.
             ##### `XKBLAYOUT`=""
             Set the supported keyboard layout(s).
             ##### `XKBVARIANT`=""
             Set the supported variant(s) of the keyboard layout(s).
             ##### `XKBOPTIONS`=""
             Set extra xkb configuration options.
             #### Networking settings (DHCP)
             This setting is used to set up networking auto configuration in `/etc/systemd/network/eth.network`.
             #####`ENABLE_DHCP`=true
             Set the system to use DHCP. This requires an DHCP server.
             #### Networking settings (static)
             These settings are used to set up a static networking configuration in /etc/systemd/network/eth.network. The following static networking settings are only supported if `ENABLE_DHCP` was set to `false`.
             #####`NET_ADDRESS`=""
             Set a static IPv4 or IPv6 address and its prefix, separated by "/", eg. "192.169.0.3/24".
             #####`NET_GATEWAY`=""
             Set the IP address for the default gateway.
             #####`NET_DNS_1`=""
             Set the IP address for the first DNS server.
             #####`NET_DNS_2`=""
             Set the IP address for the second DNS server.
             #####`NET_DNS_DOMAINS`=""
             Set the default DNS search domains to use for non fully qualified host names.
             #####`NET_NTP_1`=""
             Set the IP address for the first NTP server.
             #####`NET_NTP_2`=""
             Set the IP address for the second NTP server.
             #### Basic system features:
             ##### `ENABLE_CONSOLE`=true
             Enable serial console interface. Recommended if no monitor or keyboard is connected to the RPi2. In case of problems fe. if the network (auto) configuration failed - the serial console can be used to access the system.
             ##### `ENABLE_IPV6`=true
             Enable IPv6 support. The network interface configuration is managed via systemd-networkd.
             ##### `ENABLE_SSHD`=true
             Install and enable OpenSSH service. The default configuration of the service doesn't allow `root` to login. Please use the user `pi` instead and `su -` or `sudo` to execute commands as root.
             ##### `ENABLE_RSYSLOG`=true
             If set to false, disable and uninstall rsyslog (so logs will be available only
             in journal files)
             ##### `ENABLE_SOUND`=true
             Enable sound hardware and install Advanced Linux Sound Architecture.
             ##### `ENABLE_HWRANDOM`=true
             Enable Hardware Random Number Generator. Strong random numbers are important for most network based communications that use encryption. It's recommended to be enabled.
             ##### `ENABLE_MINGPU`=false
             Minimize the amount of shared memory reserved for the GPU. It doesn't seem to be possible to fully disable the GPU.
             ##### `ENABLE_DBUS`=true
             Install and enable D-Bus message bus. Please note that systemd should work without D-bus but it's recommended to be enabled.
             ##### `ENABLE_XORG`=false
             Install Xorg open-source X Window System.
             ##### `ENABLE_WM`=""
             Install a user defined window manager for the X Window System. To make sure all X related package dependencies are getting installed `ENABLE_XORG` will automatically get enabled if `ENABLE_WM` is used. The `rpi2-gen-image.sh` script has been tested with the following list of window managers: `blackbox`, `openbox`, `fluxbox`, `jwm`, `dwm`, `xfce4`, `awesome`.
-            #### Advanced sytem features:
+            #### Advanced system features:
             ##### `ENABLE_MINBASE`=false
             Use debootstrap script variant `minbase` which only includes essential packages and apt. This will reduce the disk usage by about 65 MB.
             ##### `ENABLE_UBOOT`=false
             Replace default RPi2 second stage bootloader (bootcode.bin) with U-Boot bootloader. U-Boot can boot images via the network using the BOOTP/TFTP protocol.
             ##### `ENABLE_FBTURBO`=false
             Install and enable the hardware accelerated Xorg video driver `fbturbo`. Please note that this driver is currently limited to hardware accelerated window moving and scrolling.
             ##### `ENABLE_IPTABLES`=false
             Enable iptables IPv4/IPv6 firewall. Simplified ruleset: Allow all outgoing connections. Block all incoming connections except to OpenSSH service.
             ##### `ENABLE_USER`=true
             Create pi user with password raspberry
             ##### `ENABLE_ROOT`=true
             Set root user password so root login will be enabled
             ##### `ENABLE_ROOT_SSH`=true
             Enable password root login via SSH. May be a security risk with default
             password, use only in trusted environments.
             ##### `ENABLE_HARDNET`=false
             Enable IPv4/IPv6 network stack hardening settings.
             ##### `ENABLE_SPLITFS`=false
             Enable having root partition on an USB drive by creating two image files: one for the `/boot/firmware` mount point, and another for `/`.
             ##### `CHROOT_SCRIPTS`=""
             Path to a directory with scripts that should be run in the chroot before the image is finally built. Every executable file in this direcory is run in lexicographical order.
+            #### Kernel compilation:
+            ##### `BUILD_KERNEL`=false
+            Build and install the latest RPi2 linux kernel. Currently only the default RPi2 kernel configuration is used. Detailed configuration parameters for customizing the kernel and minor bug fixes still need to get implemented. feel free to help.
+            ##### `KERNEL_HEADERS`=true
+            If true, also install kernel headers with built kernel.
+            ## Understanding the script
+            The functions of this script that are required for the different stages of the bootstrapping are split up into single files located inside the `bootstrap.d` directory. During the bootstrapping every script in this directory gets executed in lexicographical order:
+            | Script | Description |
+            | --- | --- |
+            | `10-bootstrap.sh` | Debootstrap basic system |
+            | `11-apt.sh` | Setup APT repositories |
+            | `12-locale.sh` | Setup Locales and keyboard settings |
+            | `13-kernel.sh` | Build and install RPi2 Kernel |
+            | `20-networking.sh` | Setup Networking |
+            | `21-firewall.sh` | Setup iptables Firewall |
+            | `30-security.sh` | Setup users and security settings |
+            | `31-logging.sh` | Setup logging |
+            | `41-uboot.sh` | Build and Setup Uboot |
+            | `42-fbturbo.sh` | Buld and Setup fbturbo Xorg driver |
+            | `50-firstboot.sh` | First boot actions |
+            All the required configuration files that will be copied to the generated OS image are located inside the `files` directory. It is not recommended to modify these configuration files manually.
+            | Directory | Description |
+            | --- | --- |
+            | `boot` | Boot and RPi2 configuration files |
+            | `firstboot` | Scripts that get executed on first boot  |
+            | `iptables` | Firewall configuration files |
+            | `modprobe.d` | Kernel Module Blacklist configuration |
+            | `mount` | Fstab configuration |
+            | `network` | Networking configuration files |
+            | `sysctl.d` | Swapping and Network Hardening configuration |
+            | `xorg` | fbturbo Xorg driver configuration |
             ## Logging of the bootstrapping process
             All information related to the bootstrapping process and the commands executed by the `rpi2-gen-image.sh` script can easily be saved into a logfile. The common shell command `script` can be used for this purpose:
             ```shell
             script -c 'APT_SERVER=ftp.de.debian.org ./rpi2-gen-image.sh' ./build.log
             ```
             ## Flashing the image file
             After the image file was successfully created by the `rpi2-gen-image.sh` script it can be copied to the microSD card that will be used by the RPi2 computer. This can be performed by using the tools `bmaptool` or `dd`. Using `bmaptool` will probably speed-up the copy process because `bmaptool` copies more wisely than `dd`.
             #####Flashing examples:
             ```shell
             bmaptool copy ./images/jessie/2015-12-13-debian-jessie.img /dev/mmcblk0
             dd bs=4M if=./images/jessie/2015-12-13-debian-jessie.img of=/dev/mmcblk0
             ```
             If you have set `ENABLE_SPLITFS`, copy the `-frmw` image on the microSD card, then the `-root` one on the USB drive:
             ```shell
             bmaptool copy ./images/jessie/2015-12-13-debian-jessie-frmw.img /dev/mmcblk0
             bmaptool copy ./images/jessie/2015-12-13-debian-jessie-root.img /dev/sdc
             ```

rpi2-gen-image.sh +32 -432

             #!/bin/sh
             ########################################################################
             # rpi2-gen-image.sh					   ver2a 12/2015
             #
             # Advanced debian "jessie" bootstrap script for RPi2
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # some parts based on rpi2-build-image:
             # Copyright (C) 2015 Ryan Finnie <ryan@finnie.org>
             # Copyright (C) 2015 Luca Falavigna <dktrkranz@debian.org>
             ########################################################################
-            # Clean up all temporary mount points
+            source ./functions.sh
-            cleanup (){
-              set +x
-              set +e
-              echo "removing temporary mount points ..."
-              umount -l $R/proc 2> /dev/null
-              umount -l $R/sys 2> /dev/null
-              umount -l $R/dev/pts 2> /dev/null
-              umount "$BUILDDIR/mount/boot/firmware" 2> /dev/null
-              umount "$BUILDDIR/mount" 2> /dev/null
-              losetup -d "$ROOT_LOOP" 2> /dev/null
-              losetup -d "$FRMW_LOOP" 2> /dev/null
-              trap - 0 1 2 3 6
-            # Exec command in chroot
-            chroot_exec() {
-              LANG=C LC_ALL=C chroot $R $*
             set -e
             set -x
             # Debian release
             RELEASE=${RELEASE:=jessie}
             KERNEL=${KERNEL:=3.18.0-trunk-rpi2}
             # Build settings
-            BASEDIR=./images/${RELEASE}
+            BASEDIR=$(pwd)/images/${RELEASE}
             BUILDDIR=${BASEDIR}/build
             # General settings
             HOSTNAME=${HOSTNAME:=rpi2-${RELEASE}}
             PASSWORD=${PASSWORD:=raspberry}
             DEFLOCAL=${DEFLOCAL:="en_US.UTF-8"}
             TIMEZONE=${TIMEZONE:="Europe/Berlin"}
             XKBMODEL=${XKBMODEL:=""}
             XKBLAYOUT=${XKBLAYOUT:=""}
             XKBVARIANT=${XKBVARIANT:=""}
             XKBOPTIONS=${XKBOPTIONS:=""}
             EXPANDROOT=${EXPANDROOT:=true}
             # Network settings
             ENABLE_DHCP=${ENABLE_DHCP:=true}
             # NET_* settings are ignored when ENABLE_DHCP=true
             # NET_ADDRESS is an IPv4 or IPv6 address and its prefix, separated by "/"
             NET_ADDRESS=${NET_ADDRESS:=""}
             NET_GATEWAY=${NET_GATEWAY:=""}
             NET_DNS_1=${NET_DNS_1:=""}
             NET_DNS_2=${NET_DNS_2:=""}
             NET_DNS_DOMAINS=${NET_DNS_DOMAINS:=""}
             NET_NTP_1=${NET_NTP_1:=""}
             NET_NTP_2=${NET_NTP_2:=""}
             # APT settings
             APT_PROXY=${APT_PROXY:=""}
             APT_SERVER=${APT_SERVER:="ftp.debian.org"}
             # Feature settings
             ENABLE_CONSOLE=${ENABLE_CONSOLE:=true}
             ENABLE_IPV6=${ENABLE_IPV6:=true}
             ENABLE_SSHD=${ENABLE_SSHD:=true}
             ENABLE_SOUND=${ENABLE_SOUND:=true}
             ENABLE_DBUS=${ENABLE_DBUS:=true}
             ENABLE_HWRANDOM=${ENABLE_HWRANDOM:=true}
             ENABLE_MINGPU=${ENABLE_MINGPU:=false}
             ENABLE_XORG=${ENABLE_XORG:=false}
             ENABLE_WM=${ENABLE_WM:=""}
             ENABLE_RSYSLOG=${ENABLE_RSYSLOG:=true}
             ENABLE_USER=${ENABLE_USER:=true}
             ENABLE_ROOT=${ENABLE_ROOT:=false}
             ENABLE_ROOT_SSH=${ENABLE_ROOT_SSH:=false}
             # Advanced settings
             ENABLE_MINBASE=${ENABLE_MINBASE:=false}
             ENABLE_UBOOT=${ENABLE_UBOOT:=false}
             ENABLE_FBTURBO=${ENABLE_FBTURBO:=false}
             ENABLE_HARDNET=${ENABLE_HARDNET:=false}
             ENABLE_IPTABLES=${ENABLE_IPTABLES:=false}
             ENABLE_SPLITFS=${ENABLE_SPLITFS:=false}
+            # Kernel compilation settings
+            BUILD_KERNEL=${BUILD_KERNEL:=false}
+            KERNEL_HEADERS=${KERNEL_HEADERS:=true}
             # Image chroot path
             R=${BUILDDIR}/chroot
             CHROOT_SCRIPTS=${CHROOT_SCRIPTS:=""}
             # Packages required for bootstrapping
             REQUIRED_PACKAGES="debootstrap debian-archive-keyring qemu-user-static binfmt-support dosfstools rsync bmap-tools whois git-core"
             # Missing packages that need to be installed
             MISSING_PACKAGES=""
             # Packages required in the chroot build environment
             APT_INCLUDES=${APT_INCLUDES:=""}
             APT_INCLUDES="${APT_INCLUDES},apt-transport-https,ca-certificates,debian-archive-keyring,dialog,sudo"
             set +x
             # Are we running as root?
             if [ "$(id -u)" -ne "0" ] ; then
               echo "this script must be executed with root privileges"
               exit 1
             fi
+            # Add packages required for kernel cross compilation
+            if [ "$BUILD_KERNEL" = true ] ; then
+              REQUIRED_PACKAGES="${REQUIRED_PACKAGES} crossbuild-essential-armhf"
+            fi
             # Check if all required packages are installed
             for package in $REQUIRED_PACKAGES ; do
               if [ "`dpkg-query -W -f='${Status}' $package`" != "install ok installed" ] ; then
                 MISSING_PACKAGES="$MISSING_PACKAGES $package"
               fi
             done
             # Ask if missing packages should get installed right now
             if [ -n "$MISSING_PACKAGES" ] ; then
               echo "the following packages needed by this script are not installed:"
               echo "$MISSING_PACKAGES"
               echo -n "\ndo you want to install the missing packages right now? [y/n] "
               read confirm
               if [ "$confirm" != "y" ] ; then
                 exit 1
               fi
             fi
             # Make sure all required packages are installed
             apt-get -qq -y install ${REQUIRED_PACKAGES}
             # Don't clobber an old build
             if [ -e "$BUILDDIR" ]; then
               echo "directory $BUILDDIR already exists, not proceeding"
               exit 1
             fi
             set -x
             # Call "cleanup" function on various signals and errors
             trap cleanup 0 1 2 3 6
             # Set up chroot directory
             mkdir -p $R
             # Add required packages for the minbase installation
             if [ "$ENABLE_MINBASE" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},vim-tiny,netbase,net-tools"
             else
               APT_INCLUDES="${APT_INCLUDES},locales,keyboard-configuration,console-setup"
             fi
             # Add parted package, required to get partprobe utility
             if [ "$EXPANDROOT" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},parted"
             fi
             # Add dbus package, recommended if using systemd
             if [ "$ENABLE_DBUS" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},dbus"
             fi
             # Add iptables IPv4/IPv6 package
             if [ "$ENABLE_IPTABLES" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},iptables"
             fi
             # Add openssh server package
             if [ "$ENABLE_SSHD" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},openssh-server"
             fi
             # Add alsa-utils package
             if [ "$ENABLE_SOUND" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},alsa-utils"
             fi
             # Add rng-tools package
             if [ "$ENABLE_HWRANDOM" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},rng-tools"
             fi
             if [ "$ENABLE_USER" = true ]; then
               APT_INCLUDES="${APT_INCLUDES},sudo"
             fi
             # Add fbturbo video driver
             if [ "$ENABLE_FBTURBO" = true ] ; then
               # Enable xorg package dependencies
               ENABLE_XORG=true
             fi
             # Add user defined window manager package
             if [ -n "$ENABLE_WM" ] ; then
               APT_INCLUDES="${APT_INCLUDES},${ENABLE_WM}"
               # Enable xorg package dependencies
               ENABLE_XORG=true
             fi
             # Add xorg package
             if [ "$ENABLE_XORG" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},xorg"
             fi
-            # Base debootstrap (unpack only)
+            ## Main bootstrap
-            if [ "$ENABLE_MINBASE" = true ] ; then
+            for i in bootstrap.d/*.sh; do
-              http_proxy=${APT_PROXY} debootstrap --arch=armhf --variant=minbase --foreign --include=${APT_INCLUDES} $RELEASE $R http://${APT_SERVER}/debian
+              . $i
-            else
+            done
-              http_proxy=${APT_PROXY} debootstrap --arch=armhf --foreign --include=${APT_INCLUDES} $RELEASE $R http://${APT_SERVER}/debian
-            fi
-            # Copy qemu emulator binary to chroot
-            cp /usr/bin/qemu-arm-static $R/usr/bin
-            # Copy debian-archive-keyring.pgp
-            chroot $R mkdir -p /usr/share/keyrings
-            cp /usr/share/keyrings/debian-archive-keyring.gpg $R/usr/share/keyrings/debian-archive-keyring.gpg
-            # Complete the bootstrapping process
-            chroot $R /debootstrap/debootstrap --second-stage
-            # Mount required filesystems
-            mount -t proc none $R/proc
-            mount -t sysfs none $R/sys
-            mount --bind /dev/pts $R/dev/pts
-            # Use proxy inside chroot
-            if [ -z "$APT_PROXY" ] ; then
-              echo "Acquire::http::Proxy \"$APT_PROXY\";" >> $R/etc/apt/apt.conf.d/10proxy
-            fi
-            # Pin package flash-kernel to repositories.collabora.co.uk
-            cat <<EOM >$R/etc/apt/preferences.d/flash-kernel
-            Package: flash-kernel
-            Pin: origin repositories.collabora.co.uk
-            Pin-Priority: 1000
-            EOM
-            # Set up timezone
-            echo ${TIMEZONE} >$R/etc/timezone
-            chroot_exec dpkg-reconfigure -f noninteractive tzdata
-            # Upgrade collabora package index and install collabora keyring
-            echo "deb https://repositories.collabora.co.uk/debian ${RELEASE} rpi2" >$R/etc/apt/sources.list
-            chroot_exec apt-get -qq -y update
-            chroot_exec apt-get -qq -y --force-yes install collabora-obs-archive-keyring
-            # Set up initial sources.list
-            cat <<EOM >$R/etc/apt/sources.list
-            deb http://${APT_SERVER}/debian ${RELEASE} main contrib
-            #deb-src http://${APT_SERVER}/debian ${RELEASE} main contrib
-            deb http://${APT_SERVER}/debian/ ${RELEASE}-updates main contrib
-            #deb-src http://${APT_SERVER}/debian/ ${RELEASE}-updates main contrib
-            deb http://security.debian.org/ ${RELEASE}/updates main contrib
-            #deb-src http://security.debian.org/ ${RELEASE}/updates main contrib
-            deb https://repositories.collabora.co.uk/debian ${RELEASE} rpi2
-            EOM
-            # Upgrade package index and update all installed packages and changed dependencies
-            chroot_exec apt-get -qq -y update
-            chroot_exec apt-get -qq -y -u dist-upgrade
-            # Set up default locale and keyboard configuration
-            if [ "$ENABLE_MINBASE" = false ] ; then
-              # Set locale choice in debconf db, even though dpkg-reconfigure ignores and overwrites them due to some bug
-              # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=684134 https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=685957
-              # ... so we have to set locales manually
-              if [ "$DEFLOCAL" = "en_US.UTF-8" ] ; then
-                chroot_exec echo "locales locales/locales_to_be_generated multiselect ${DEFLOCAL} UTF-8" | debconf-set-selections
-              else
-                # en_US.UTF-8 should be available anyway : https://www.debian.org/doc/manuals/debian-reference/ch08.en.html#_the_reconfiguration_of_the_locale
-                chroot_exec echo "locales locales/locales_to_be_generated multiselect en_US.UTF-8 UTF-8, ${DEFLOCAL} UTF-8" | debconf-set-selections
-                chroot_exec sed -i "/en_US.UTF-8/s/^#//" /etc/locale.gen
-              fi
-              chroot_exec sed -i "/${DEFLOCAL}/s/^#//" /etc/locale.gen
-              chroot_exec echo "locales locales/default_environment_locale select ${DEFLOCAL}" | debconf-set-selections
-              chroot_exec locale-gen
-              chroot_exec update-locale LANG=${DEFLOCAL}
-              # Keyboard configuration, if requested
-              if [ "$XKBMODEL" != "" ] ; then
-                chroot_exec sed -i "s/^XKBMODEL.*/XKBMODEL=\"${XKBMODEL}\"/" /etc/default/keyboard
-              fi
-              if [ "$XKBLAYOUT" != "" ] ; then
-                chroot_exec sed -i "s/^XKBLAYOUT.*/XKBLAYOUT=\"${XKBLAYOUT}\"/" /etc/default/keyboard
-              fi
-              if [ "$XKBVARIANT" != "" ] ; then
-                chroot_exec sed -i "s/^XKBVARIANT.*/XKBVARIANT=\"${XKBVARIANT}\"/" /etc/default/keyboard
-              fi
-              if [ "$XKBOPTIONS" != "" ] ; then
-                chroot_exec sed -i "s/^XKBOPTIONS.*/XKBOPTIONS=\"${XKBOPTIONS}\"/" /etc/default/keyboard
-              fi
-              chroot_exec dpkg-reconfigure -f noninteractive keyboard-configuration
-              # Set up font console
-              case "${DEFLOCAL}" in
-                *UTF-8)
-                  chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="UTF-8"/' /etc/default/console-setup
-                  ;;
-                *)
-                  chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="guess"/' /etc/default/console-setup
-                  ;;
-              esac
-              chroot_exec dpkg-reconfigure -f noninteractive console-setup
-            fi
-            # Kernel installation
-            # Install flash-kernel last so it doesn't try (and fail) to detect the platform in the chroot
-            chroot_exec apt-get -qq -y --no-install-recommends install linux-image-${KERNEL} raspberrypi-bootloader-nokernel
-            chroot_exec apt-get -qq -y install flash-kernel
-            VMLINUZ="$(ls -1 $R/boot/vmlinuz-* | sort | tail -n 1)"
-            [ -z "$VMLINUZ" ] && exit 1
-            cp $VMLINUZ $R/boot/firmware/kernel7.img
-            # Set up IPv4 hosts
-            echo ${HOSTNAME} >$R/etc/hostname
-            cat <<EOM >$R/etc/hosts
-.0.0.1       localhost
-.0.1.1       ${HOSTNAME}
-            EOM
-            if [ "$NET_ADDRESS" != "" ] ; then
-            NET_IP=$(echo ${NET_ADDRESS} | cut -f 1 -d'/')
-            sed -i "s/^127.0.1.1/${NET_IP}/" $R/etc/hosts
-            fi
-            # Set up IPv6 hosts
-            if [ "$ENABLE_IPV6" = true ] ; then
-            cat <<EOM >>$R/etc/hosts
-            ::1             localhost ip6-localhost ip6-loopback
-            ff02::1         ip6-allnodes
-            ff02::2         ip6-allrouters
-            EOM
-            fi
-            # Place hint about network configuration
-            cat <<EOM >$R/etc/network/interfaces
-            # Debian switched to systemd-networkd configuration files.
-            # please configure your networks in '/etc/systemd/network/'
-            EOM
-            if [ "$ENABLE_DHCP" = true ] ; then
-            # Enable systemd-networkd DHCP configuration for interface eth0
-            cat <<EOM >$R/etc/systemd/network/eth.network
-            [Match]
-            Name=eth0
-            [Network]
-            DHCP=yes
-            EOM
-            # Set DHCP configuration to IPv4 only
-            if [ "$ENABLE_IPV6" = false ] ; then
-              sed -i "s/^DHCP=yes/DHCP=v4/" $R/etc/systemd/network/eth.network
-            fi
-            else # ENABLE_DHCP=false
-            cat <<EOM >$R/etc/systemd/network/eth.network
-            [Match]
-            Name=eth0
-            [Network]
-            DHCP=no
-            Address=${NET_ADDRESS}
-            Gateway=${NET_GATEWAY}
-            DNS=${NET_DNS_1}
-            DNS=${NET_DNS_2}
-            Domains=${NET_DNS_DOMAINS}
-            NTP=${NET_NTP_1}
-            NTP=${NET_NTP_2}
-            EOM
-            fi
-            # Enable systemd-networkd service
-            chroot_exec systemctl enable systemd-networkd
-            # Generate crypt(3) password string
-            ENCRYPTED_PASSWORD=`mkpasswd -m sha-512 ${PASSWORD}`
-            # Set up default user
-            if [ "$ENABLE_USER" = true ] ; then
-              chroot_exec adduser --gecos pi --add_extra_groups --disabled-password pi
-              chroot_exec usermod -a -G sudo -p "${ENCRYPTED_PASSWORD}" pi
-            fi
-            # Set up root password or not
-            if [ "$ENABLE_ROOT" = true ]; then
-              chroot_exec usermod -p "${ENCRYPTED_PASSWORD}" root
-              if [ "$ENABLE_ROOT_SSH" = true ]; then
-                sed -i 's|[#]*PermitRootLogin.*|PermitRootLogin yes|g' $R/etc/ssh/sshd_config
-              fi
-            else
-              chroot_exec usermod -p \'!\' root
-            fi
-            # Set up firmware boot cmdline
-            if [ "$ENABLE_SPLITFS" = true ] ; then
-              CMDLINE="dwc_otg.lpm_enable=0 root=/dev/sda1 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1"
-            else
-              CMDLINE="dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1"
-            fi
-            # Set up serial console support (if requested)
-            if [ "$ENABLE_CONSOLE" = true ] ; then
-              CMDLINE="${CMDLINE} console=ttyAMA0,115200 kgdboc=ttyAMA0,115200"
-            fi
-            # Set up IPv6 networking support
-            if [ "$ENABLE_IPV6" = false ] ; then
-              CMDLINE="${CMDLINE} ipv6.disable=1"
-            fi
-            echo "${CMDLINE}" >$R/boot/firmware/cmdline.txt
-            # Set up firmware config
-            install -o root -g root -m 644 files/config.txt $R/boot/firmware/config.txt
-            # Load snd_bcm2835 kernel module at boot time
-            if [ "$ENABLE_SOUND" = true ] ; then
-              echo "snd_bcm2835" >>$R/etc/modules
-            fi
-            # Set smallest possible GPU memory allocation size: 16MB (no X)
-            if [ "$ENABLE_MINGPU" = true ] ; then
-              echo "gpu_mem=16" >>$R/boot/firmware/config.txt
-            fi
-            # Create symlinks
-            ln -sf firmware/config.txt $R/boot/config.txt
-            ln -sf firmware/cmdline.txt $R/boot/cmdline.txt
-            # Prepare modules-load.d directory
-            mkdir -p $R/lib/modules-load.d/
-            # Load random module on boot
-            if [ "$ENABLE_HWRANDOM" = true ] ; then
-              cat <<EOM >$R/lib/modules-load.d/rpi2.conf
-            bcm2708_rng
-            EOM
-            fi
-            # Prepare modprobe.d directory
-            mkdir -p $R/etc/modprobe.d/
-            # Blacklist sound modules
-            install -o root -g root -m 644 files/modprobe.d/raspi-blacklist.conf $R/etc/modprobe.d/raspi-blacklist.conf
-            # Create default fstab
-            install -o root -g root -m 644 files/fstab $R/etc/fstab
-            if [ "$ENABLE_SPLITFS" = true ] ; then
-              sed -i '/mmcblk0p2/sda1/' $R/etc/fstab
-            fi
-            # Avoid swapping and increase cache sizes
-            install -o root -g root -m 644 files/sysctl.d/81-rpi-vm.conf $R/etc/sysctl.d/81-rpi-vm.conf
-            # Enable network stack hardening
-            if [ "$ENABLE_HARDNET" = true ] ; then
-              install -o root -g root -m 644 files/sysctl.d/81-rpi-net-hardening.conf $R/etc/sysctl.d/81-rpi-net-hardening.conf
-            # Enable resolver warnings about spoofed addresses
-              cat <<EOM >>$R/etc/host.conf
-            spoof warn
-            EOM
-            fi
-            # First boot actions
-            cat files/firstboot/10-begin.sh > $R/etc/rc.firstboot
-            # Ensure openssh server host keys are regenerated on first boot
-            if [ "$ENABLE_SSHD" = true ] ; then
-              cat files/firstboot/21-generate-ssh-keys.sh >> $R/etc/rc.firstboot
-              rm -f $R/etc/ssh/ssh_host_*
-            fi
-            if [ "$EXPANDROOT" = true ] ; then
-              cat files/firstboot/22-expandroot.sh >> $R/etc/rc.firstboot
-            fi
-            cat files/firstboot/99-finish.sh >> $R/etc/rc.firstboot
-            chmod +x $R/etc/rc.firstboot
-            sed -i '/exit 0/d' $R/etc/rc.local
-            echo /etc/rc.firstboot >> $R/etc/rc.local
-            echo exit 0 >> $R/etc/rc.local
-            # Disable rsyslog
-            if [ "$ENABLE_RSYSLOG" = false ]; then
-              sed -i 's|[#]*ForwardToSyslog=yes|ForwardToSyslog=no|g' $R/etc/systemd/journald.conf
-              chroot_exec systemctl disable rsyslog
-              chroot_exec apt-get purge -q -y --force-yes rsyslog
-            fi
-            # Enable serial console systemd style
-            if [ "$ENABLE_CONSOLE" = true ] ; then
-              chroot_exec systemctl enable serial-getty\@ttyAMA0.service
-            fi
-            # Enable firewall based on iptables started by systemd service
-            if [ "$ENABLE_IPTABLES" = true ] ; then
-              # Create iptables configuration directory
-              mkdir -p "$R/etc/iptables"
-              # Create iptables systemd service
-              install -o root -g root -m 644 files/iptables/iptables.service $R/etc/systemd/system/iptables.service
-              # Create flush-table script called by iptables service
-              install -o root -g root -m 755 files/iptables/flush-iptables.sh $R/etc/iptables/flush-iptables.sh
-              # Create iptables rule file
-              install -o root -g root -m 644 files/iptables/iptables.rules $R/etc/iptables/iptables.rules
-              # Reload systemd configuration and enable iptables service
-              chroot_exec systemctl daemon-reload
-              chroot_exec systemctl enable iptables.service
-              if [ "$ENABLE_IPV6" = true ] ; then
-                # Create ip6tables systemd service
-                install -o root -g root -m 644 files/iptables/ip6tables.service $R/etc/systemd/system/ip6tables.service
-                # Create ip6tables file
-                install -o root -g root -m 755 files/iptables/flush-ip6tables.sh $R/etc/iptables/flush-ip6tables.sh
-                install -o root -g root -m 644 files/iptables/ip6tables.rules $R/etc/iptables/ip6tables.rules
-                # Reload systemd configuration and enable iptables service
-                chroot_exec systemctl daemon-reload
-                chroot_exec systemctl enable ip6tables.service
-              fi
-            fi
-            # Remove SSHD related iptables rules
-            if [ "$ENABLE_SSHD" = false ] ; then
-             sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/iptables.rules 2> /dev/null
-             sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/ip6tables.rules 2> /dev/null
-            fi
-            # Install gcc/c++ build environment inside the chroot
-            if [ "$ENABLE_UBOOT" = true ] || [ "$ENABLE_FBTURBO" = true ]; then
-              chroot_exec apt-get install -q -y --force-yes --no-install-recommends linux-compiler-gcc-4.9-arm g++ make bc
-            fi
-            # Fetch and build U-Boot bootloader
-            if [ "$ENABLE_UBOOT" = true ] ; then
-              # Fetch U-Boot bootloader sources
-              git -C $R/tmp clone git://git.denx.de/u-boot.git
-              # Build and install U-Boot inside chroot
-              chroot_exec make -C /tmp/u-boot/ rpi_2_defconfig all
-              # Copy compiled bootloader binary and set config.txt to load it
-              cp $R/tmp/u-boot/u-boot.bin $R/boot/firmware/
-              printf "\n# boot u-boot kernel\nkernel=u-boot.bin\n" >> $R/boot/firmware/config.txt
-              # Set U-Boot command file
-              cat <<EOM >$R/boot/firmware/uboot.mkimage
-            # Tell Linux that it is booting on a Raspberry Pi2
-            setenv machid 0x00000c42
-            # Set the kernel boot command line
-            setenv bootargs "earlyprintk ${CMDLINE}"
-            # Save these changes to u-boot's environment
-            saveenv
-            # Load the existing Linux kernel into RAM
-            fatload mmc 0:1 \${kernel_addr_r} kernel7.img
-            # Boot the kernel we have just loaded
-            bootz \${kernel_addr_r}
-            EOM
-              # Generate U-Boot image from command file
-              chroot_exec mkimage -A arm -O linux -T script -C none -a 0x00000000 -e 0x00000000 -n "RPi2 Boot Script" -d /boot/firmware/uboot.mkimage /boot/firmware/boot.scr
-            fi
-            # Fetch and build fbturbo Xorg driver
-            if [ "$ENABLE_FBTURBO" = true ] ; then
-              # Fetch fbturbo driver sources
-              git -C $R/tmp clone https://github.com/ssvb/xf86-video-fbturbo.git
-              # Install Xorg build dependencies
-              chroot_exec apt-get install -q -y --no-install-recommends xorg-dev xutils-dev x11proto-dri2-dev libltdl-dev libtool automake libdrm-dev
-              # Build and install fbturbo driver inside chroot
-              chroot_exec /bin/bash -c "cd /tmp/xf86-video-fbturbo; autoreconf -vi; ./configure --prefix=/usr; make; make install"
-              # Add fbturbo driver to Xorg configuration
-              cat <<EOM >$R/usr/share/X11/xorg.conf.d/99-fbturbo.conf
-            Section "Device"
-                    Identifier "Allwinner A10/A13 FBDEV"
-                    Driver "fbturbo"
-                    Option "fbdev" "/dev/fb0"
-                    Option "SwapbuffersWait" "true"
-            EndSection
-            EOM
-              # Remove Xorg build dependencies
-              chroot_exec apt-get -q -y purge --auto-remove xorg-dev xutils-dev x11proto-dri2-dev libltdl-dev libtool automake libdrm-dev
-            fi
-            # Remove gcc/c++ build environment from the chroot
+            ## Custom bootstrap scripts
-            if [ "$ENABLE_UBOOT" = true ] || [ "$ENABLE_FBTURBO" = true ]; then
+            if [ -d "custom.d" ]; then
-              chroot_exec apt-get -y -q purge --auto-remove bc binutils cpp cpp-4.9 g++ g++-4.9 gcc gcc-4.9 libasan1 libatomic1 libc-dev-bin libc6-dev libcloog-isl4 libgcc-4.9-dev libgomp1 libisl10 libmpc3 libmpfr4 libstdc++-4.9-dev libubsan0 linux-compiler-gcc-4.9-arm linux-libc-dev make
+              for i in custom.d/*.sh; do
+                . $i
+              done
             fi
-            # Clean cached downloads
-            chroot_exec apt-get -y clean
-            chroot_exec apt-get -y autoclean
-            chroot_exec apt-get -y autoremove
             # Invoke custom scripts
             if [ -n "${CHROOT_SCRIPTS}" ]; then
               cp -r "${CHROOT_SCRIPTS}" "${R}/chroot_scripts"
               LANG=C chroot $R bash -c 'for SCRIPT in /chroot_scripts/*; do if [ -f $SCRIPT -a -x $SCRIPT ]; then $SCRIPT; fi done;'
               rm -rf "${R}/chroot_scripts"
             fi
+            ## Cleanup
+            chroot_exec apt-get -y clean
+            chroot_exec apt-get -y autoclean
+            chroot_exec apt-get -y autoremove
             # Unmount mounted filesystems
             umount -l $R/proc
             umount -l $R/sys
             # Clean up files
             rm -f $R/etc/apt/sources.list.save
             rm -f $R/etc/resolvconf/resolv.conf.d/original
             rm -rf $R/run
             mkdir -p $R/run
             rm -f $R/etc/*-
             rm -f $R/root/.bash_history
             rm -rf $R/tmp/*
             rm -f $R/var/lib/urandom/random-seed
             [ -L $R/var/lib/dbus/machine-id ] || rm -f $R/var/lib/dbus/machine-id
             rm -f $R/etc/machine-id
             rm -fr $R/etc/apt/apt.conf.d/10proxy
+            rm -f $R/etc/resolv.conf
             # Calculate size of the chroot directory in KB
             CHROOT_SIZE=$(expr `du -s $R | awk '{ print $1 }'`)
             # Calculate the amount of needed 512 Byte sectors
             TABLE_SECTORS=$(expr 1 \* 1024 \* 1024 \/ 512)
             FRMW_SECTORS=$(expr 64 \* 1024 \* 1024 \/ 512)
             ROOT_OFFSET=$(expr ${TABLE_SECTORS} + ${FRMW_SECTORS})
             # The root partition is EXT4
             # This means more space than the actual used space of the chroot is used.
             # As overhead for journaling and reserved blocks 20% are added.
             ROOT_SECTORS=$(expr $(expr ${CHROOT_SIZE} + ${CHROOT_SIZE} \/ 100 \* 20) \* 1024 \/ 512)
             # Calculate required image size in 512 Byte sectors
             IMAGE_SECTORS=$(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} + ${ROOT_SECTORS})
             # Prepare date string for image file name
             DATE="$(date +%Y-%m-%d)"
             # Prepare image file
             if [ "$ENABLE_SPLITFS" = true ] ; then
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" bs=512 count=0 seek=${FRMW_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-root.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-root.img" bs=512 count=0 seek=${ROOT_SECTORS}
               # Write partition tables
               sfdisk -q -L -f "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${FRMW_SECTORS}, Id= c, bootable
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
               sfdisk -q -L -f "$BASEDIR/${DATE}-debian-${RELEASE}-root.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${ROOT_SECTORS}, Id=83
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
-              # Set up temporary loop devices and build filesystems
+              # Set up temporary loop devices
               FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show $BASEDIR/${DATE}-debian-${RELEASE}-frmw.img)"
               ROOT_LOOP="$(losetup -o 1M -f --show $BASEDIR/${DATE}-debian-${RELEASE}-root.img)"
             else
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}.img" bs=512 count=0 seek=${IMAGE_SECTORS}
               # Write partition table
               sfdisk -q -f "$BASEDIR/${DATE}-debian-${RELEASE}.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${FRMW_SECTORS}, Id= c, bootable
 : start=     ${ROOT_OFFSET}, size=   ${ROOT_SECTORS}, Id=83
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
-              # Set up temporary loop devices and build filesystems
+              # Set up temporary loop devices
               FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show $BASEDIR/${DATE}-debian-${RELEASE}.img)"
               ROOT_LOOP="$(losetup -o 65M -f --show $BASEDIR/${DATE}-debian-${RELEASE}.img)"
             fi
+            # Build filesystems
             mkfs.vfat "$FRMW_LOOP"
             mkfs.ext4 "$ROOT_LOOP"
             # Mount the temporary loop devices
             mkdir -p "$BUILDDIR/mount"
             mount "$ROOT_LOOP" "$BUILDDIR/mount"
             mkdir -p "$BUILDDIR/mount/boot/firmware"
             mount "$FRMW_LOOP" "$BUILDDIR/mount/boot/firmware"
             # Copy all files from the chroot to the loop device mount point directory
             rsync -a "$R/" "$BUILDDIR/mount/"
             # Unmount all temporary loop devices and mount points
             cleanup
             if [ "$ENABLE_SPLITFS" = true ] ; then
               # (optional) create block map file for "bmaptool"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}-root.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}-root.img"
               # Image was successfully created
-              echo "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} \* 512 \/ 1024)M)" ": successfully created"
+              echo "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
-              echo "$BASEDIR/${DATE}-debian-${RELEASE}-root.img ($(expr ${TABLE_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024)M)" ": successfully created"
+              echo "$BASEDIR/${DATE}-debian-${RELEASE}-root.img ($(expr ${TABLE_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
             else
               # (optional) create block map file for "bmaptool"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}.img"
               # Image was successfully created
-              echo "$BASEDIR/${DATE}-debian-${RELEASE}.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024)M)" ": successfully created"
+              echo "$BASEDIR/${DATE}-debian-${RELEASE}.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
             fi

General Comments 0

Écrire
Preview

Vous devez vous connecter pour laisser un commentaire. Se connecter maintenant

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Dépôts
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages