1 files changed, 300 insertions, 209 deletions

diff --git a/meta/classes/kernel-yocto.bbclass b/meta/classes/kernel-yocto.bbclass
index c6425b2b69..50226f6d49 100644
--- a/meta/classes/kernel-yocto.bbclass
+++ b/meta/classes/kernel-yocto.bbclass
@@ -1,50 +1,69 @@
-S = "${WORKDIR}/linux"
-
 # remove tasks that modify the source tree in case externalsrc is inherited
-SRCTREECOVEREDTASKS += "do_kernel_link_vmlinux do_kernel_configme do_validate_branches do_kernel_configcheck do_kernel_checkout do_patch"
+SRCTREECOVEREDTASKS += "do_kernel_configme do_validate_branches do_kernel_configcheck do_kernel_checkout do_fetch do_unpack do_patch"
+PATCH_GIT_USER_EMAIL ?= "kernel-yocto@oe"
+PATCH_GIT_USER_NAME ?= "OpenEmbedded"
 
 # returns local (absolute) path names for all valid patches in the
 # src_uri
 def find_patches(d):
-	patches=src_patches(d)
-	patch_list=[]
-	for p in patches:
-	    _, _, local, _, _, _ = bb.decodeurl(p)
- 	    patch_list.append(local)
+    patches = src_patches(d)
+    patch_list=[]
+    for p in patches:
+        _, _, local, _, _, _ = bb.fetch.decodeurl(p)
+        patch_list.append(local)
 
-	return patch_list
+    return patch_list
 
 # returns all the elements from the src uri that are .scc files
 def find_sccs(d):
