#!/bin/bash
# Copyright 2015 Calculate Ltd. http://www.calculate-linux.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

PATH=/lib/rc/bin:$PATH

TEXTDOMAIN=cl_kernel
CL_KERNEL_VERSION=0.1_rc3
DESCRIPTION=$"Kernel building tool"
DEFAULT_KERNEL_DIRECTORY=/usr/src/linux
SRC_DIRECTORY=/usr/src
LOCAL_TEMPLATES_DIR=/var/calculate/templates/kernel
TEMPLATES_BACKUP=${LOCAL_TEMPLATES_DIR}/backup
DEBUG_LOG=/var/log/calculate/cl-kernel.log
KVER=
KERNEL_DIR=${DEFAULT_KERNEL_DIRECTORY}
# создавать базовую конфигурацию ядра
CREATE_BASE=1
# создавать текущую конфигурацию ядра
CREATE_NEW=1
# собирать ядро после конфигурации
BUILD_KERNEL=1
# права на файл шаблона
CHMOD=0644
# наличие dracut в системе
DRACUT=$(which dracut 2>/dev/null)
declare -a TAILOUT=()

# прервать скрипт в случае ошибки любой из команд
set -e

: >$DEBUG_LOG

# вывод короткой справки
usage() {
    echo $"Usage: $0 [OPTION]

Version: $CL_KERNEL_VERSION

${DESCRIPTION}

    -h, --help  display all options and exit"
}

# вывод полной справки
long_usage() {
    echo $"Usage: $0 [OPTION]

Version: $CL_KERNEL_VERSION

${DESCRIPTION}

  --kver [VERSION]           specify the kernel version ('list' for displaying possible values)
  --kver-old [VERSION]       specify the kernel version for new options ('list' for displaying possible values)
  --convert                  migrate .config from the kernel directory to templates
  -s, --skip-build           do not build the kernel after configuration
  --march [ARCH]             kernel architecture (x86 or x86_64)
  --safemode                 create an additional initrd with all modules (only for calculate-sources)
  --help                     display this help and exit
"
}

# подготовить параметры командной строки
rearrange_params() {
    TEMP=$(unset POSIXLY_CORRECT; getopt \
        -o "hs" \
        --long help \
        --long kver: \
        --long kver-old: \
        --long march: \
        --long convert \
        --long skip-build \
        --long safemode \
        -- "$@")
    if (( $? != 0 )); then
        usage
        exit 1
    fi
}

# выполнить параметры командной строки
do_args() {
    while :; do
        case $1 in
        -h|--help)
            long_usage
            exit 0
            ;;
        --kver)
            KVER="$2"
            shift
            ;;
        --kver-old)
            KVER_OLD="$2"
            shift
            ;;
        --safemode)
            SAFEMODE=1
            ;;
        --march)
            MARCH="$2"
            if [[ ${MARCH} != "x86" ]] && [[ ${MARCH} != "x86_64" ]]
            then
                eerror $"Error in parameter --march. The value may be 'x86' or 'x86_64'"
            fi
            shift
            ;;
        --convert)
            MIGRATE=1
            CREATE_NEW=
            ;;
        -s|--skip-build)
            BUILD_KERNEL=
            ;;
        --) shift;break;;
        *) usage;
           eerror $"Unknown option: $1"
           ;;
       esac
       shift
    done
    if [[ -n $1 ]]
    then
        usage;
        eerror $"Unknown argument: $1"
    fi
}

# использовать параметры из make.conf
source_makeconf() {
    [[ -f /etc/make.conf ]] && source /etc/make.conf
    if [[ -d /etc/portage/make.conf ]]
    then
        for makeconf in /etc/portage/make.conf/*
        do
            source $makeconf
        done
    fi
}

# получить значение переменной calculate
variable_value()
{
    local varname=$1
    cl-core-variables-show --only-value $varname
}

# оставить только названия параметров + "="
options_name() {
    sed -r 's/^# (CON.*) is not set.*$/\1=/' | sed -r 's/^(CON.*=).*/\1/'
}

