#!/bin/bash
# originally by Iguleder - hacked to DEATH by 01micko
# see README
# Compile fatdog style kernel [v3+ - 3.10+ recommended].

source ./build.conf || exit 1
source ./funcs.sh

setvar CWD = $(pwd)
wget --help | grep -q '\-\-show\-progress' && setvar WGET_SHOW_PROGRESS = ''-q --show-progress''
setvar WGET_OPT = "'--no-check-certificate '${WGET_SHOW_PROGRESS}"

setvar MWD = $(pwd)
setvar BUILD_LOG = "${MWD}/build.log"

proc log_msg { echo -e @ARGV ; echo -e @ARGV >> ${BUILD_LOG} ; }
proc exit_error { log_msg @ARGV  ; exit 1 ; }

for i in $@  {
	case (i) {
		clean { setvar DO_CLEAN = '1' ; break }
		auto { setvar AUTO = 'yes' ; shift }
		nopae { setvar x86_disable_pae = 'yes' ; shift } #funcs.sh
		pae {   setvar x86_enable_pae = 'yes'  ; shift } #funcs.sh
		i486 {  setvar x86_set_i486 = 'yes'    ; shift } #funcs.sh
		i686 {  setvar x86_set_i686 = 'yes'    ; shift } #funcs.sh
	}
}

if test $DO_CLEAN  {
	echo "Please wait..."
	rm -rf ./{aufs*,kernel*,build.log*,linux-*}
	echo "Cleaning complete"
	exit 0
}

## delete the previous log
test -f build.log && rm -f build.log
test -f build.log.tar.bz2 && mv -f build.log.${today}.tar.bz2

## Dependency check...
for app in git gcc make  {
	$app --version &>/dev/null || exit_error "\033[1;31m""$app is not installed""\033[0m"
}
which mksquashfs &>/dev/null || exit_error "\033[1;30m""mksquashfs is not installed""\033[0m"
log_ver #funcs.sh
which cc &>/dev/null || ln -sv $(which gcc) /usr/bin/cc

if test $AUTO = "yes"  {
	test ! $DOTconfig_file && exit_error "Must specify DOTconfig_file=<file> in build.conf"
	test ! $FW_PKG_URL && exit_error "Must specify FW_PKG_URL=<url> in build.conf"
}

## determine number of jobs for make
if test ! $JOBS  {
	setvar JOBS = $(grep "^processor" /proc/cpuinfo | wc -l)
	test $JOBS -ge 1 && setvar JOBS = ""-j${JOBS}"" || setvar JOBS = """"
}
test $JOBS && log_msg "Jobs for make: ${JOBS#-j}" && echo

#------------------------------------------------------------------

if test $DOTconfig_file -a ! -f $DOTconfig_file  {
	exit_error "File not found: $DOTconfig_file (see build.conf - DOTconfig_file=)"
}

if test -f $DOTconfig_file  {
	setvar CONFIGS_DIR = ${DOTconfig_file%/*} #dirname  $DOTconfig_file
	setvar Choice = ${DOTconfig_file##*/}     #basename $DOTconfig_file
	test $CONFIGS_DIR = $Choice && setvar CONFIGS_DIR = '.'
} else {
	test $AUTO = "yes" && exit_error "Must specify DOTconfig_file=<file> in build.conf"
	## .configs
	test -f /tmp/kernel_configs && rm -f /tmp/kernel_configs
	## CONFIG_DIR
	case{
		i?86 {   setvar HOST_ARCH = 'x86' }
		x86_64 { setvar HOST_ARCH = 'x86_64' }
		arm* {   setvar HOST_ARCH = 'arm' }
		* {      setvar HOST_ARCH = $(uname -m) }
	}

	setvar CONFIGS_DIR = "configs_${HOST_ARCH}"
	setvar CONFIGS = $(ls ./${CONFIGS_DIR}/DOTconfig* 2>/dev/null | sed 's|.*/||' | sort -n)
	## list
	echo
	echo "Select the config file you want to use"
	setvar NUM = '1'
	for C in $CONFIGS {
		echo "${NUM}. $C" >> /tmp/kernel_configs
		setvar NUM = $(($NUM + 1))
	}
	if test -f DOTconfig  {
		echo "d. Default - current DOTconfig (./DOTconfig)" >> /tmp/kernel_configs
	}
	echo "n. New DOTconfig" >> /tmp/kernel_configs
	cat /tmp/kernel_configs
	echo -n "Enter choice: " ; read Chosen
	test ! $Chosen -a ! -f DOTconfig && exit_error "\033[1;31m""ERROR: invalid choice, start again!""\033[0m"
	if test $Chosen  {
		setvar Choice = $(grep "^$Chosen\." /tmp/kernel_configs | cut -d ' ' -f2)
		test ! $Choice && exit_error "\033[1;31m""ERROR: your choice is not sane ..quiting""\033[0m"
	} else {
		setvar Choice = 'Default'
	}
	echo -en "\nYou chose $Choice. 
If this is ok hit ENTER, if not hit CTRL|C to quit: " 
	read oknow
}

case (Choice) {
	Default {
		setvar kver = $(grep 'kernel_version=' DOTconfig | head -1 | tr -s ' ' | cut -d '=' -f2)
		if test $kver = ""  {
			if test $kernel_ver = ""  {
				echo -n "Enter kernel version for DOTconfig: "
				read kernel_version
				test ! $kernel_version && echo "ERROR" && exit 1
				echo "kernel_version=${kernel_version}" >> DOTconfig
			} else {
				setvar kernel_version = ${kernel_ver} #build.conf
			}
		}
		}
	New {
		rm -f DOTconfig
		echo -n "Enter kernel version (ex: 3.14.73) : "
		read kernel_version
		}
	* {
		case (Choice) { DOTconfig-* {'
			IFS=-' read dconf kernel_version kernel_version_info <<< ${CONFIGS_DIR}/$Choice }
			* { setvar kernel_version = """" }
		}
		if test ! $kernel_version  {
			setvar kver = $(grep 'kernel_version=' ${CONFIGS_DIR}/$Choice | head -1 | tr -s ' ' | cut -d '=' -f2)
			sed -i '/^kernel_version/d' ${CONFIGS_DIR}/$Choice
			setvar kernel_version = ${kver}
			test $kernel_ver && setvar kernel_version = ${kernel_ver} #build.conf
			if test $kernel_version  {
				echo "kernel_version=${kernel_version}" >> DOTconfig
				echo "kernel_version_info=${kernel_version_info}" >> DOTconfig
			} else {
				test $AUTO = "yes" && exit_error "Must specify kernel_ver=<version> in build.conf"
			}
		}
		if test "${CONFIGS_DIR}/$Choice" != "./DOTconfig"  {
			cp -afv ${CONFIGS_DIR}/$Choice DOTconfig
		}
		test ! $package_name_suffix && setvar package_name_suffix = ${kinfo}
		}
}