-	sources=src_patches(d, True)
-	sources_list=[]
-	for s in sources:
-		base, ext = os.path.splitext(os.path.basename(s))
-		if ext and ext in ('.scc' '.cfg'):
-			sources_list.append(s)
-		elif base and base in 'defconfig':
-			sources_list.append(s)
-
-	return sources_list
-
-# this is different from find_patches, in that it returns a colon separated
-# list of <patches>:<subdir> instead of just a list of patches
-def find_urls(d):
-	patches=src_patches(d)
-	fetch = bb.fetch2.Fetch([], d)
-	patch_list=[]
-	for p in patches:
-		_, _, local, _, _, _ = bb.decodeurl(p)
-		for url in fetch.urls:
-			urldata = fetch.ud[url]
-			if urldata.localpath == local:
-				patch_list.append(local+':'+urldata.path)
-
-        return patch_list
-
-
-do_patch() {
+    sources=src_patches(d, True)
+    sources_list=[]
+    for s in sources:
+        base, ext = os.path.splitext(os.path.basename(s))
+        if ext and ext in [".scc", ".cfg"]:
+            sources_list.append(s)
+        elif base and base in 'defconfig':
+            sources_list.append(s)
+
+    return sources_list
+
+# check the SRC_URI for "kmeta" type'd git repositories. Return the name of
+# the repository as it will be found in WORKDIR
+def find_kernel_feature_dirs(d):
+    feature_dirs=[]
+    fetch = bb.fetch2.Fetch([], d)
+    for url in fetch.urls:
+        urldata = fetch.ud[url]
+        parm = urldata.parm
+        type=""
+        if "type" in parm:
+            type = parm["type"]
+        if "destsuffix" in parm:
+            destdir = parm["destsuffix"]
+            if type == "kmeta":
+                feature_dirs.append(destdir)
+	    
+    return feature_dirs
+
+# find the master/machine source branch. In the same way that the fetcher proceses
+# git repositories in the SRC_URI we take the first repo found, first branch.
+def get_machine_branch(d, default):
+    fetch = bb.fetch2.Fetch([], d)
+    for url in fetch.urls:
+        urldata = fetch.ud[url]
+        parm = urldata.parm
+        if "branch" in parm:
+            branches = urldata.parm.get("branch").split(',')
+            btype = urldata.parm.get("type")
+            if btype != "kmeta":
+                return branches[0]
+	    
+    return default
+
+do_kernel_metadata() {
+	set +e
 	cd ${S}
+	export KMETA=${KMETA}
 
 	# if kernel tools are available in-tree, they are preferred
 	# and are placed on the path before any external tools. Unless
@@ -55,91 +74,169 @@ do_patch() {
 		fi
 	fi
 
-	kbranch=${KBRANCH}
-
-	# if we have a defined/set meta branch we should not be generating
-	# any meta data. The passed branch has what we need.
-	if [ -n "${KMETA}" ]; then
-		createme_flags="--disable-meta-gen"
+	machine_branch="${@ get_machine_branch(d, "${KBRANCH}" )}"
+	machine_srcrev="${SRCREV_machine}"
+	if [ -z "${machine_srcrev}" ]; then
+		# fallback to SRCREV if a non machine_meta tree is being built
+		machine_srcrev="${SRCREV}"
 	fi
-	createme ${createme_flags} ${ARCH} ${kbranch}
-	if [ $? -ne 0 ]; then
-		echo "ERROR. Could not create ${kbranch}"
-		exit 1
+
+	# In a similar manner to the kernel itself:
+	#
+	#   defconfig: $(obj)/conf
+	#   ifeq ($(KBUILD_DEFCONFIG),)
+	#	$< --defconfig $(Kconfig)
+	#   else
+	#	@echo "*** Default configuration is based on '$(KBUILD_DEFCONFIG)'"
+	#	$(Q)$< --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
+	#   endif
+	#
+	# If a defconfig is specified via the KBUILD_DEFCONFIG variable, we copy it
+	# from the source tree, into a common location and normalized "defconfig" name,
+	# where the rest of the process will include and incoroporate it into the build
+	#
+	# If the fetcher has already placed a defconfig in WORKDIR (from the SRC_URI),
+	# we don't overwrite it, but instead warn the user that SRC_URI defconfigs take
+	# precendence.
+	#
+	if [ -n "${KBUILD_DEFCONFIG}" ]; then
+		if [ -f "${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG}" ]; then
+			if [ -f "${WORKDIR}/defconfig" ]; then
+				# If the two defconfig's are different, warn that we didn't overwrite the
+				# one already placed in WORKDIR by the fetcher.
+				cmp "${WORKDIR}/defconfig" "${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG}"
+				if [ $? -ne 0 ]; then
+					bbwarn "defconfig detected in WORKDIR. ${KBUILD_DEFCONFIG} skipped"
+				fi
+			else
+				cp -f ${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG} ${WORKDIR}/defconfig
+				sccs="${WORKDIR}/defconfig"
+			fi
+		else
+			bbfatal "A KBUILD_DECONFIG '${KBUILD_DEFCONFIG}' was specified, but not present in the source tree"
+		fi
 	fi
 
-	sccs="${@" ".join(find_sccs(d))}"
+	sccs="$sccs ${@" ".join(find_sccs(d))}"
 	patches="${@" ".join(find_patches(d))}"
+	feat_dirs="${@" ".join(find_kernel_feature_dirs(d))}"
+
+	# check for feature directories/repos/branches that were part of the
+	# SRC_URI. If they were supplied, we convert them into include directives
+	# for the update part of the process
+	for f in ${feat_dirs}; do
+		if [ -d "${WORKDIR}/$f/meta" ]; then
+			includes="$includes -I${WORKDIR}/$f/kernel-meta"
+	        elif [ -d "${WORKDIR}/$f" ]; then
+			includes="$includes -I${WORKDIR}/$f"
+		fi
+	done
+	for s in ${sccs} ${patches}; do
+		sdir=$(dirname $s)
+		includes="$includes -I${sdir}"
+                # if a SRC_URI passed patch or .scc has a subdir of "kernel-meta",
+                # then we add it to the search path
+                if [ -d "${sdir}/kernel-meta" ]; then
+			includes="$includes -I${sdir}/kernel-meta"
+                fi
+	done
 
-	set +e
-	# add any explicitly referenced features onto the end of the feature
-	# list that is passed to the kernel build scripts.
-	if [ -n "${KERNEL_FEATURES}" ]; then
-		for feat in ${KERNEL_FEATURES}; do
-			addon_features="$addon_features --feature $feat"
-		done
+	# expand kernel features into their full path equivalents
+	bsp_definition=$(spp ${includes} --find -DKMACHINE=${KMACHINE} -DKTYPE=${LINUX_KERNEL_TYPE})
+	meta_dir=$(kgit --meta)
+
+	# run1: pull all the configuration fragments, no matter where they come from
+	elements="`echo -n ${bsp_definition} ${sccs} ${patches} ${KERNEL_FEATURES}`"
+	if [ -n "${elements}" ]; then
+		echo "${bsp_definition}" > ${S}/${meta_dir}/bsp_definition
+		scc --force -o ${S}/${meta_dir}:cfg,merge,meta ${includes} ${bsp_definition} ${sccs} ${patches} ${KERNEL_FEATURES}
+		if [ $? -ne 0 ]; then
+			bbfatal_log "Could not generate configuration queue for ${KMACHINE}."
+		fi
 	fi
 
-	# updates or generates the target description
-	updateme --branch ${kbranch} -DKDESC=${KMACHINE}:${LINUX_KERNEL_TYPE} \
-                           ${addon_features} ${ARCH} ${KMACHINE} ${sccs} ${patches}
-	if [ $? -ne 0 ]; then
-		echo "ERROR. Could not update ${kbranch}"
-		exit 1
+	# run2: only generate patches for elements that have been passed on the SRC_URI
+	elements="`echo -n ${sccs} ${patches} ${KERNEL_FEATURES}`"
+	if [ -n "${elements}" ]; then
+		scc --force -o ${S}/${meta_dir}:patch --cmds patch ${includes} ${sccs} ${patches} ${KERNEL_FEATURES}
+		if [ $? -ne 0 ]; then
+			bbfatal_log "Could not generate configuration queue for ${KMACHINE}."
+		fi
 	fi
+}
 
-	# executes and modifies the source tree as required
-	patchme ${KMACHINE}
-	if [ $? -ne 0 ]; then
-		echo "ERROR. Could not modify ${kbranch}"
-		exit 1
+do_patch() {
+	set +e
+	cd ${S}
+
+	check_git_config
+	meta_dir=$(kgit --meta)
+	(cd ${meta_dir}; ln -sf patch.queue series)
+	if [ -f "${meta_dir}/series" ]; then
+		kgit-s2q --gen -v --patches .kernel-meta/
+		if [ $? -ne 0 ]; then
+			bberror "Could not apply patches for ${KMACHINE}."
+			bbfatal_log "Patch failures can be resolved in the linux source directory ${S})"
+		fi
+	fi
+
+	if [ -f "${meta_dir}/merge.queue" ]; then
+		# we need to merge all these branches
+		for b in $(cat ${meta_dir}/merge.queue); do
+			git show-ref --verify --quiet refs/heads/${b}
+			if [ $? -eq 0 ]; then
+				bbnote "Merging branch ${b}"
+				git merge -q --no-ff -m "Merge branch ${b}" ${b}
+			else
+				bbfatal "branch ${b} does not exist, cannot merge"
+			fi
+		done
 	fi
 }
 
 do_kernel_checkout() {
 	set +e
 
-	# A linux yocto SRC_URI should use the bareclone option. That
-	# ensures that all the branches are available in the WORKDIR version
-	# of the repository. If it wasn't passed, we should detect it, and put
-	# out a useful error message
-	if [ -d "${WORKDIR}/git/" ] && [ -d "${WORKDIR}/git/.git" ]; then
-		# we build out of {S}, so ensure that ${S} is clean and present
-		rm -rf ${S}
-		mkdir -p ${S}/.git
-
-		echo "WARNING. ${WORKDIR}/git is not a bare clone."
-		echo "Ensure that the SRC_URI includes the 'bareclone=1' option."
-		
-		# we can fix up the kernel repository, but at the least the meta
-		# branch must be present. The machine branch may be created later.
-		mv ${WORKDIR}/git/.git ${S}
-		rm -rf ${WORKDIR}/git/
-		cd ${S}
-		if [ -n "${KMETA}" ]; then
-			git branch -a | grep -q ${KMETA}
-			if [ $? -ne 0 ]; then
-				echo "ERROR. The branch '${KMETA}' is required and was not"
-				echo "found. Ensure that the SRC_URI points to a valid linux-yocto"
-				echo "kernel repository"
-				exit 1
+	source_dir=`echo ${S} | sed 's%/$%%'`
+	source_workdir="${WORKDIR}/git"
+	if [ -d "${WORKDIR}/git/" ]; then
+		# case: git repository
+		# if S is WORKDIR/git, then we shouldn't be moving or deleting the tree.
+		if [ "${source_dir}" != "${source_workdir}" ]; then
+			if [ -d "${source_workdir}/.git" ]; then
+				# regular git repository with .git
+				rm -rf ${S}
+				mv ${WORKDIR}/git ${S}
+			else
+				# create source for bare cloned git repository
+				git clone ${WORKDIR}/git ${S}
+				rm -rf ${WORKDIR}/git
 			fi
 		fi
+		cd ${S}
+	else
+		# case: we have no git repository at all. 
+		# To support low bandwidth options for building the kernel, we'll just 
+		# convert the tree to a git repo and let the rest of the process work unchanged
+		
+		# if ${S} hasn't been set to the proper subdirectory a default of "linux" is 
+		# used, but we can't initialize that empty directory. So check it and throw a
+		# clear error
+
+	        cd ${S}
+		if [ ! -f "Makefile" ]; then
+			bberror "S is not set to the linux source directory. Check "
+			bbfatal "the recipe and set S to the proper extracted subdirectory"
+		fi
+		rm -f .gitignore
+		git init
+		git add .
+		git commit -q -m "baseline commit: creating repo for ${PN}-${PV}"
+		git clean -d -f
 	fi
-	if [ -d "${WORKDIR}/git/" ] && [ ! -d "${WORKDIR}/git/.git" ]; then
-		# we build out of {S}, so ensure that ${S} is clean and present
-		rm -rf ${S}
-		mkdir -p ${S}/.git
-
-		mv ${WORKDIR}/git/* ${S}/.git
-		rm -rf ${WORKDIR}/git/
-		cd ${S}	
-		git config core.bare false
-	fi
-	# end debare
 
 	# convert any remote branches to local tracking ones
-	for i in `git branch -a | grep remotes | grep -v HEAD`; do
+	for i in `git branch -a --no-color | grep remotes | grep -v HEAD`; do
 		b=`echo $i | cut -d' ' -f2 | sed 's%remotes/origin/%%'`;
 		git show-ref --quiet --verify -- "refs/heads/$b"
 		if [ $? -ne 0 ]; then
@@ -147,147 +244,141 @@ do_kernel_checkout() {
 		fi
 	done
 
-	# Create a working tree copy of the kernel by checkout out a branch
-	git show-ref --quiet --verify -- "refs/heads/${KBRANCH}"
-	if [ $? -eq 0 ]; then
-		# checkout and clobber and unimportant files
-		git checkout -f ${KBRANCH}
-	else
-		echo "Not checking out ${KBRANCH}, it will be created later"
-		git checkout -f master
-	fi
+	# Create a working tree copy of the kernel by checking out a branch
+	machine_branch="${@ get_machine_branch(d, "${KBRANCH}" )}"
+
+	# checkout and clobber any unimportant files
+	git checkout -f ${machine_branch}
 }
 do_kernel_checkout[dirs] = "${S}"
 
-addtask kernel_checkout before do_patch after do_unpack
+addtask kernel_checkout before do_kernel_metadata after do_unpack
+addtask kernel_metadata after do_validate_branches do_unpack before do_patch
+do_kernel_metadata[depends] = "kern-tools-native:do_populate_sysroot"
+do_validate_branches[depends] = "kern-tools-native:do_populate_sysroot"
 
-do_kernel_configme[dirs] = "${CCACHE_DIR} ${S} ${B}"
+do_kernel_configme[dirs] += "${S} ${B}"
 do_kernel_configme() {
-	echo "[INFO] doing kernel configme"
+	set +e
 
-	if [ -n ${KCONFIG_MODE} ]; then
-		configmeflags=${KCONFIG_MODE}
-	else
-		# If a defconfig was passed, use =n as the baseline, which is achieved
-		# via --allnoconfig
+	# translate the kconfig_mode into something that merge_config.sh
+	# understands
+	case ${KCONFIG_MODE} in
+		*allnoconfig)
+			config_flags="-n"
+			;;
+		*alldefconfig)
+			config_flags=""
+			;;
+	    *)
 		if [ -f ${WORKDIR}/defconfig ]; then
-			configmeflags="--allnoconfig"
+			config_flags="-n"
 		fi
-	fi
+	    ;;
+	esac
 
 	cd ${S}
-	PATH=${PATH}:${S}/scripts/util
-	configme ${configmeflags} --reconfig --output ${B} ${LINUX_KERNEL_TYPE} ${KMACHINE}
+
+	meta_dir=$(kgit --meta)
+	configs="$(scc --configs -o ${meta_dir})"
+	if [ -z "${configs}" ]; then
+		bbfatal_log "Could not find configuration queue (${meta_dir}/config.queue)"
+	fi
+
+	CFLAGS="${CFLAGS} ${TOOLCHAIN_OPTIONS}"	ARCH=${ARCH} merge_config.sh -O ${B} ${config_flags} ${configs} > ${meta_dir}/cfg/merge_config_build.log 2>&1
 	if [ $? -ne 0 ]; then
-		echo "ERROR. Could not configure ${KMACHINE}-${LINUX_KERNEL_TYPE}"
-		exit 1
+		bbfatal_log "Could not configure ${KMACHINE}-${LINUX_KERNEL_TYPE}"
 	fi
-	
+
 	echo "# Global settings from linux recipe" >> ${B}/.config
 	echo "CONFIG_LOCALVERSION="\"${LINUX_VERSION_EXTENSION}\" >> ${B}/.config
 }
 
+addtask kernel_configme before do_configure after do_patch
+
 python do_kernel_configcheck() {
-    import bb, re, string, sys, commands
+    import re, string, sys
 
-    bb.plain("NOTE: validating kernel configuration")
+    # if KMETA isn't set globally by a recipe using this routine, we need to
+    # set the default to 'meta'. Otherwise, kconf_check is not passed a valid
+    # meta-series for processing
+    kmeta = d.getVar("KMETA") or "meta"
+    if not os.path.exists(kmeta):
+        kmeta = "." + kmeta
 
-    pathprefix = "export PATH=%s:%s; " % (d.getVar('PATH', True), "${S}/scripts/util/")
-    cmd = d.expand("cd ${B}/..; kconf_check -config- ${B} ${S} ${B} ${KBRANCH}")
-    ret, result = commands.getstatusoutput("%s%s" % (pathprefix, cmd))
+    pathprefix = "export PATH=%s:%s; " % (d.getVar('PATH'), "${S}/scripts/util/")
 
-    bb.plain( "%s" % result )
-}
+    cmd = d.expand("scc --configs -o ${S}/.kernel-meta")
+    ret, configs = oe.utils.getstatusoutput("%s%s" % (pathprefix, cmd))
+
+    cmd = d.expand("cd ${S}; kconf_check --report -o ${S}/%s/cfg/ ${B}/.config ${S} %s" % (kmeta,configs))
+    ret, result = oe.utils.getstatusoutput("%s%s" % (pathprefix, cmd))
 
+    config_check_visibility = int(d.getVar("KCONF_AUDIT_LEVEL") or 0)
+    bsp_check_visibility = int(d.getVar("KCONF_BSP_AUDIT_LEVEL") or 0)
+
+    # if config check visibility is non-zero, report dropped configuration values
+    mismatch_file = d.expand("${S}/%s/cfg/mismatch.txt" % kmeta)
+    if os.path.exists(mismatch_file):
+        if config_check_visibility:
+            with open (mismatch_file, "r") as myfile:
+                results = myfile.read()
+                bb.warn( "[kernel config]: specified values did not make it into the kernel's final configuration:\n\n%s" % results)
+}
 
-# Ensure that the branches (BSP and meta) are on the locatios specified by
+# Ensure that the branches (BSP and meta) are on the locations specified by
 # their SRCREV values. If they are NOT on the right commits, the branches
-# are reset to the correct commit.
+# are corrected to the proper commit.
 do_validate_branches() {
+	set +e
 	cd ${S}
 
-	set +e
+	machine_branch="${@ get_machine_branch(d, "${KBRANCH}" )}"
+	machine_srcrev="${SRCREV_machine}"
+
 	# if SRCREV is AUTOREV it shows up as AUTOINC there's nothing to
 	# check and we can exit early
-	if [ "${SRCREV_machine}" = "AUTOINC" ]; then
-		return
-	fi
-
-	# if the branches do not exist, then there's nothing to check either
-	git show-ref --quiet --verify -- "refs/heads/${KBRANCH}"
-	if [ $? -eq 1 ]; then
-		return
-	fi
-
- 	branch_head=`git show-ref -s --heads ${KBRANCH}`
-	if [ -z "${SRCREV_machine}" ]; then
-		target_branch_head="${SRCREV}"
+	if [ "${machine_srcrev}" = "AUTOINC" ]; then
+		bbnote "SRCREV validation is not required for AUTOREV"
+	elif [ "${machine_srcrev}" = "" ]; then
+		if [ "${SRCREV}" != "AUTOINC" ] && [ "${SRCREV}" != "INVALID" ]; then
+		       # SRCREV_machine_<MACHINE> was not set. This means that a custom recipe
+		       # that doesn't use the SRCREV_FORMAT "machine_meta" is being built. In
+		       # this case, we need to reset to the give SRCREV before heading to patching
+		       bbnote "custom recipe is being built, forcing SRCREV to ${SRCREV}"
+		       force_srcrev="${SRCREV}"
+		fi
 	else
-	 	target_branch_head="${SRCREV_machine}"
-	fi
-
-	if [ "${target_branch_head}" = "AUTOINC" ]; then
-		return
-	fi
-
-	# We have SRCREVs and we have branches so validation can continue!
-	current=`git branch |grep \*|sed 's/^\* //'`
-	if [ -n "$target_branch_head" ] && [ "$branch_head" != "$target_branch_head" ] &&
-           [ "$target_branch_head" != "AUTOINC" ]; then
-		ref=`git show ${target_branch_head} 2>&1 | head -n1 || true`
-		if [ "$ref" = "fatal: bad object ${target_meta_head}" ]; then
-			echo "ERROR ${target_branch_head} is not a valid commit ID."
-			echo "The kernel source tree may be out of sync"
-			exit 1
-		else
-			echo "Forcing branch $current to ${target_branch_head}"
-			git branch -m $current $current-orig
-			git checkout -b $current ${target_branch_head}
+		git cat-file -t ${machine_srcrev} > /dev/null
+		if [ $? -ne 0 ]; then
+			bberror "${machine_srcrev} is not a valid commit ID."
+			bbfatal_log "The kernel source tree may be out of sync"
 		fi
+		force_srcrev=${machine_srcrev}
 	fi
 
- 	meta_head=`git show-ref -s --heads ${KMETA}`
- 	target_meta_head="${SRCREV_meta}"
-	git show-ref --quiet --verify -- "refs/heads/${KMETA}"
-	if [ $? -eq 1 ]; then
-		return
-	fi
-
-	if [ "${target_meta_head}" = "AUTOINC" ]; then
-		return
-	fi
-
-	if [ "$meta_head" != "$target_meta_head" ]; then
-		ref=`git show ${target_meta_head} 2>&1 | head -n1 || true`
-		if [ "$ref" = "fatal: bad object ${target_meta_head}" ]; then
-			echo "ERROR ${target_meta_head} is not a valid commit ID"
-			echo "The kernel source tree may be out of sync"
-			exit 1
-		else
-			echo "Forcing branch meta to ${target_meta_head}"
-			git branch -m ${KMETA} ${KMETA}-orig
-			git checkout -b ${KMETA} ${target_meta_head}
-			if [ $? -ne 0 ];then
-				echo "ERROR: could not checkout meta branch from known hash ${target_meta_head}"
-				exit 1
-			fi
+	git checkout -q -f ${machine_branch}
+	if [ -n "${force_srcrev}" ]; then
+		# see if the branch we are about to patch has been properly reset to the defined
+		# SRCREV .. if not, we reset it.
+		branch_head=`git rev-parse HEAD`
+		if [ "${force_srcrev}" != "${branch_head}" ]; then
+			current_branch=`git rev-parse --abbrev-ref HEAD`
+			git branch "$current_branch-orig"
+			git reset --hard ${force_srcrev}
+			# We've checked out HEAD, make sure we cleanup kgit-s2q fence post check
+			# so the patches are applied as expected otherwise no patching
+			# would be done in some corner cases.
+			kgit-s2q --clean
 		fi
 	fi
-
-	# restore the branch for builds
-	git checkout -f ${KBRANCH}
-}
-
-# Many scripts want to look in arch/$arch/boot for the bootable
-# image. This poses a problem for vmlinux based booting. This 
-# task arranges to have vmlinux appear in the normalized directory
-# location.
-do_kernel_link_vmlinux() {
-	if [ ! -d "${B}/arch/${ARCH}/boot" ]; then
-		mkdir ${B}/arch/${ARCH}/boot
-	fi
-	cd ${B}/arch/${ARCH}/boot
-	ln -sf ../../../vmlinux
 }
 
+OE_TERMINAL_EXPORTS += "KBUILD_OUTPUT"
+KBUILD_OUTPUT = "${B}"
 
+python () {
+    # If diffconfig is available, ensure it runs after kernel_configme
+    if 'do_diffconfig' in d:
+        bb.build.addtask('do_diffconfig', None, 'do_kernel_configme', d)
+}