# преобразовать опции в синтаксис удаления параметра
remove_syntax() {
    sed -r 's/^(.*=).*$/!\1/'
}

# преобразовать CONFIG_XXX=n -> # CONFIG_XXX is not set
n2not_set() {
    sed -r 's/(CONFIG.*)=n/# \1 is not set/'
}

# получить разницу в конфигурационных файлах
diff_config() {
    diff -u <(grep CONFIG_ $1 | sort | n2not_set) <(grep CONFIG_ $2 | sort | n2not_set)
}

# получить разницу в параметрах конфигурационных файлов
diff_config_options() {
    diff -u <(cat $1 | options_name | sort) <(cat $2 | options_name | sort)
}

# изменённые параметры
append_options() {
     diff_config $1 $2 | grep -e "^+CON" -e "^+# CON" | sed 's/^.//' | sort
}


# удаленные параметры
removed_options() {
     diff_config_options $1 $2 | grep -e "^-CON" | sed  's/^.//' | sort
}


# получить содержимое шаблона
diff_template_body() {
    append_options $1 $2
    removed_options $1 $2 | remove_syntax
}

# вывести заголов для шаблона
# Args:
# категория/название пакета
# версия пакета
diff_template_head() {
    local category_pn=$1
    local pv=$2
    echo "# Calculate format=kernel name=.config os_install_arch_machine==${TEMPLATE_ARCH}&&merge(${category_pn})>=${pv}"
}

# вывести полный шаблон
# Args:
# категория/название пакета
# версия пакета
# файл базовой конфигурации
# файл новой конфигурации
create_template() {
    local category_pn=$1
    local pv=$2
    local base_config=$3
    local new_config=$4
    diff_template_head ${category_pn} ${pv}
    diff_template_body ${base_config} ${new_config}
}