log_msg "kernel_version=${kernel_version}"
log_msg "kernel_version_info=${kernel_version_info}"
case (kernel_version) {
	3.*|4.* { setvar ok = '1' } #----
	* { exit_error "ERROR: Unsupported kernel version" }
}

if test $Choice != "New" -a ! -f DOTconfig  {
	exit_error "\033[1;31m""ERROR: No DOTconfig found ..quiting""\033[0m"
}

#------------------------------------------------------------------
setvar FW_URL = ${FW_URL:-http://distro.ibiblio.org/puppylinux/firmware}
# $package_name_suffix $custom_suffix $kernel_ver
setvar aufs_git_3 = ""git://git.code.sf.net/p/aufs/aufs3-standalone.git""
setvar aufs_git_4 = ""git://github.com/sfjro/aufs4-standalone.git""
test ! $kernel_mirrors && setvar kernel_mirrors = ""ftp://www.kernel.org/pub/linux/kernel""
setvar ksubdir_3 = 'v3.x' #http://www.kernel.org/pub/linux/kernel/v3.x
setvar ksubdir_4 = 'v4.x'
#-- random kernel mirror first
setvar rn = $(( ( RANDOM % $(echo "$kernel_mirrors" | wc -l) )  + 1 ))
setvar x = '0'
for i in $kernel_mirrors  {
	setvar x = $((x+1))
	test $x -eq $rn && setvar first = "$i" && continue
	setvar km = ""$km $i""
}
setvar kernel_mirrors = ""$first $km""
#--

if test -f /etc/DISTRO_SPECS  {
	source /etc/DISTRO_SPECS
	test ! $package_name_suffix && setvar package_name_suffix = ${DISTRO_FILE_PREFIX}
}

if test -f DOTconfig  {
	echo ; tail -n10 README ; echo
	for i in CONFIG_AUFS_FS=y CONFIG_NLS_CODEPAGE_850=y
	{
		grep -q $i DOTconfig && do { echo "$i is ok" ; continue ; }
		echo -e "\033[1;31m""\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!   WARNING     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n""\033[0m"
		if test $i = "CONFIG_AUFS_FS=y"  {
			log_msg "For your kernel to boot AUFS as a built in is required:"
			setvar fs_msg = ""File systems -> Miscellaneous filesystems -> AUFS""
		} else {
			log_msg "For NLS to work at boot some configs are required:"
			setvar fs_msg = ""NLS Support""
		}
		echo $i
		echo $i|grep -q "CONFIG_NLS_CODEPAGE_850=y" && echo "CONFIG_NLS_CODEPAGE_852=y"
		log_msg "Make sure you enable this when you are given the opportunity after
	the kernel has downloaded and been patched.
	Look under ' $fs_msg'
	"
		test $AUTO != "yes" && echo -n "PRESS ENTER" && read zzz
	}
}

## fail-safe switch in case someone clicks the script in ROX (real story! not fun at all!!!!) :p
echo
test $AUTO != "yes" && read -p "Press ENTER to begin" dummy'

#------------------------------------------------------------------

## version info
IFS=.' read -r kernel_series \
		kernel_major_version \
		kernel_minor_version \
		kernel_minor_revision <<< "${kernel_version}"

setvar kernel_branch = ${kernel_major_version} #3.x 4.x kernels
setvar kernel_major_version = "${kernel_series}.${kernel_major_version}" #crazy!! 3.14 2.6 etc
setvar aufs_version = ${kernel_series} ## aufs major version
if test $kernel_minor_version  {
	setvar kmv = ".${kernel_minor_version}"
	setvar kernel_tarball_version = ${kernel_version}
} else {
	#single numbered kernel
	setvar kmv = "".0""
	setvar kernel_version = "${kernel_major_version}${kmv}"
	setvar kernel_tarball_version = ${kernel_major_version}
	setvar FIX_KERNEL_VER = 'yes'
}
test $kernel_minor_revision && setvar kmr = ".${kernel_minor_revision}"

log_msg "Linux: ${kernel_major_version}${kmv}${kmr}" #${kernel_series}.

if test ! $aufsv  {
	setvar AUFS_BRANCHES = ''aufs3.0 aufs3.1 aufs3.11 aufs3.13 aufs3.15 aufs3.16 aufs3.17 aufs3.19 aufs3.3 aufs3.4 aufs3.5 aufs3.6 aufs3.7 aufs3.8 aufs3.9 aufs4.0 aufs4.2 aufs4.3 aufs4.4 aufs4.5 aufs4.6 aufs4.7 aufs4.8 aufs4.9 aufs4.10''
	if shell { echo $AUFS_BRANCHES | tr ' ' '\n' | grep -q "^aufs${kernel_major_version}$" }  {
		setvar aufsv = ${kernel_major_version}
	### special cases ###
	} elif test ${kernel_major_version} = "3.2"  {
		setvar aufsv = ''3.2''                #unknown actual value
		vercmp ${kernel_version} ge 3.2.30 && setvar aufsv = ''3.2.x''
	} elif test ${kernel_major_version} = "3.10"  {
		setvar aufsv = ''3.10''
		vercmp ${kernel_version} ge 3.10.26 && setvar aufsv = ''3.10.x''
	} elif test ${kernel_major_version} = "3.12"  {
		setvar aufsv = ''3.12''
		vercmp ${kernel_version} ge 3.12.7 && setvar aufsv = ''3.12.x''
		vercmp ${kernel_version} ge 3.12.31 && setvar aufsv = ''3.12.31+''
	} elif test ${kernel_major_version} = "3.14"  {
		setvar aufsv = ''3.14''
		vercmp ${kernel_version} ge 3.14.21 && setvar aufsv = ''3.14.21+''
		vercmp ${kernel_version} ge 3.14.40 && setvar aufsv = ''3.14.40+''
	} elif test ${kernel_major_version} = "3.18"  {
		setvar aufsv = ''3.18''
		vercmp ${kernel_version} ge 3.18.1 && setvar aufsv = ''3.18.1+''
		vercmp ${kernel_version} ge 3.18.25 && setvar aufsv = ''3.18.25+''
	} elif test ${kernel_major_version} = "4.1"  {
		setvar aufsv = ''4.1''
		vercmp ${kernel_version} ge 4.1.13 && setvar aufsv = ''4.1.13+''
	}
}

test $aufsv || exit_error "You must specify 'aufsv=version' in build.conf"
log_msg "aufs=$aufsv"

#kernel mirror - Aufs series (must match the kernel version)
case (kernel_series) {
	3 { setvar ksubdir = ${ksubdir_3} ; setvar aufs_git = ${aufs_git_3} ; setvar aufs_git_dir = 'aufs3_sources_git' }
	4 { setvar ksubdir = ${ksubdir_4} ; setvar aufs_git = ${aufs_git_4} ; setvar aufs_git_dir = 'aufs4_sources_git' }
}

## create directories for the results
rm -rf output/patches-${kernel_version}-${HOST_ARCH}
test ! -d sources/kernels && mkdir -p sources/kernels
test ! -d output/patches-${kernel_version}-${HOST_ARCH} && mkdir -p output/patches-${kernel_version}-${HOST_ARCH}
test ! -d output && mkdir -p output

## get today's date
setvar today = $(date +%d%m%y)

#==============================================================
#    download kernel, aufs, aufs-utils and firmware tarball
#==============================================================

## download the kernel
setvar testing = ''
echo ${kernel_version##*-} | grep -q "rc" && setvar testing = "/testing"

setvar DOWNLOAD_KERNEL = '1'
test -f sources/kernels/linux-${kernel_tarball_version}.tar.xz && setvar DOWNLOAD_KERNEL = '0'
if test -f sources/kernels/linux-${kernel_tarball_version}.tar.xz.md5.txt  {
	cd sources/kernels
	md5sum -c linux-${kernel_tarball_version}.tar.xz.md5.txt
	if test $? -ne 0  {
		log_msg "md5sum FAILED: will resume kernel download..."
		setvar DOWNLOAD_KERNEL = '1'
	}
	cd $MWD
} else {
	setvar DOWNLOAD_KERNEL = '1'
}

if test $DOWNLOAD_KERNEL -eq 1  {
	setvar KERROR = '1'
	for kernel_mirror in $kernel_mirrors  {
		setvar kernel_mirror = "${kernel_mirror}/${ksubdir}"
		log_msg "Downloading: ${kernel_mirror}${testing}/linux-${kernel_tarball_version}.tar.xz"
		wget ${WGET_OPT} -c -P sources/kernels ${kernel_mirror}${testing}/linux-${kernel_tarball_version}.tar.xz >> ${BUILD_LOG}
		if test $? -ne 0  {
			echo "Error"
		} else {
			setvar KERROR = ''
			break
		}
	}
	test $KERROR && exit 1
	cd sources/kernels
	md5sum linux-${kernel_tarball_version}.tar.xz > linux-${kernel_tarball_version}.tar.xz.md5.txt
	sha256sum linux-${kernel_tarball_version}.tar.xz > linux-${kernel_tarball_version}.tar.xz.sha256.txt
	cd $MWD
}

## download Linux-libre scripts
if test $LIBRE -eq 1  {
	setvar minor_version = ${kernel_version##*.}
	for i in deblob-${kernel_major_version} deblob-check {
		if test ! -f sources/kernels/$i  {
			wget ${WGET_OPT} -O sources/kernels/$i http://linux-libre.fsfla.org/pub/linux-libre/releases/LATEST-${kernel_major_version}.N/$i
			test $? -ne 0 && exit_error "Error: failed to download $i."
		}
	}
}

## download Aufs
if test ! -f /tmp/${aufs_git_dir}_done -o ! -d sources/${aufs_git_dir}/.git  {
	cd sources
	if test ! -d ${aufs_git_dir}/.git  {
		git clone ${aufs_git} ${aufs_git_dir}
		test $? -ne 0 && exit_error "Error: failed to download the Aufs sources."
		touch /tmp/${aufs_git_dir}_done
	} else {
		cd ${aufs_git_dir}
		git pull --all
		if test $? -ne 0  {
			log_msg "WARNING: 'git pull --all' command failed" && sleep 5
		} else {
			touch /tmp/${aufs_git_dir}_done
		}
	}
	cd $MWD
}

## download aufs-utils -- for after compiling the kernel (*)
if test ! -f /tmp/aufs-util_done -o ! -d sources/aufs-util_git/.git  {
	cd sources
	if test ! -d aufs-util_git/.git  {
		log_msg "Downloading aufs-utils for userspace"
		git clone git://git.code.sf.net/p/aufs/aufs-util.git aufs-util_git' || \
		GIT_SSL_NO_VERIFY=true' git clone https://git.code.sf.net/p/aufs/aufs-util aufs-util_git
		test $? -ne 0 && exit_error "Error: failed to download the Aufs utils..."
		touch /tmp/aufs-util_done
	} else {
		cd aufs-util_git
		git pull --all
		if test $? -ne 0  {
			log_msg "WARNING: 'git pull --all' command failed" && sleep 5
		} else {
			touch /tmp/aufs-util_done
		}
	}
	cd $MWD
}

## download firmware tarball/fdrv - specified in build.conf (**)
if test $FW_PKG_URL  {
	setvar fw_pkg = ${FW_PKG_URL##*/} #basename
	setvar FDRV = "fdrv.sfs-${kernel_version}-${package_name_suffix}"
	if test ! -f sources/${fw_pkg}  {
		if test ! -f $FW_PKG_URL  { #may be a local file
			log_msg "Downloading $FW_PKG_URL"
			wget ${WGET_OPT} -c ${FW_PKG_URL} -P sources
			test $? -ne 0 && exit_error "failed to download ${fw_pkg}"
		}
	}
} else {
	# menu
	echo
	log_msg "-- Pausing"
	log_msg "Extra firmware to be added after compiling the kernel"
	echo "Choose an option (generating list...):"
	## download the fw or offer to copy
	setvar tmpfw = "/tmp/fw"$$
	setvar x = '1'
	wget -q ${FW_URL} -O - | \
		sed '/href/!d; /\.tar\./!d; /md5\.txt/d; s/.*href="//; s/".*//' | \
		while read f{
			test $f && echo "$x $f" >> ${tmpfw}
			setvar x = $(($x + 1 ))
		}
	setvar y = $(cat ${tmpfw} | wc -l)
	test $y = 0 && echo "WARNING: no firmware at that URL" # we carry on
	setvar x = $(($x + $y))
	echo "$x I'll copy in my own." >> ${tmpfw}
	setvar x = $(($x + 1))
	echo "$x I'll grab the latest firmware from kernel.org. (slow)" >> ${tmpfw}
	cat ${tmpfw}
	echo -n "Enter a number, 1 to $x:  "
	read fw
	case (fw) {
		[0-9]* { setvar ok = '1' }
		* {	log_msg "invalid option... falling back to option $(($x - 1))"
			setvar fw = $(($x - 1))
			}
	}
	echo
	## if $fw is not a number then the conditionals below will fail
	if test $fw -gt $x  {
		exit_error "error, wrong number"
	} elif test $fw = "$(($x - 1))"  {
		setvar FIRMWARE_OPT = 'manual'
		log_msg "you will manually add firmware after the kernel is compiled"
		sleep 6
	} elif test $fw = $x  {
		setvar FIRMWARE_OPT = 'git'
		## fw.sh - linux-firmware git ##
		echo "You have chosen to get the latest firmware from kernel.org"
		if test -e ../linux-firmware  { #outside kernel-kit
			if test -d ../linux-firmware -a ! -h ../linux-firmware{ # move legacy
				if test -e ../../local-repositories{
					echo "  wait while we move the repository..."
					mv -f ../linux-firmware ../../local-repositories
					shell { cd .. ; ln -snf ../local-repositories/linux-firmware . }
					echo "  repo moved!"
				}
			}
			cd ../linux-firmware
			echo "Updating the git firmware repo"
			git pull || log_msg "Warning: 'git pull' failed"
		} else {
			log_msg "This may take a long time as the firmware repository is around 180MB"
			cd ..
			git clone git://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git
			test $? -ne 0 && exit
		}
		cd $CWD
	} else {
		setvar FIRMWARE_OPT = 'tarball'
		setvar fw_pkg = $(grep ^$fw ${tmpfw})
		setvar fw_pkg = ${fw_pkg##* }
		if test -f sources/${fw_pkg}  {
			log_msg "Verifying sources/${fw_pkg}"
			tar -taf sources/${fw_pkg} &>/dev/null
			test $? -ne 0 && exit_error "failed verify ${fw_pkg##* }"
		} else {
			log_msg "You chose ${fw_pkg}. If that isn't correct change it manually later."
			log_msg "downloading ${FW_URL}/${fw_pkg}"
			wget ${WGET_OPT} -c ${FW_URL}/${fw_pkg} -P sources
			test $? -ne 0 && exit_error "failed to download ${fw_pkg##* }"
		}
		setvar FW_PKG_URL = ${fw_pkg}
	}
}


#==============================================================
#                    compile the kernel
#==============================================================

log_msg "Extracting the Aufs-util sources"
rm -rf aufs-util
cp -a sources/aufs-util_git aufs-util
shell {
	cd aufs-util
	git branch -a | grep "aufs$kernel_series" | \
		grep -v -E 'rcN|\)' | cut -d '.' -f2 | \
		sort -n > /tmp/aufs-util-version #we go for stable only
	while read line { 
		if test $line -le $kernel_branch  { #less or equal than $kernel_branch
			setvar branch = "$line"
			#echo $line ##debug
		} else {
			break
		}
	} < /tmp/aufs-util-version
	git checkout aufs${kernel_series}.${branch} #>> ${BUILD_LOG} 2>&1
	cp Makefile Makefile-orig
	sed -i -e 's/-static //' -e 's|ver_test ||' -e 's|BuildFHSM = .*||' Makefile
	diff -ru Makefile-orig Makefile > ../output/patches-${kernel_version}-${HOST_ARCH}/aufs-util.patch
}

log_msg "Extracting the Aufs sources"
rm -rf aufs_sources
cp -a sources/${aufs_git_dir} aufs_sources
shell {
	cd aufs_sources ; git checkout aufs${aufsv}
	../patches/aufs_sources/apply ${kernel_version}
}

## extract the kernel
log_msg "Extracting the kernel sources"
tar -axf sources/kernels/linux-${kernel_tarball_version}.tar.xz >> ${BUILD_LOG} 2>&1
if test $? -ne 0  {
	rm -f sources/kernels/linux-${kernel_tarball_version}.tar.xz
	exit_error "ERROR extracting kernel sources. file was deleted..."
}

if test $FIX_KERNEL_VER = "yes"  {
	rm -rf linux-${kernel_version}
	mv -f linux-${kernel_tarball_version} linux-${kernel_version}
}

#-------------------------
cd linux-${kernel_version}
#-------------------------

log_msg "Adding Aufs to the kernel sources"
## hack - Aufs adds this file in the mmap patch, but it may be already there
if test -f mm/prfile.c  {
	setvar mmap = "../aufs_sources/aufs${aufs_version}-mmap.patch"
	test -f $mmap && grep -q 'mm/prfile.c' $mmap && rm -f mm/prfile.c #delete or mmap patch will fail
}
for i in kbuild base standalone mmap { #loopback tmpfs-idr vfs-ino
	setvar patchfile = "../aufs_sources/aufs${aufs_version}-$i.patch"
	shell { echo ; echo "patch -N -p1 < ${patchfile##*/}" } &>> ${BUILD_LOG}
	patch -N -p1 < ${patchfile} &>> ${BUILD_LOG}
	if test $? -ne 0  {
		log_msg "WARNING: failed to add some Aufs patches to the kernel sources."
		log_msg "Check it manually and either CRTL+C to bail or hit enter to go on"
		read goon
	}
}
cp -r ../aufs_sources/{fs,Documentation} .
cp ../aufs_sources/include/linux/aufs_type.h include/linux 2>/dev/null
cp ../aufs_sources/include/uapi/linux/aufs_type.h include/linux 2>/dev/null
test -d ../aufs_sources/include/uapi && \
cp -r ../aufs_sources/include/uapi/linux/aufs_type.h include/uapi/linux
################################################################################

## deblob the kernel
if test $LIBRE -eq 1  {
	cd ..
	cp -r linux-${kernel_version} linux-${kernel_version}-orig
	cd linux-${kernel_version}
	sh ../sources/kernels/deblob-${kernel_major_version} 2>&1 | tee -a ${BUILD_LOG}
	cd ..
	diff -rupN linux-${kernel_version}-orig linux-${kernel_version} > output/patches-${kernel_version}-${HOST_ARCH}/deblob.patch
	rm -rf linux-${kernel_version}-orig
	cd linux-${kernel_version}
}

## reset sublevel
cp Makefile Makefile-orig
if test $remove_sublevel = "yes"  {
	log_msg "Resetting the minor version number" #!
	sed -i "s/^SUBLEVEL =.*/SUBLEVEL = 0/" Makefile
}
## custom suffix
if test -n ${custom_suffix} || test $LIBRE -eq 1  {
	sed -i "s/^EXTRAVERSION =.*/EXTRAVERSION = ${custom_suffix}/" Makefile
}
diff -up Makefile-orig Makefile || diff -up Makefile-orig Makefile > ../output/patches-${kernel_version}-${HOST_ARCH}/version.patch
rm Makefile-orig

log_msg "Reducing the number of consoles and verbosity level"
for i in include/linux/printk.h kernel/printk/printk.c kernel/printk.c
{
	test ! -f $i && continue
	setvar z = $(echo "$i" | sed 's|/|_|g')
	cp ${i} ${i}.orig
	sed -i 's|#define CONSOLE_LOGLEVEL_DEFAULT .*|#define CONSOLE_LOGLEVEL_DEFAULT 3|' $i
	sed -i 's|#define DEFAULT_CONSOLE_LOGLEVEL .*|#define DEFAULT_CONSOLE_LOGLEVEL 3|' $i
	sed -i 's|#define MAX_CMDLINECONSOLES .*|#define MAX_CMDLINECONSOLES 5|' $i
	diff -q ${i}.orig ${i} &>/dev/null || diff -up ${i}.orig ${i} > ../output/patches-${kernel_version}-${HOST_ARCH}/${z}.patch
}

for patch in ../patches/*.patch ../patches/${kernel_major_version}/*.patch  {
	test ! -f $patch && continue #../patches/ might not exist or it may be empty
	vercmp ${kernel_version} ge 4.14 && test $(basename "$patch") = "commoncap-symbol.patch" && continue
	log_msg "Applying $patch"
	patch -p1 < $patch >> ${BUILD_LOG} 2>&1
	test $? -ne 0 && exit_error "Error: failed to apply $patch on the kernel sources."
	cp $patch ../output/patches-${kernel_version}-${HOST_ARCH}
}

log_msg "Cleaning the kernel sources"
make clean
make mrproper
find . '(' -name '*.orig' -o -name '*.rej' -o -name '*~' ')' -delete

if test -f ../DOTconfig  {
	cp ../DOTconfig .config
	sed -i '/^kernel_version/d' .config
}

## enable aufs in Kconfig
if test -f fs/aufs/Kconfig  {
	sed -i 's%support"$%support"\n\tdefault y%' fs/aufs/Kconfig
	sed -i 's%aufs branch"%aufs branch"\n\tdefault n%' fs/aufs/Kconfig
}
if ! grep -q "CONFIG_AUFS_FS=y" .config  {
	echo -e "\033[1;31m"
	log_msg "For your kernel to boot AUFS as a built in is required:"
	log_msg "File systems -> Miscellaneous filesystems -> AUFS" 
	echo -e "\033[0m" #reset to original
}

#----
i386_specific_stuff #pae/nopae i486/i686 - funcs.sh
#----

test -f .config -a ! -f ../DOTconfig && cp .config ../DOTconfig

#####################
# pause to configure
proc do_kernel_config {
	log_msg "make $1"
	make $1 ##
	if test $? -eq 0  {
		if test -f .config -a $AUTO != "yes"  {
			log_msg "\nOk, kernel is configured. hit ENTER to continue, CTRL+C to quit"
			read goon
		}
	} else {
		exit 1
	}
}

if test $AUTO = "yes"  {
	do_kernel_config oldconfig
} else {
	if test -f .config  {
		echo -en "
You now should configure your kernel. The supplied .config
should be already configured but you may want to make changes, plus
the date should be updated."
	} else {
		echo -en "\nYou must now configure the kernel"
	}

	echo -en "
Hit a number or s to skip:
1. make menuconfig [default] (ncurses based)
2. make gconfig (gtk based gui)
3. make xconfig (qt based gui)
4. make oldconfig
s. skip

Enter option: " ; read kernelconfig
	case (kernelconfig) {
		1 { do_kernel_config menuconfig }
		2 { do_kernel_config gconfig    }
		3 { do_kernel_config xconfig    }
		4 { do_kernel_config oldconfig   }
		s {
			log_msg "skipping configuration of kernel"
			echo "hit ENTER to continue, CTRL+C to quit"
			read goon
			}
		* { do_kernel_config menuconfig }
	}
}

test ! -f .config && exit_error "\nNo config file, exiting..."

#------------------------------------------------------------------

## we need the arch of the system being built
if grep -q 'CONFIG_X86_64=y' .config  {
	setvar arch = 'x86_64'
	setvar karch = 'x86'
} elif grep -q 'CONFIG_X86_32=y' .config  {
	setvar karch = 'x86'
	if grep -q 'CONFIG_X86_32_SMP=y' .config  {
		setvar arch = 'i686'
	} else {
		setvar arch = 'i486' #gross assumption
	}
} elif grep -q 'CONFIG_ARM=y' .config  {
	setvar arch = 'arm'
	setvar karch = 'arm'
} else {
	log_msg "Your arch is unsupported."
	setvar arch = 'unknown' #allow build anyway
	setvar karch = 'arm'
}

#.....................................................................
setvar linux_kernel_dir = "linux_kernel-${kernel_version}-${package_name_suffix}"
#.....................................................................

## kernel headers
setvar kheaders_dir = ""kernel_headers-${kernel_version}-${package_name_suffix}-$arch""
rm -rf ../output/${kheaders_dir}
log_msg "Creating the kernel headers package"
make headers_check >> ${BUILD_LOG} 2>&1
make INSTALL_HDR_PATH=${kheaders_dir}/usr headers_install >> ${BUILD_LOG} 2>&1
find ${kheaders_dir}/usr/include '(' -name .install -o -name ..install.cmd ')' -delete
mv ${kheaders_dir} ../output

#---------------------------------------------------------------------
#  build aufs-utils userspace modules (**) - requires kernel headers 
#---------------------------------------------------------------------
	log_msg "Building aufs-utils - userspace modules"
	## see if fhsm is enabled in kernel config
	if grep -q 'CONFIG_AUFS_FHSM=y' .config  {
		export MAKE="make BuildFHSM=yes"
	} else {
		export MAKE="make BuildFHSM=no"
	}
	setvar LinuxSrc = "${CWD}/output/${kheaders_dir}" #needs absolute path
	#---
	cd ../aufs-util
	export CPPFLAGS="-I $LinuxSrc/usr/include"
	echo "export CPPFLAGS=\"-I $LinuxSrc/usr/include\"
make clean
$MAKE
make DESTDIR=$CWD/output/aufs-util-${kernel_version}-${arch} install
" > compile ## debug
	make clean &>/dev/null
	$MAKE >> ${BUILD_LOG} 2>&1 || exit_error "Failed to compile aufs-util"
	make DESTDIR=$CWD/output/aufs-util-${kernel_version}-${arch} install >> ${BUILD_LOG} 2>&1 #needs absolute path
	make clean >> ${BUILD_LOG} 2>&1
	# temp hack - https://github.com/puppylinux-woof-CE/woof-CE/issues/889
	mkdir -p $CWD/output/aufs-util-${kernel_version}-${arch}/usr/lib
	mv -fv $CWD/output/aufs-util-${kernel_version}-${arch}/libau.so* \
		$CWD/output/aufs-util-${kernel_version}-${arch}/usr/lib 2>/dev/null
	if test $arch = "x86_64"  {
		mv $CWD/output/aufs-util-${kernel_version}-${arch}/usr/lib \
			$CWD/output/aufs-util-${kernel_version}-${arch}/usr/lib64
	}
	log_msg "aufs-util-${kernel_version} is in output"
	#---
	cd ..
#------------------------------------------------------
cd linux-${kernel_version}

echo "make ${JOBS} bzImage modules
make INSTALL_MOD_PATH=${linux_kernel_dir} modules_install" > compile ## debug

log_msg "Compiling the kernel" | tee -a ${BUILD_LOG}
make ${JOBS} bzImage modules >> ${BUILD_LOG} 2>&1
setvar KCONFIG = ""output/DOTconfig-${kernel_version}-${HOST_ARCH}-${today}""
cp .config ../${KCONFIG}

if test $karch = "x86"  {
	if test ! -f arch/x86/boot/bzImage -o ! -f System.map  {
		exit_error "Error: failed to compile the kernel sources."
	}
} else {
	if test ! -f arch/arm/boot/zImage  { #needs work
		exit_error "Error: failed to compile the kernel sources."
	}
}

#---------------------------------------------------------------------

log_msg "Creating the kernel package"
make INSTALL_MOD_PATH=${linux_kernel_dir} modules_install >> ${BUILD_LOG} 2>&1
rm -f ${linux_kernel_dir}/lib/modules/${kernel_version}${custom_suffix}/{build,source}
mkdir -p ${linux_kernel_dir}/boot
mkdir -p ${linux_kernel_dir}/etc/modules
## /boot/config-$(uname -m)     ## http://www.h-online.com/open/features/Good-and-quick-kernel-configuration-creation-1403046.html
cp .config ${linux_kernel_dir}/boot/config-${kernel_version}${custom_suffix}
## /boot/Sytem.map-$(uname -r)  ## https://en.wikipedia.org/wiki/System.map
cp System.map ${linux_kernel_dir}/boot/System.map-${kernel_version}${custom_suffix}
## /etc/moodules/..
cp .config ${linux_kernel_dir}/etc/modules/DOTconfig-${kernel_version}-${today}
cp ${linux_kernel_dir}/lib/modules/${kernel_version}${custom_suffix}/modules.builtin \
	${linux_kernel_dir}/etc/modules/modules.builtin-${kernel_version}${custom_suffix}
cp ${linux_kernel_dir}/lib/modules/${kernel_version}${custom_suffix}/modules.order \
	${linux_kernel_dir}/etc/modules/modules.order-${kernel_version}${custom_suffix}

#cp arch/x86/boot/bzImage ${linux_kernel_dir}/boot/vmlinuz
setvar BZIMAGE = $(find . -type f -name bzImage | head -1)
cp ${BZIMAGE} ${linux_kernel_dir}/boot
cp ${BZIMAGE} ${linux_kernel_dir}/boot/vmlinuz

mv ${linux_kernel_dir} ../output ## ../output/${linux_kernel_dir}

## make fatdog kernel module package
mv ../output/${linux_kernel_dir}/boot/vmlinuz \
	../output/vmlinuz-${kernel_version}-${package_name_suffix}
test -f ../output/${linux_kernel_dir}/boot/bzImage && \
	rm -f ../output/${linux_kernel_dir}/boot/bzImage
log_msg "Huge kernel ${kernel_version}-${package_name_suffix} is ready in dist"

log_msg "Cleaning the kernel sources"
make clean >> ${BUILD_LOG} 2>&1
make prepare >> ${BUILD_LOG} 2>&1

#----
cd ..
#----

log_msg "Installing aufs-utils into kernel package"
cp -a --remove-destination output/aufs-util-${kernel_version}-${arch}/* \
		output/${linux_kernel_dir}

log_msg "Creating a kernel sources SFS"
mkdir -p kernel_sources-${kernel_version}-${package_name_suffix}/usr/src
mv linux-${kernel_version} kernel_sources-${kernel_version}-${package_name_suffix}/usr/src/linux
mkdir -p kernel_sources-${kernel_version}-${package_name_suffix}/lib/modules/${kernel_version}${custom_suffix}
ln -s /usr/src/linux kernel_sources-${kernel_version}-${package_name_suffix}/lib/modules/${kernel_version}${custom_suffix}/build
if test ! -f kernel_sources-${kernel_version}-${package_name_suffix}/usr/src/linux/include/linux/version.h  {
	ln -s /usr/src/linux/include/generated/uapi/linux/version.h \
		kernel_sources-${kernel_version}-${package_name_suffix}/usr/src/linux/include/linux/version.h
}
ln -s /usr/src/linux kernel_sources-${kernel_version}-${package_name_suffix}/lib/modules/${kernel_version}${custom_suffix}/source
mksquashfs kernel_sources-${kernel_version}-${package_name_suffix} output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs $COMP
md5sum output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs > output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs.md5.txt
sha256sum output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs > output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs.sha256.txt

#==============================================================

if test $LIBRE -eq 0  {
 #firmware pkg/fdrv (*)
 if test $FW_PKG_URL  {
	setvar fw_pkg = ${FW_PKG_URL##*/} #basename
	case (fw_pkg) {
		*.sfs {
			setvar FDRV = "fdrv.sfs-${kernel_version}-${package_name_suffix}"
			test -f $FW_PKG_URL && cp $FW_PKG_URL output/${FDRV} #may be a local file
			test -f sources/${fw_pkg} && cp sources/${fw_pkg} output/${FDRV}
			}
		*.tar.* {
			mkdir -p output/${linux_kernel_dir}/lib
			tar -xaf sources/${fw_pkg} -C output/${linux_kernel_dir}/lib/
			test $? -ne 0 && exit_error "failed to unpack ${fw_pkg}"
			}
	}
 } else {
	log_msg "Pausing here to add extra firmware."
	case{
	manual {
		log_msg "once you have manually added firmware to "
		log_msg "output/${linux_kernel_dir}/lib/firmware"
		echo "hit ENTER to continue"
		read firm
	}
	git {
		## run the firmware script and re-enter here
		export GIT_ALREADY_DOWNLOADED=yes
		./fw.sh ${fw_flag} # optonal param; see fw.sh and build.conf
		if test $? -eq 0  {
			log_msg "Extracting firmware from the kernel.org git repo has succeeded."
		} else {
			log_msg "WARNING: Extracting firmware from the kernel.org git repo has failed."
			log_msg "While your kernel is built, your firmware is incomplete."
		}
	}
	}
 }
}

mksquashfs output/${linux_kernel_dir} output/kernel-modules.sfs-${kernel_version}-${package_name_suffix} $COMP
test $? = 0 || exit 1
log_msg "Huge compatible kernel packages are ready to package./"
log_msg "Packaging huge-${kernel_version}-${package_name_suffix} kernel"
cd output/
tar -cjvf huge-${kernel_version}-${package_name_suffix}.tar.bz2 \
	vmlinuz-${kernel_version}-${package_name_suffix} ${FDRV} \
	kernel-modules.sfs-${kernel_version}-${package_name_suffix} || exit 1
	echo "huge-${kernel_version}-${package_name_suffix}.tar.bz2 is in output"
md5sum huge-${kernel_version}-${package_name_suffix}.tar.bz2 > huge-${kernel_version}-${package_name_suffix}.tar.bz2.md5.txt
sha256sum huge-${kernel_version}-${package_name_suffix}.tar.bz2 > huge-${kernel_version}-${package_name_suffix}.tar.bz2.sha256.txt
echo
cd -

log_msg "Compressing the log"
bzip2 -9 build.log
cp build.log.bz2 output

log_msg "------------------
Output files:
- output/huge-${kernel_version}-${package_name_suffix}.tar.bz2
  (kernel tarball: vmlinuz, modules.sfs - used in the woof process)
  you can use this to replace vmlinuz and zdrv.sfs from the current wce puppy install..

- output/kernel_sources-${kernel_version}-${package_name_suffix}.sfs
  (you can use this to compile new kernel modules - load or install first..)
------------------"

echo "Done!"
test -f /usr/share/sounds/2barks.au && aplay /usr/share/sounds/2barks.au

### END ###