[mirror_zfs.git] / scripts / kmodtool

#!/bin/bash

# kmodtool - Helper script for building kernel module RPMs
# Copyright (c) 2003-2012 Ville Skyttä <ville.skytta@iki.fi>,
#                         Thorsten Leemhuis <fedora@leemhuis.info>
#                         Nicolas Chauvet <kwizart@gmail.com>
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

shopt -s extglob

myprog="kmodtool-${repo}"
myver="0.12.1"

kmodname=
build_kernels="current"
kernels_known_variants=
kernel_versions=
kernel_versions_to_build_for=
prefix=
filterfile=
target=
buildroot=

error_out()
{
	local errorlevel=${1}
	shift
	echo "Error: $@" >&2
	# the next line is not multi-line safe -- not needed *yet*
	echo "%global kmodtool_check echo \"kmodtool error: $@\"; exit ${errorlevel};"
	exit ${errorlevel}
}

print_rpmtemplate_header()
{
	echo
	echo '%global kmodinstdir_prefix  '${prefix}/lib/modules/
	echo '%global kmodinstdir_postfix '/extra/${kmodname}/
	echo '%global kernel_versions     '${kernel_versions}
	echo
}

print_akmodtemplate ()
{
	echo
	cat <<EOF

%global akmod_install mkdir -p \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/; \\\
LANG=C rpmbuild --define "_sourcedir %{_sourcedir}" \\\
--define "_srcrpmdir \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/" \\\
-bs --nodeps %{_specdir}/%{name}.spec ; \\\
ln -s \$(ls \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/) \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/${kmodname}-kmod.latest

%package -n akmod-${kmodname}
Summary:	Akmod package for ${kmodname} kernel module(s) 
Group: 		System Environment/Kernel
Requires:   kmodtool
Requires: 	akmods
%{?AkmodsBuildRequires:Requires: %{AkmodsBuildRequires}}
# same requires and provides as a kmods package would have
Requires: 	${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
Provides: 	${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
EOF

	if [[ ${obsolete_name} ]]; then
		echo "Provides:   akmod-${obsolete_name} = ${obsolete_version}"
		echo "Obsoletes:  akmod-${obsolete_name} < ${obsolete_version}"
	fi

	cat <<EOF

%description -n akmod-${kmodname}
This package provides the akmod package for the ${kmodname} kernel modules.

%posttrans -n akmod-${kmodname}
nohup ${prefix}/sbin/akmods --from-akmod-posttrans --akmod ${kmodname} &> /dev/null &

%files -n akmod-${kmodname}
%defattr(-,root,root,-)
%{_usrsrc}/akmods/*

EOF
}

print_akmodmeta ()
{
		cat <<EOF
%package      -n kmod-${kmodname}
Summary:         Metapackage which tracks in ${kmodname} kernel module for newest kernel${dashvariant}
Group:           System Environment/Kernel

Provides:        ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
Provides:        kmod-${kmodname}-xen = %{?epoch:%{epoch}:}%{version}-%{release}
Provides:        kmod-${kmodname}-smp = %{?epoch:%{epoch}:}%{version}-%{release}
Provides:        kmod-${kmodname}-PAE = %{?epoch:%{epoch}:}%{version}-%{release}
Requires:        akmod-${kmodname} = %{?epoch:%{epoch}:}%{version}-%{release}
EOF

	if [[ ${obsolete_name} ]]; then
		echo "Provides:        kmod-${obsolete_name} = ${obsolete_version}"
		echo "Obsoletes:       kmod-${obsolete_name} < ${obsolete_version}"
	fi
cat <<EOF

%description  -n kmod-${kmodname}${dashvariant}
This is a meta-package without payload which sole purpose is to require the
${kmodname} kernel module(s) for the newest kernel${dashvariant},
to make sure you get it together with a new kernel.

%files        -n kmod-${kmodname}${dashvariant}
%defattr(644,root,root,755)
EOF
}

print_rpmtemplate_per_kmodpkg ()
{
	if [[ "${1}" == "--custom" ]]; then
		shift
		local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
		# this is needed for akmods
		shift
		local redhatkernel=true
	fi

	local kernel_uname_r=${1}
	local kernel_variant="${2:+-${2}}"

    # first part
	cat <<EOF
%package       -n kmod-${kmodname}-${kernel_uname_r}
Summary:          ${kmodname} kernel module(s) for ${kernel_uname_r}
Group:            System Environment/Kernel
Provides:         kernel-modules-for-kernel = ${kernel_uname_r}
Provides:         kmod-${kmodname}-uname-r = ${kernel_uname_r}
Provides:         ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
Requires:         ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
Requires(post):   ${prefix}/sbin/depmod
Requires(postun): ${prefix}/sbin/depmod
EOF

	if [[ ${obsolete_name} ]]; then
		echo "Provides:        kmod-${obsolete_name}-${kernel_uname_r} = ${obsolete_version}"
		echo "Obsoletes:       kmod-${obsolete_name}-${kernel_uname_r} < ${obsolete_version}"
	fi

	# second part
	if [[ ! "${customkernel}" ]]; then
	     cat <<EOF
Requires:         kernel-uname-r = ${kernel_uname_r}
BuildRequires:	  kernel-devel-uname-r = ${kernel_uname_r}
%{?KmodsRequires:Requires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
%{?KmodsRequires:BuildRequires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
%post          -n kmod-${kmodname}-${kernel_uname_r}
${prefix}/sbin/depmod -aeF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} > /dev/null || :
%postun        -n kmod-${kmodname}-${kernel_uname_r}
${prefix}/sbin/depmod  -aF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} &> /dev/null || :

EOF
	else
	  cat <<EOF
%post          -n kmod-${kmodname}-${kernel_uname_r}
[[ "$(uname -r)" == "${kernel_uname_r}"  ]] && ${prefix}/sbin/depmod -a > /dev/null || :
%postun        -n kmod-${kmodname}-${kernel_uname_r}
[[ "$(uname -r)" == "${kernel_uname_r}"  ]] && ${prefix}/sbin/depmod -a > /dev/null || :

EOF
	fi

  # third part
	cat <<EOF
%description  -n kmod-${kmodname}-${kernel_uname_r}
This package provides the ${kmodname} kernel modules built for the Linux
kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
%files        -n kmod-${kmodname}-${kernel_uname_r}
%defattr(644,root,root,755)
%dir $prefix/lib/modules/${kernel_uname_r}/extra
${prefix}/lib/modules/${kernel_uname_r}/extra/${kmodname}/


EOF
}

print_rpmtemplate_kmoddevelpkg ()
{
	if [[ "${1}" == "--custom" ]]; then
		shift
		local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
		shift
		local redhatkernel=true
	fi

	local kernel_uname_r=${1}

	cat <<EOF
%package       -n kmod-${kmodname}-devel
Summary:          ${kmodname} kernel module(s) devel common
Group:            System Environment/Kernel
Provides:         ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
EOF

	if [[ ! ${customkernel} ]] && [[ ! ${redhatkernel} ]]; then
		echo "Requires:        kmod-${kmodname}-devel-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}"
	fi

	if [[ ${obsolete_name} ]]; then
		echo "Provides:        kmod-${obsolete_name}-devel = ${obsolete_version}"
		echo "Obsoletes:       kmod-${obsolete_name}-devel < ${obsolete_version}"
	fi

	cat <<EOF
%description  -n kmod-${kmodname}-devel
This package provides the common header files to build kernel modules
which depend on the ${kmodname} kernel module.  It may optionally require
the ${kmodname}-devel-<kernel> objects for the newest kernel.

%files        -n kmod-${kmodname}-devel
%defattr(644,root,root,755)
%{_usrsrc}/${kmodname}-%{version}
EOF
	if [[ ${obsolete_name} ]]; then
		echo "%{_usrsrc}/${obsolete_name}-%{version}"
	fi

	for kernel in ${1}; do
		local kernel_uname_r=${kernel}
		echo "%exclude %{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}"
		if [[ ${obsolete_name} ]]; then
			echo "%exclude %{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
		fi
	done

	echo
	echo
}

print_rpmtemplate_per_kmoddevelpkg ()
{
	if [[ "${1}" == "--custom" ]]; then
		shift
		local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
		# this is needed for akmods
		shift
		local redhatkernel=true
	fi

	local kernel_uname_r=${1}
	local kernel_variant="${2:+-${2}}"

	# first part
	cat <<EOF
%package       -n kmod-${kmodname}-devel-${kernel_uname_r}
Summary:          ${kmodname} kernel module(s) devel for ${kernel_uname_r}
Group:            System Environment/Kernel
Provides:         kernel-objects-for-kernel = ${kernel_uname_r}
Provides:         ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
Provides:         kmod-${kmodname}-devel-uname-r = ${kernel_uname_r}
EOF

	if [[ ${obsolete_name} ]]; then
		echo "Provides:        kmod-${obsolete_name}-devel-${kernel_uname_r} = ${obsolete_version}"
		echo "Obsoletes:       kmod-${obsolete_name}-devel-${kernel_uname_r} < ${obsolete_version}"
	fi

	# second part
	if [[ ! "${customkernel}" ]]; then
		cat <<EOF
Requires:         kernel-devel-uname-r = ${kernel_uname_r}
BuildRequires:    kernel-devel-uname-r = ${kernel_uname_r}
%{?KmodsDevelRequires:Requires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
%{?KmodsDevelRequires:BuildRequires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
EOF
	fi

	# third part
	cat <<EOF
%description  -n kmod-${kmodname}-devel-${kernel_uname_r}
This package provides objects and symbols required to build kernel modules
which depend on the ${kmodname} kernel modules built for the Linux
kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
%files        -n kmod-${kmodname}-devel-${kernel_uname_r}
%defattr(644,root,root,755)
%{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}
EOF
	if [[ ${obsolete_name} ]]; then
		echo "%{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
	fi
}

print_rpmtemplate_kmodmetapkg ()
{
		local kernel_uname_r=${1}
		local kernel_variant="${2:+-${2}}"

		cat <<EOF
%package      -n kmod-${kmodname}${kernel_variant}
Summary:         Metapackage which tracks in ${kmodname} kernel module for newest kernel${kernel_variant}
Group:           System Environment/Kernel

Provides:        ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
Requires:        kmod-${kmodname}-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}
%{?KmodsMetaRequires:Requires: %{?KmodsMetaRequires}}
EOF

		if [[ ${obsolete_name} ]]; then
			echo "Provides:        kmod-${obsolete_name}${kernel_variant} = ${obsolete_version}"
			echo "Obsoletes:       kmod-${obsolete_name}${kernel_variant} < ${obsolete_version}"
		fi

		cat <<EOF

%description  -n kmod-${kmodname}${kernel_variant}
This is a meta-package without payload which sole purpose is to require the
${kmodname} kernel module(s) for the newest kernel${kernel_variant}.
to make sure you get it together with a new kernel.

%files        -n kmod-${kmodname}${kernel_variant}
%defattr(644,root,root,755)


EOF
}

print_customrpmtemplate ()
{
	for kernel in ${1}
	do
		if [[ -e "${buildroot}/usr/src/kernels/${kernel}" ]] ; then
			# this looks like a Fedora/RH kernel -- print a normal template (which includes the proper BR) and be happy :)
			kernel_versions="${kernel_versions}${kernel}___${buildroot}%{_usrsrc}/kernels/${kernel} "

			# parse kernel versions string and print template
			local kernel_verrelarch=${kernel%%${kernels_known_variants}}
			print_rpmtemplate_per_kmodpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}

			# create development package
			if [[ "${devel}" ]]; then
				# create devel package including common headers
				print_rpmtemplate_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}

				# create devel package
				print_rpmtemplate_per_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
			fi
		elif [[ -e ${prefix}/lib/modules/"${kernel}"/build/Makefile ]] ; then 
			# likely a user-build-kernel with available buildfiles
			# fixme: we should check if uname from Makefile is the same as ${kernel}

			kernel_versions="${kernel_versions}${kernel}___${prefix}/lib/modules/${kernel}/build/ "
			print_rpmtemplate_per_kmodpkg --custom "${kernel}"

			# create development package
			if [[ "${devel}" ]]; then
				# create devel package including common headers
				print_rpmtemplate_kmoddevelpkg --custom "${kernel}"

				# create devel package
				print_rpmtemplate_per_kmoddevelpkg --custom "${kernel}"
			fi
		else
			error_out 2 "Don't know how to handle ${kernel} -- ${prefix}/lib/modules/${kernel}/build/Makefile not found"
		fi
	done

	# well, it's no header anymore, but who cares ;-)
	print_rpmtemplate_header
}


print_rpmtemplate ()
{
	# create kernel_versions var
	for kernel_version in ${kernel_versions_to_build_for}
	do
		kernel_versions="${kernel_versions}${kernel_version}___%{_usrsrc}/kernels/${kernel_version} "
	done

	# and print it and some other required stuff as macro
	print_rpmtemplate_header

	# now print the packages itselfs
	for kernel in ${kernel_versions_to_build_for} ; do

		local kernel_verrelarch=${kernel%%${kernels_known_variants}}

		# create metapackage 
		print_rpmtemplate_kmodmetapkg ${kernel} ${kernel##${kernel_verrelarch}}

		# create package
		print_rpmtemplate_per_kmodpkg ${kernel} ${kernel##${kernel_verrelarch}}

		if [[ "${devel}" ]]; then
			# create devel package including common headers
			print_rpmtemplate_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}

			# create devel package
			print_rpmtemplate_per_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}
		fi
	done
}

myprog_help ()
{
	echo "Usage: $(basename ${0}) [OPTIONS]"
	echo $'\n'"Creates a template to be used during kmod building"
	echo $'\n'"Available options:"
	echo " --filterfile <file>  -- filter the results with grep --file <file>"
	echo " --for-kernels <list> -- created templates only for these kernels"
	echo " --kmodname <file>    -- name of the kmod (required)"
	echo " --devel              -- make kmod-devel package"
	echo " --noakmod            -- no akmod package"
	echo " --repo <name>        -- use buildsys-build-<name>-kerneldevpkgs"
	echo " --target <arch>      -- target-arch (required)"
	echo " --buildroot <dir>    -- Build root (place to look for build files)"
}

while [ "${1}" ] ; do
	case "${1}" in
		--filterfile)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide path to a filter-file together with --filterfile" >&2
			elif [[ ! -e "${1}" ]]; then	
				error_out 2 "Filterfile ${1} not found" >&2
			fi
			filterfile="${1}"
			shift
			;;
		--kmodname)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	 	    fi
			# strip pending -kmod
			kmodname="${1%%-kmod}"
			shift
			;;
		--devel)
			shift
			devel="true"
			;;
		--prefix)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide a prefix with --prefix" >&2
		    fi
			prefix="${1}"
			shift
			;;
		--repo)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide the name of the repo together with --repo" >&2
	 	    fi
			repo=${1}
			shift
			;;
		--for-kernels)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	 		fi
			for_kernels="${1}"
			shift
			;;
		--noakmod)
			shift
			noakmod="true"
			;;
		--obsolete-name)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide the name of the kmod to obsolte together with --obsolete-name" >&2
	 		fi
			obsolete_name="${1}"
			shift
			;;
		--obsolete-version)
			shift
			if [[ ! "${1}" ]] ; then
				error_out 2 "Please provide the version of the kmod to obsolte together with --obsolete-version" >&2
	 		fi
			obsolete_version="${1}"
			shift
			;;
		--target)
			shift
			target="${1}"
			shift
			;;
		--akmod)
			shift
			build_kernels="akmod"
			;;
		--newest)
			shift
			build_kernels="newest"
			;;
		--current)
			shift
			build_kernels="current"
			;;
		--buildroot)
			shift
			buildroot="${1}"
			shift
			;;
		--help)
			myprog_help
			exit 0
			;;
		--version)
			echo "${myprog} ${myver}"
			exit 0
			;;
		*)
			echo "Error: Unknown option '${1}'." >&2
			usage >&2
			exit 2
			;;
	esac
done

if [[ -e ./kmodtool-kernel-variants ]]; then
	kernels_known_variants="$(cat ./kmodtool-kernel-variants)"
elif [[ -e /usr/share/kmodtool/kernel-variants ]] ; then
	kernels_known_variants="$(cat /usr/share/kmodtool/kernel-variants)"
else
	kernels_known_variants="@(smp?(-debug)|PAE?(-debug)|debug|kdump|xen|kirkwood|highbank|imx|omap|tegra)"
fi

# general sanity checks
if [[ ! "${target}" ]]; then
		error_out 2 "please pass target arch with --target"
elif [[ ! "${kmodname}" ]]; then
		error_out 2 "please pass kmodname with --kmodname"
elif [[ ! "${kernels_known_variants}" ]] ; then
		error_out 2 "could not determine known variants"
elif ( [[ "${obsolete_name}" ]] && [[ ! "${obsolete_version}" ]] ) ||  ( [[ ! "${obsolete_name}" ]] && [[ "${obsolete_version}" ]] ) ; then
		error_out 2 "you need to provide both --obsolete-name and --obsolete-version"
fi

# go
if [[ "${for_kernels}" ]]; then
	# this is easy:
	print_customrpmtemplate "${for_kernels}"
elif [[ "${build_kernels}" == "akmod" ]]; then
	# do only a akmod package
	print_akmodtemplate
	print_akmodmeta
else
	# seems we are on out own to decide for which kernels to build

	# we need more sanity checks in this case
	if [[ ! "${repo}" ]]; then
		error_out 2 "please provide repo name with --repo"
	elif ! $(which buildsys-build-${repo}-kerneldevpkgs &> /dev/null) ; then
		error_out 2 "buildsys-build-${repo}-kerneldevpkgs not found"
	fi

	# call buildsys-build-${repo}-kerneldevpkgs to get the list of kernels
	cmdoptions="--target ${target}"

	# filterfile to filter list of kernels?	
	if [[ "${filterfile}" ]] ; then
		 cmdoptions="${cmdoptions} --filterfile ${filterfile}"
	fi

	kernel_versions_to_build_for="$(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
	returncode=$?
	if (( ${returncode} != 0 )); then
		error_out 2 "buildsys-build-${repo}-kerneldevpkgs failed: $(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
	fi

	if [[ "${build_kernels}" == "current" ]] && [[ ! "${noakmod}" ]]; then
		print_akmodtemplate
	fi

	print_rpmtemplate 
fi
Commit	Line	Data
f3757573 BB	1	#!/bin/bash
	2
	3	# kmodtool - Helper script for building kernel module RPMs
	4	# Copyright (c) 2003-2012 Ville Skyttä <ville.skytta@iki.fi>,
	5	# Thorsten Leemhuis <fedora@leemhuis.info>
	6	# Nicolas Chauvet <kwizart@gmail.com>
	7	#
	8	# Permission is hereby granted, free of charge, to any person obtaining
	9	# a copy of this software and associated documentation files (the
	10	# "Software"), to deal in the Software without restriction, including
	11	# without limitation the rights to use, copy, modify, merge, publish,
	12	# distribute, sublicense, and/or sell copies of the Software, and to
	13	# permit persons to whom the Software is furnished to do so, subject to
	14	# the following conditions:
	15	#
	16	# The above copyright notice and this permission notice shall be
	17	# included in all copies or substantial portions of the Software.
	18	#
	19	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	20	# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	21	# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	22	# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	23	# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	24	# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	25	# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	26
	27	shopt -s extglob
	28
	29	myprog="kmodtool-${repo}"
	30	myver="0.12.1"
	31
	32	kmodname=
	33	build_kernels="current"
	34	kernels_known_variants=
	35	kernel_versions=
	36	kernel_versions_to_build_for=
	37	prefix=
	38	filterfile=
	39	target=
389cf730	40	buildroot=
f3757573 BB	41
	42	error_out()
	43	{
	44	local errorlevel=${1}
	45	shift
	46	echo "Error: $@" >&2
	47	# the next line is not multi-line safe -- not needed yet
	48	echo "%global kmodtool_check echo \"kmodtool error: $@\"; exit ${errorlevel};"
	49	exit ${errorlevel}
	50	}
	51
	52	print_rpmtemplate_header()
	53	{
	54	echo
	55	echo '%global kmodinstdir_prefix '${prefix}/lib/modules/
	56	echo '%global kmodinstdir_postfix '/extra/${kmodname}/
	57	echo '%global kernel_versions '${kernel_versions}
	58	echo
	59	}
	60
	61	print_akmodtemplate ()
	62	{
	63	echo
	64	cat <<EOF
	65
	66	%global akmod_install mkdir -p \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/; \\\
0f629346	67	LANG=C rpmbuild --define "_sourcedir %{_sourcedir}" \\\
f3757573 BB	68	--define "_srcrpmdir \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/" \\\
	69	-bs --nodeps %{_specdir}/%{name}.spec ; \\\
	70	ln -s \$(ls \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/) \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/${kmodname}-kmod.latest
	71
	72	%package -n akmod-${kmodname}
	73	Summary: Akmod package for ${kmodname} kernel module(s)
	74	Group: System Environment/Kernel
	75	Requires: kmodtool
	76	Requires: akmods
	77	%{?AkmodsBuildRequires:Requires: %{AkmodsBuildRequires}}
	78	# same requires and provides as a kmods package would have
	79	Requires: ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
	80	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	81	EOF
	82
	83	if [[ ${obsolete_name} ]]; then
	84	echo "Provides: akmod-${obsolete_name} = ${obsolete_version}"
	85	echo "Obsoletes: akmod-${obsolete_name} < ${obsolete_version}"
	86	fi
	87
	88	cat <<EOF
	89
	90	%description -n akmod-${kmodname}
	91	This package provides the akmod package for the ${kmodname} kernel modules.
	92
	93	%posttrans -n akmod-${kmodname}
	94	nohup ${prefix}/sbin/akmods --from-akmod-posttrans --akmod ${kmodname} &> /dev/null &
	95
	96	%files -n akmod-${kmodname}
	97	%defattr(-,root,root,-)
	98	%{_usrsrc}/akmods/*
	99
	100	EOF
	101	}
	102
	103	print_akmodmeta ()
	104	{
	105	cat <<EOF
	106	%package -n kmod-${kmodname}
	107	Summary: Metapackage which tracks in ${kmodname} kernel module for newest kernel${dashvariant}
	108	Group: System Environment/Kernel
	109
	110	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	111	Provides: kmod-${kmodname}-xen = %{?epoch:%{epoch}:}%{version}-%{release}
	112	Provides: kmod-${kmodname}-smp = %{?epoch:%{epoch}:}%{version}-%{release}
	113	Provides: kmod-${kmodname}-PAE = %{?epoch:%{epoch}:}%{version}-%{release}
	114	Requires: akmod-${kmodname} = %{?epoch:%{epoch}:}%{version}-%{release}
	115	EOF
	116
	117	if [[ ${obsolete_name} ]]; then
	118	echo "Provides: kmod-${obsolete_name} = ${obsolete_version}"
	119	echo "Obsoletes: kmod-${obsolete_name} < ${obsolete_version}"
	120	fi
	121	cat <<EOF
	122
	123	%description -n kmod-${kmodname}${dashvariant}
	124	This is a meta-package without payload which sole purpose is to require the
	125	${kmodname} kernel module(s) for the newest kernel${dashvariant},
	126	to make sure you get it together with a new kernel.
	127
	128	%files -n kmod-${kmodname}${dashvariant}
	129	%defattr(644,root,root,755)
	130	EOF
	131	}
132
133	print_rpmtemplate_per_kmodpkg ()
134	{
135	if [[ "${1}" == "--custom" ]]; then
136	shift
137	local customkernel=true
138	elif [[ "${1}" == "--redhat" ]]; then
139	# this is needed for akmods
140	shift
141	local redhatkernel=true
142	fi
143
144	local kernel_uname_r=${1}
145	local kernel_variant="${2:+-${2}}"
146
147	# first part
148	cat <<EOF
149	%package -n kmod-${kmodname}-${kernel_uname_r}
150	Summary: ${kmodname} kernel module(s) for ${kernel_uname_r}
151	Group: System Environment/Kernel
152	Provides: kernel-modules-for-kernel = ${kernel_uname_r}
153	Provides: kmod-${kmodname}-uname-r = ${kernel_uname_r}
154	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
155	Requires: ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
156	Requires(post): ${prefix}/sbin/depmod
157	Requires(postun): ${prefix}/sbin/depmod
f3757573 BB	158	EOF
	159
	160	if [[ ${obsolete_name} ]]; then
	161	echo "Provides: kmod-${obsolete_name}-${kernel_uname_r} = ${obsolete_version}"
	162	echo "Obsoletes: kmod-${obsolete_name}-${kernel_uname_r} < ${obsolete_version}"
	163	fi
	164
	165	# second part
	166	if [[ ! "${customkernel}" ]]; then
	167	cat <<EOF
	168	Requires: kernel-uname-r = ${kernel_uname_r}
	169	BuildRequires: kernel-devel-uname-r = ${kernel_uname_r}
cb79a4e8 BB	170	%{?KmodsRequires:Requires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
cb79a4e8 BB	171	%{?KmodsRequires:BuildRequires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
f3757573 BB	172	%post -n kmod-${kmodname}-${kernel_uname_r}
	173	${prefix}/sbin/depmod -aeF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} > /dev/null \|\| :
	174	%postun -n kmod-${kmodname}-${kernel_uname_r}
	175	${prefix}/sbin/depmod -aF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} &> /dev/null \|\| :
	176
	177	EOF
	178	else
	179	cat <<EOF
	180	%post -n kmod-${kmodname}-${kernel_uname_r}
	181	[[ "$(uname -r)" == "${kernel_uname_r}" ]] && ${prefix}/sbin/depmod -a > /dev/null \|\| :
	182	%postun -n kmod-${kmodname}-${kernel_uname_r}
	183	[[ "$(uname -r)" == "${kernel_uname_r}" ]] && ${prefix}/sbin/depmod -a > /dev/null \|\| :
	184
	185	EOF
	186	fi
	187
	188	# third part
	189	cat <<EOF
	190	%description -n kmod-${kmodname}-${kernel_uname_r}
	191	This package provides the ${kmodname} kernel modules built for the Linux
	192	kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
	193	%files -n kmod-${kmodname}-${kernel_uname_r}
	194	%defattr(644,root,root,755)
	195	%dir $prefix/lib/modules/${kernel_uname_r}/extra
	196	${prefix}/lib/modules/${kernel_uname_r}/extra/${kmodname}/
	197
	198
	199	EOF
	200	}
	201
	202	print_rpmtemplate_kmoddevelpkg ()
	203	{
cb79a4e8 BB	204	if [[ "${1}" == "--custom" ]]; then
	205	shift
	206	local customkernel=true
	207	elif [[ "${1}" == "--redhat" ]]; then
	208	shift
	209	local redhatkernel=true
	210	fi
	211
	212	local kernel_uname_r=${1}
	213
f3757573 BB	214	cat <<EOF
	215	%package -n kmod-${kmodname}-devel
	216	Summary: ${kmodname} kernel module(s) devel common
	217	Group: System Environment/Kernel
cb79a4e8 BB	218	Provides: ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	219	EOF
	220
	221	if [[ ! ${customkernel} ]] && [[ ! ${redhatkernel} ]]; then
	222	echo "Requires: kmod-${kmodname}-devel-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}"
	223	fi
f3757573	224
cb79a4e8 BB	225	if [[ ${obsolete_name} ]]; then
	226	echo "Provides: kmod-${obsolete_name}-devel = ${obsolete_version}"
	227	echo "Obsoletes: kmod-${obsolete_name}-devel < ${obsolete_version}"
	228	fi
	229
	230	cat <<EOF
f3757573 BB	231	%description -n kmod-${kmodname}-devel
f3757573 BB	232	This package provides the common header files to build kernel modules
cb79a4e8 BB	233	which depend on the ${kmodname} kernel module. It may optionally require
	234	the ${kmodname}-devel-<kernel> objects for the newest kernel.
	235
f3757573 BB	236	%files -n kmod-${kmodname}-devel
	237	%defattr(644,root,root,755)
	238	%{_usrsrc}/${kmodname}-%{version}
	239	EOF
93ce2b4c BB	240	if [[ ${obsolete_name} ]]; then
	241	echo "%{_usrsrc}/${obsolete_name}-%{version}"
	242	fi
f3757573 BB	243
	244	for kernel in ${1}; do
	245	local kernel_uname_r=${kernel}
	246	echo "%exclude %{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}"
93ce2b4c BB	247	if [[ ${obsolete_name} ]]; then
	248	echo "%exclude %{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
	249	fi
f3757573 BB	250	done
	251
	252	echo
	253	echo
	254	}
	255
	256	print_rpmtemplate_per_kmoddevelpkg ()
	257	{
	258	if [[ "${1}" == "--custom" ]]; then
	259	shift
	260	local customkernel=true
	261	elif [[ "${1}" == "--redhat" ]]; then
	262	# this is needed for akmods
	263	shift
	264	local redhatkernel=true
	265	fi
	266
	267	local kernel_uname_r=${1}
	268	local kernel_variant="${2:+-${2}}"
	269
cb79a4e8	270	# first part
f3757573 BB	271	cat <<EOF
	272	%package -n kmod-${kmodname}-devel-${kernel_uname_r}
	273	Summary: ${kmodname} kernel module(s) devel for ${kernel_uname_r}
	274	Group: System Environment/Kernel
cb79a4e8	275	Provides: kernel-objects-for-kernel = ${kernel_uname_r}
0df23ca9	276	Provides: ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
cb79a4e8	277	Provides: kmod-${kmodname}-devel-uname-r = ${kernel_uname_r}
f3757573 BB	278	EOF
f3757573 BB	279
cb79a4e8 BB	280	if [[ ${obsolete_name} ]]; then
	281	echo "Provides: kmod-${obsolete_name}-devel-${kernel_uname_r} = ${obsolete_version}"
	282	echo "Obsoletes: kmod-${obsolete_name}-devel-${kernel_uname_r} < ${obsolete_version}"
	283	fi
	284
f3757573 BB	285	# second part
	286	if [[ ! "${customkernel}" ]]; then
	287	cat <<EOF
cb79a4e8	288	Requires: kernel-devel-uname-r = ${kernel_uname_r}
f3757573	289	BuildRequires: kernel-devel-uname-r = ${kernel_uname_r}
cb79a4e8 BB	290	%{?KmodsDevelRequires:Requires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
cb79a4e8 BB	291	%{?KmodsDevelRequires:BuildRequires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
f3757573 BB	292	EOF
	293	fi
	294
cb79a4e8	295	# third part
f3757573 BB	296	cat <<EOF
	297	%description -n kmod-${kmodname}-devel-${kernel_uname_r}
	298	This package provides objects and symbols required to build kernel modules
	299	which depend on the ${kmodname} kernel modules built for the Linux
	300	kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
	301	%files -n kmod-${kmodname}-devel-${kernel_uname_r}
	302	%defattr(644,root,root,755)
	303	%{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}
f3757573	304	EOF
93ce2b4c BB	305	if [[ ${obsolete_name} ]]; then
	306	echo "%{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
	307	fi
f3757573 BB	308	}
	309
	310	print_rpmtemplate_kmodmetapkg ()
	311	{
	312	local kernel_uname_r=${1}
	313	local kernel_variant="${2:+-${2}}"
	314
	315	cat <<EOF
	316	%package -n kmod-${kmodname}${kernel_variant}
	317	Summary: Metapackage which tracks in ${kmodname} kernel module for newest kernel${kernel_variant}
	318	Group: System Environment/Kernel
	319
	320	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	321	Requires: kmod-${kmodname}-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}
cb79a4e8	322	%{?KmodsMetaRequires:Requires: %{?KmodsMetaRequires}}
f3757573	323	EOF
cb79a4e8	324
f3757573 BB	325	if [[ ${obsolete_name} ]]; then
	326	echo "Provides: kmod-${obsolete_name}${kernel_variant} = ${obsolete_version}"
	327	echo "Obsoletes: kmod-${obsolete_name}${kernel_variant} < ${obsolete_version}"
	328	fi
	329
	330	cat <<EOF
	331
	332	%description -n kmod-${kmodname}${kernel_variant}
	333	This is a meta-package without payload which sole purpose is to require the
	334	${kmodname} kernel module(s) for the newest kernel${kernel_variant}.
	335	to make sure you get it together with a new kernel.
	336
	337	%files -n kmod-${kmodname}${kernel_variant}
	338	%defattr(644,root,root,755)
	339
	340
	341	EOF
	342	}
	343
	344	print_customrpmtemplate ()
	345	{
	346	for kernel in ${1}
	347	do
389cf730	348	if [[ -e "${buildroot}/usr/src/kernels/${kernel}" ]] ; then
f3757573	349	# this looks like a Fedora/RH kernel -- print a normal template (which includes the proper BR) and be happy :)
389cf730	350	kernel_versions="${kernel_versions}${kernel}___${buildroot}%{_usrsrc}/kernels/${kernel} "
f3757573 BB	351
	352	# parse kernel versions string and print template
	353	local kernel_verrelarch=${kernel%%${kernels_known_variants}}
	354	print_rpmtemplate_per_kmodpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
	355
	356	# create development package
	357	if [[ "${devel}" ]]; then
cb79a4e8 BB	358	# create devel package including common headers
	359	print_rpmtemplate_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
	360
	361	# create devel package
f3757573 BB	362	print_rpmtemplate_per_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
	363	fi
	364	elif [[ -e ${prefix}/lib/modules/"${kernel}"/build/Makefile ]] ; then
	365	# likely a user-build-kernel with available buildfiles
	366	# fixme: we should check if uname from Makefile is the same as ${kernel}
	367
	368	kernel_versions="${kernel_versions}${kernel}___${prefix}/lib/modules/${kernel}/build/ "
	369	print_rpmtemplate_per_kmodpkg --custom "${kernel}"
	370
	371	# create development package
	372	if [[ "${devel}" ]]; then
cb79a4e8 BB	373	# create devel package including common headers
	374	print_rpmtemplate_kmoddevelpkg --custom "${kernel}"
	375
	376	# create devel package
f3757573 BB	377	print_rpmtemplate_per_kmoddevelpkg --custom "${kernel}"
	378	fi
	379	else
	380	error_out 2 "Don't know how to handle ${kernel} -- ${prefix}/lib/modules/${kernel}/build/Makefile not found"
	381	fi
	382	done
	383
f3757573 BB	384	# well, it's no header anymore, but who cares ;-)
	385	print_rpmtemplate_header
	386	}
	387
	388
	389	print_rpmtemplate ()
	390	{
	391	# create kernel_versions var
	392	for kernel_version in ${kernel_versions_to_build_for}
	393	do
	394	kernel_versions="${kernel_versions}${kernel_version}___%{_usrsrc}/kernels/${kernel_version} "
	395	done
	396
	397	# and print it and some other required stuff as macro
	398	print_rpmtemplate_header
	399
	400	# now print the packages itselfs
	401	for kernel in ${kernel_versions_to_build_for} ; do
	402
	403	local kernel_verrelarch=${kernel%%${kernels_known_variants}}
	404
	405	# create metapackage
	406	print_rpmtemplate_kmodmetapkg ${kernel} ${kernel##${kernel_verrelarch}}
	407
	408	# create package
	409	print_rpmtemplate_per_kmodpkg ${kernel} ${kernel##${kernel_verrelarch}}
	410
f3757573	411	if [[ "${devel}" ]]; then
cb79a4e8 BB	412	# create devel package including common headers
	413	print_rpmtemplate_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}
	414
	415	# create devel package
f3757573 BB	416	print_rpmtemplate_per_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}
	417	fi
	418	done
f3757573 BB	419	}
	420
	421	myprog_help ()
	422	{
	423	echo "Usage: $(basename ${0}) [OPTIONS]"
	424	echo $'\n'"Creates a template to be used during kmod building"
	425	echo $'\n'"Available options:"
f3757573 BB	426	echo " --filterfile <file> -- filter the results with grep --file <file>"
	427	echo " --for-kernels <list> -- created templates only for these kernels"
	428	echo " --kmodname <file> -- name of the kmod (required)"
	429	echo " --devel -- make kmod-devel package"
	430	echo " --noakmod -- no akmod package"
	431	echo " --repo <name> -- use buildsys-build-<name>-kerneldevpkgs"
	432	echo " --target <arch> -- target-arch (required)"
389cf730	433	echo " --buildroot <dir> -- Build root (place to look for build files)"
f3757573 BB	434	}
	435
	436	while [ "${1}" ] ; do
	437	case "${1}" in
	438	--filterfile)
	439	shift
	440	if [[ ! "${1}" ]] ; then
	441	error_out 2 "Please provide path to a filter-file together with --filterfile" >&2
	442	elif [[ ! -e "${1}" ]]; then
	443	error_out 2 "Filterfile ${1} not found" >&2
	444	fi
	445	filterfile="${1}"
	446	shift
	447	;;
	448	--kmodname)
	449	shift
	450	if [[ ! "${1}" ]] ; then
	451	error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	452	fi
	453	# strip pending -kmod
	454	kmodname="${1%%-kmod}"
	455	shift
	456	;;
	457	--devel)
	458	shift
	459	devel="true"
	460	;;
	461	--prefix)
	462	shift
	463	if [[ ! "${1}" ]] ; then
	464	error_out 2 "Please provide a prefix with --prefix" >&2
	465	fi
	466	prefix="${1}"
	467	shift
	468	;;
	469	--repo)
	470	shift
	471	if [[ ! "${1}" ]] ; then
	472	error_out 2 "Please provide the name of the repo together with --repo" >&2
	473	fi
	474	repo=${1}
	475	shift
	476	;;
	477	--for-kernels)
	478	shift
	479	if [[ ! "${1}" ]] ; then
	480	error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	481	fi
	482	for_kernels="${1}"
	483	shift
	484	;;
	485	--noakmod)
	486	shift
	487	noakmod="true"
	488	;;
	489	--obsolete-name)
	490	shift
	491	if [[ ! "${1}" ]] ; then
	492	error_out 2 "Please provide the name of the kmod to obsolte together with --obsolete-name" >&2
	493	fi
	494	obsolete_name="${1}"
	495	shift
	496	;;
	497	--obsolete-version)
498	shift
499	if [[ ! "${1}" ]] ; then
500	error_out 2 "Please provide the version of the kmod to obsolte together with --obsolete-version" >&2
501	fi
502	obsolete_version="${1}"
503	shift
504	;;
505	--target)
506	shift
507	target="${1}"
508	shift
509	;;
510	--akmod)
511	shift
512	build_kernels="akmod"
513	;;
514	--newest)
515	shift
516	build_kernels="newest"
517	;;
518	--current)
519	shift
520	build_kernels="current"
521	;;
389cf730 NC	522	--buildroot)
	523	shift
	524	buildroot="${1}"
	525	shift
	526	;;
f3757573 BB	527	--help)
	528	myprog_help
	529	exit 0
	530	;;
	531	--version)
	532	echo "${myprog} ${myver}"
	533	exit 0
	534	;;
	535	*)
	536	echo "Error: Unknown option '${1}'." >&2
	537	usage >&2
	538	exit 2
	539	;;
	540	esac
	541	done
	542
	543	if [[ -e ./kmodtool-kernel-variants ]]; then
	544	kernels_known_variants="$(cat ./kmodtool-kernel-variants)"
	545	elif [[ -e /usr/share/kmodtool/kernel-variants ]] ; then
	546	kernels_known_variants="$(cat /usr/share/kmodtool/kernel-variants)"
	547	else
	548	kernels_known_variants="@(smp?(-debug)\|PAE?(-debug)\|debug\|kdump\|xen\|kirkwood\|highbank\|imx\|omap\|tegra)"
	549	fi
	550
	551	# general sanity checks
	552	if [[ ! "${target}" ]]; then
	553	error_out 2 "please pass target arch with --target"
	554	elif [[ ! "${kmodname}" ]]; then
	555	error_out 2 "please pass kmodname with --kmodname"
	556	elif [[ ! "${kernels_known_variants}" ]] ; then
	557	error_out 2 "could not determine known variants"
	558	elif ( [[ "${obsolete_name}" ]] && [[ ! "${obsolete_version}" ]] ) \|\| ( [[ ! "${obsolete_name}" ]] && [[ "${obsolete_version}" ]] ) ; then
	559	error_out 2 "you need to provide both --obsolete-name and --obsolete-version"
	560	fi
	561
	562	# go
	563	if [[ "${for_kernels}" ]]; then
	564	# this is easy:
	565	print_customrpmtemplate "${for_kernels}"
	566	elif [[ "${build_kernels}" == "akmod" ]]; then
	567	# do only a akmod package
	568	print_akmodtemplate
	569	print_akmodmeta
	570	else
	571	# seems we are on out own to decide for which kernels to build
	572
	573	# we need more sanity checks in this case
	574	if [[ ! "${repo}" ]]; then
	575	error_out 2 "please provide repo name with --repo"
	576	elif ! $(which buildsys-build-${repo}-kerneldevpkgs &> /dev/null) ; then
	577	error_out 2 "buildsys-build-${repo}-kerneldevpkgs not found"
	578	fi
	579
	580	# call buildsys-build-${repo}-kerneldevpkgs to get the list of kernels
	581	cmdoptions="--target ${target}"
	582
	583	# filterfile to filter list of kernels?
	584	if [[ "${filterfile}" ]] ; then
	585	cmdoptions="${cmdoptions} --filterfile ${filterfile}"
	586	fi
	587
	588	kernel_versions_to_build_for="$(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
	589	returncode=$?
	590	if (( ${returncode} != 0 )); then
591	error_out 2 "buildsys-build-${repo}-kerneldevpkgs failed: $(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
592	fi
593
594	if [[ "${build_kernels}" == "current" ]] && [[ ! "${noakmod}" ]]; then
595	print_akmodtemplate
596	fi
597
598	print_rpmtemplate
599	fi