# получить конфигурацию ядра
# Args:
# каталог с исходным кодом ядра
# категория/название пакета
# версия пакета
# применяемые шаблоны (локации)
create_kernel_config() {
    local kernel_dir=$1
    local category_pn=( ${2/\// } )
    local category=${category_pn[0]}
    local pn=${category_pn[1]}
    local pv=$3
    # создать временную директорию для выполнения шаблонов
    local tempdir=$(${MKTEMP} -d)
    [[ -n $4 ]] && local templates="-T $4"
    # получить конфигурацию ядра по умолчанию, нужной архитектуры
    local temp_config=".config_clkernel_${ARCH}"
    (cd ${kernel_dir};ARCH=$MARCH KCONFIG_CONFIG=${temp_config} make defconfig;mv ${temp_config} ${tempdir}/.config) &>>$DEBUG_LOG ||
        eerror $"Failed to create the default kernel config"
    # выполнить шаблоны (патчи)
    /usr/sbin/cl-core-patch --march=$TEMPLATE_ARCH --pkg-name ${pn} --pkg-category ${category} --pkg-version=${pv} --pkg-slot=${pv} --pkg-path=$tempdir $templates &>>$DEBUG_LOG || eerror $"Failed to apply kernel templates"
    # вывести содержимое файла конфигурации ядра
    cat $tempdir/.config || eerror $"Kernel configuration file not found"
    rm -rf $tempdir &>>$DEBUG_LOG
}

# проверить содержит ли каталог полный исходный код ядра
check_kernel_sources() {
    local sources_dir=$1
    [[ -f ${sources_dir}/arch/x86/configs/i386_defconfig ]]
}

# версия исходного кода ядра
sources_ver() {
    basename "$(readlink -f $1)" | sed 's/linux-//' || true
}

# текущее ядро
current_kernel() {
    sources_ver /usr/src/linux
}

# вывести список версий ядер с полным исходным кодом
list_kernel() {
    local asterisk=$(echo -e "\033[1m*\033[0m")
    local green_asterisk=$(echo -e "\033[1;32m*\033[0m")
    local red_asterisk=$(echo -e "\033[1;31m*\033[0m")
    local curver=$1
    for f in $(ls -drv /usr/src/linux-[[:digit:]]*); do
        local ver=$(sources_ver "${f}")
        [[ $ver == $curver ]] && mark=$asterisk || mark=
        check_kernel_sources $f && echo " ${green_asterisk}" $ver $mark || echo " ${red_asterisk}" $ver $mark
    done
}

# вывести сообщение и добавить его в список выводимых после сборки ядра сообщений
einfo_tail() {
    einfo $*
    TAILOUT+=( "$*" )
}

# получить содержимое текущего конфига
# .config в директории исходного кода ядра
# /boot/config- 
# /proc/config.gz
get_old_config() {
    local source_config="${KERNEL_DIR}/.config"
    local boot_config="/boot/config-$(uname -r)"
    local proc_config="/proc/config.gz"
    if [[ -f $source_config ]]
    then
        config=$source_config
    elif [[ -f $boot_config ]]
    then
        config=$boot_config
        cp $config $NEW_CONFIG
    elif [[ -f $proc_config ]]
    then
        config=$proc_config
        zcat $proc_config >$NEW_CONFIG
    fi
    if [[ -n $config ]]
    then
        einfo $"Will be used $config kernel configuration"
    else
        eerror $"Failed to get current kernel configuration"
    fi
}

# qfile hack
_qfile() {
    (cd /; qfile $*)
}

check_belong() {
    local fn=$1
    local linenum=$(_qfile -C $fn | wc -l)
    if [[ $linenum -lt 1 ]]
    then
        eerror $"${fn} does not belong to any package"
    elif [[ $linenum -gt 1 ]]
    then
        eerror $"${fn} belongs to multiple packages"
    fi
    return 0
}

######################
# Обработать параметры
######################
rearrange_params "$@"
eval set -- "$TEMP"
do_args "$@"

########################
# Подготовить переменные 
########################

# вычислить архитектуру
[[ -z $MARCH ]] && MARCH=$(/usr/bin/arch)
if [[ "$MARCH" == "x86" ]] || [[ "$MARCH" == "i686" ]]
then
    # архитектура для конфигурации по умолчанию
    MARCH=i386
    # архитектура для шаблонов
    TEMPLATE_ARCH=i686
    # название архитектуры
    NAME_ARCH=x86
else
    TEMPLATE_ARCH=$MARCH
    NAME_ARCH=$MARCH
fi

# подготовить имя для шаблона очистить старые временные данные
TMP_TEMPLATE=/tmp/cl_kernel_${MARCH}
MKTEMP="/usr/bin/mktemp ${TMP_TEMPLATE}.XXXXXX"
rm -rf ${TMP_TEMPLATE}*

# пропустить сборку ядра если выбранная архитектура и архитектура машины отличаются
if [[ $TEMPLATE_ARCH != $(/usr/bin/arch) ]]
then
    OTHER_ARCH=1
    BUILD_KERNEL=
fi

# вывести список доступных ядер
if [[ $KVER == "list" ]] || [[ $KVER_OLD == "list" ]]
then
    list_kernel $(current_kernel)
    exit 0
fi

# получить директорию ядра по версии
if [[ -n $KVER ]]
then
    KERNEL_DIR=${SRC_DIRECTORY}/linux-${KVER}
fi
if [[ -n $KVER_OLD ]]
then
    KERNEL_OLD_DIR=${SRC_DIRECTORY}/linux-${KVER_OLD}
fi
# проверить правильность исходников
for check_dir in ${KERNEL_DIR} ${KERNEL_OLD_DIR}
do
    [[ -d ${check_dir} ]] || eerror $"Kernel directory ${check_dir} not found"
    check_kernel_sources  ${check_dir} || eerror $"Kernel directory ${check_dir} has no full sources"
done 

# получить версию из директории ядра
if [[ -z $KVER ]]
then
    KVER=$(sources_ver $KERNEL_DIR)
fi

# проверка доступности safemode
if [[ -n $SAFEMODE ]] && ! [[ $KVER =~ -calculate ]]
then
    eerror $"--safemode available for calculate-sources only"
fi

if [[ -n $SAFEMODE ]] && [[ -z $DRACUT ]]
then
    eerror $"--safemode unavailable without dracut"
fi

# создать каталог в локальных шаблонах для шаблонов ядра
if ! [[ -d $LOCAL_TEMPLATES_DIR ]]
then
    (mkdir -p $LOCAL_TEMPLATES_DIR ;
    echo "# Calculate env=install cl_ver>=3.3.0 cl_name==calculate-core&&ac_install_patch==on append=skip" >${LOCAL_TEMPLATES_DIR}/.calculate_directory) ||
        eerror $"Failed to create the kernel template directory"
fi

# если другая архитектура
if [[ -n $OTHER_ARCH ]]
then
    NEW_CONFIG=${KERNEL_DIR}/.config_${TEMPLATE_ARCH}
else
    NEW_CONFIG=${KERNEL_DIR}/.config
fi

check_belong ${KERNEL_DIR}/Makefile
# получение параметров пакета, которому принадлежат исходники
CATEGORY_PN=$( _qfile -C ${KERNEL_DIR}/Makefile | awk '{print $1}' )
PV=$( _qfile -Cv ${KERNEL_DIR}/Makefile | awk '{print $1}' )
PV=${PV/$CATEGORY_PN-/}

if [[ -n $KERNEL_OLD_DIR ]] 
then
    check_belong ${KERNEL_OLD_DIR}/Makefile
    CATEGORY_PN_OLD=$( _qfile -C ${KERNEL_OLD_DIR}/Makefile | awk '{print $1}' )
    PV_OLD=$( _qfile -Cv ${KERNEL_OLD_DIR}/Makefile | awk '{print $1}' )
    PV_OLD=${PV_OLD/${CATEGORY_PN_OLD}-/}
fi

# получить версия MAJOR.MINOR для условий в шаблонах
[[ $KVER =~ ^([[:digit:]]+\.[[:digit:]]+) ]] && PV2=${BASH_REMATCH[0]} || PV2=$PV

# определение имени шаблонов для пакета
if [[ $CATEGORY_PN =~ ^.*/(.*)-sources ]]
then
    TEMPLATE_NAME_PREFIX=10-${BASH_REMATCH[1]}-
else
    TEMPLATE_NAME_PREFIX=10-config-
fi
TEMPLATE_NAME_ARCH_PREFIX=${TEMPLATE_NAME_PREFIX}${NAME_ARCH}-
TEMPLATE_NAME="${LOCAL_TEMPLATES_DIR}/${TEMPLATE_NAME_ARCH_PREFIX}${PV2}"

####################################
# Подготовка новой конфигурации ядра
####################################

CONFIG_GZ=/proc/config.gz

if [[ -n $CREATE_NEW ]]
then
    ebegin $"Preparing the current kernel configuration"
    create_kernel_config ${KERNEL_OLD_DIR:-${KERNEL_DIR}} \
        ${CATEGORY_PN_OLD:-${CATEGORY_PN}} \
        ${PV_OLD:-${PV}} >$NEW_CONFIG
    eend
else
    if [[ -n $OTHER_ARCH ]]
    then
        eerror $"--convert is uncompatible with --march"
    fi
    get_old_config
fi

######################################
# Подготовка базовой конфигурации ядра
######################################
BASE_CONFIG=$( ${MKTEMP} )

ebegin $"Preparing the basic kernel configuration"
if [[ -n $CREATE_BASE ]]
then
    # будут использоваться только шаблоны оверлеев
    TEMPLATES=$(variable_value main.cl_template_location)
    create_kernel_config ${KERNEL_DIR} ${CATEGORY_PN} ${PV} ${TEMPLATES/,local,remote/} >$BASE_CONFIG
else
    cp $NEW_CONFIG $BASE_CONFIG
fi
eend

###########################################
# Изменение конфигурации ядра пользователем
###########################################
(cd $KERNEL_DIR; [[ -n ${KERNEL_OLD_DIR} || -z ${CREATE_NEW} ]] && KCONFIG_CONFIG=$(basename $NEW_CONFIG) make oldconfig;KCONFIG_CONFIG=$(basename $NEW_CONFIG) make -s nconfig) || true

###########################
# Создание шаблона
###########################
NEW_TEMPLATE=$( ${MKTEMP} )
create_template $CATEGORY_PN $PV2 $BASE_CONFIG $NEW_CONFIG >${NEW_TEMPLATE}

##################################
# Создание резервной копии шаблона
##################################
if ls ${LOCAL_TEMPLATES_DIR}/${TEMPLATE_NAME_ARCH_PREFIX}* &>/dev/null
then
    for i in ${LOCAL_TEMPLATES_DIR}/${TEMPLATE_NAME_ARCH_PREFIX}*
    do
        if diff -u $i $NEW_TEMPLATE &>/dev/null
        then
            einfo_tail $"The kernel configuration has not changed"
            rm $i
            SKIP_CREATE_INFO=1
        else
            newname="$(basename $i)-$(date +%Y%m%d_%H%M -r $i)"
            einfo_tail $"Backing up the template" "$(basename $i) -> ${newname}"
            if ! [[ -d ${TEMPLATES_BACKUP} ]]
            then
                (mkdir -p ${TEMPLATES_BACKUP} &&
                    echo "# Calculate cl_action==skip" >${TEMPLATES_BACKUP}/.calculate_directory) || eerror $"Failed to create a backup directory"
            fi
            mv  $i ${TEMPLATES_BACKUP}/${newname}
        fi
    done
fi

# пропуск создания пустого шаблона
if [[ $(sed 1d $NEW_TEMPLATE | wc -l) -gt 0 ]]
then
    mv $NEW_TEMPLATE $TEMPLATE_NAME
    chmod ${CHMOD} $TEMPLATE_NAME
    if [[ -z $SKIP_CREATE_INFO ]]
    then
        einfo_tail $"Creating the template" "$(basename $TEMPLATE_NAME)"
    fi
else
    einfo_tail $"Skipping the empty template"
fi

rm -f $BASE_CONFIG

STARTTIME=$(date +%s)

#############
# Сборка ядра
#############
if [[ -n ${BUILD_KERNEL} ]]
then
    cd $KERNEL_DIR
    (source_makeconf && make clean && make $MAKEOPTS && make $MAKEOPTS modules_install && make $MAKEOPTS install)
    # сборка initramfs
    if [[ -n $DRACUT ]]
    then
        grep -q "CONFIG_BLK_DEV_INITRD=y" ${NEW_CONFIG} && ${DRACUT} -fH --kver $KVER /boot/initramfs-${KVER}.img
        if [[ $KVER =~ calculate ]] && [[ -n $SAFEMODE ]]
        then
            
            grep -q "CONFIG_BLK_DEV_INITRD=y" ${NEW_CONFIG} && ${DRACUT} -f --kver $KVER /boot/initramfs-${KVER/-calculate/-SafeMode-calculate}.img
        fi
    fi
    # выполнение шаблонов для настройки загрзуки системы
    cl-setup-boot

    # вывод времени компиляции ядра
    DELTATIME=$(( $(date +%s) - $STARTTIME ))
    HOUR=$(( $DELTATIME / 3600 ))
    DELTATIME=$(( $DELTATIME % 3600 ))
    MIN=$(( $DELTATIME / 60 ))
    SEC=$(( $DELTATIME % 60 ))

    echo -en " \033[1;32m*\033[0m "
    echo -n $"Kernel build time: "
    if [[ ${HOUR} -gt 0 ]]
    then
        printf "%02d:%02d:%02d\n" ${HOUR} ${MIN} ${SEC}
    else
        printf "%02d:%02d\n" ${MIN} ${SEC}
    fi

    # вывод информационных сообщений, отображённых до сборки ядра
    for line in "${TAILOUT[@]}"
    do
        einfo $line
    done
fi

einfo $"All done!"
