Merge branch 'stable/1710' of https://gerrit.fd.io/r/vpp into 17101710

1 files changed, 1170 insertions, 0 deletions

diff --git a/build-root/Makefile b/build-root/Makefile
new file mode 100644
index 00000000..81f7b901
--- /dev/null
+++ b/build-root/Makefile
@@ -0,0 +1,1170 @@
+# Copyright (c) 2015 Cisco and/or its affiliates.
+# 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.
+
+#
+# Copyright (c) 2007-2008 Eliot Dresselhaus
+#
+#  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.
+#
+
+######################################################################
+# Collect makefile fragments
+######################################################################
+
+# Scripts require non-POSIX parts of bash
+SHELL := /bin/bash
+
+# Where this makefile lives
+MU_BUILD_ROOT_DIR = $(shell pwd)
+MU_BUILD_NAME = $(shell basename $(MU_BUILD_ROOT_DIR))
+
+# Search path (e.g. multiple directories) where sources are found.
+SOURCE_PATH =
+
+# Pick up user's definitions for variables e.g. SOURCE_PATH, etc.
+-include build-config.mk
+
+MU_BUILD_ROOT_NAME = $(shell basename $(MU_BUILD_ROOT_DIR))
+MU_BUILD_DATA_DIR_NAME = build-data
+
+ABSOLUTE_SOURCE_PATH = $(foreach d,$(SOURCE_PATH),$(shell cd $(d) && pwd))
+
+SOURCE_PATH_BUILD_ROOT_DIRS = $(addsuffix /$(MU_BUILD_NAME),$(ABSOLUTE_SOURCE_PATH))
+SOURCE_PATH_BUILD_DATA_DIRS = $(addsuffix /$(MU_BUILD_DATA_DIR_NAME),$(ABSOLUTE_SOURCE_PATH))
+
+# For tools use build-root as source path, otherwise use given source path
+FIND_SOURCE_PATH =						\
+  $(if $(is_build_tool),					\
+    $(SOURCE_PATH_BUILD_ROOT_DIRS) $(MU_BUILD_ROOT_DIR),	\
+    $(SOURCE_PATH_BUILD_DATA_DIRS))
+
+# First search given source path, then default to build-root
+FULL_SOURCE_PATH = $(SOURCE_PATH_BUILD_DATA_DIRS) $(MU_BUILD_ROOT_DIR)
+
+# Misc functions
+is_in_fn = $(strip $(filter $(1),$(2)))
+last_fn = $(lastword $1)
+chop_fn = $(wordlist 2,$(words $1),x $1)
+uniq_fn = $(strip $(if $1,$(call uniq_fn,$(call chop_fn,$1)) \
+            $(if $(filter $(call last_fn,$1),$(call chop_fn,$1)),,$(call last_fn,$1))))
+ifdef3_fn = $(if $(patsubst undefined,,$(origin $(1))),$(3),$(2))
+ifdef_fn = $(call ifdef3_fn,$(1),$(2),$($(1)))
+
+_mu_debug = $(warning "$(1) = $($(1))")
+
+$(foreach d,$(FIND_SOURCE_PATH),					\
+  $(eval _mu_package_mk_in_$(d) = $(shell find $(d)/packages/*.mk 2> /dev/null))	\
+  $(eval _mu_srcdirs_in_$(d) =						\
+    $(shell find $(d)/..						\
+      -maxdepth 1							\
+      -type d								\
+      -and -not -name ".."						\
+      -and -not -name $(MU_BUILD_ROOT_NAME)				\
+      -and -not -name $(MU_BUILD_DATA_DIR_NAME)))			\
+  $(eval _mu_non_package_files_in_$(d) =				\
+    $(shell find $(d)/packages						\
+      -type f								\
+      -and -not -name '*.mk'						\
+      -and -not -name '*~' 2> /dev/null))				\
+  $(foreach p,$(patsubst %.mk,%,$(notdir $(_mu_package_mk_in_$(d)))),	\
+    $(eval _mu_package_dir_$(p) = $(d))					\
+    $(eval _mu_package_mk_$(p) = $(d)/packages/$(p).mk)			\
+  )									\
+  $(foreach p,$(notdir $(_mu_srcdirs_in_$(d))),				\
+    $(eval _mu_package_srcdir_$(p) = $(shell cd $(d)/../$(p) && pwd))	\
+  )									\
+)
+
+# Find root directory for package based on presence of package .mk
+# makefile fragment on source path.
+_find_build_data_dir_for_package_fn = $(shell			\
+  set -eu$(BUILD_DEBUG) ;					\
+  for d in $(FIND_SOURCE_PATH) ; do				\
+    f="$${d}/packages/$(1).mk" ;				\
+    [[ -f $${f} ]] && echo `cd $${d} && pwd` && exit 0 ;	\
+  done ;							\
+  echo "")
+find_build_data_dir_for_package_fn = $(call ifdef_fn,_mu_package_dir_$(1),)
+
+# dir/PACKAGE
+_find_source_fn = $(shell				\
+  set -eu$(BUILD_DEBUG) ;				\
+  d="$(call find_build_data_dir_for_package_fn,$(1))" ;	\
+  [[ -n "$${d}" ]] && d="$${d}/../$(1)" ;		\
+  echo "$${d}")
+find_source_fn = $(call ifdef3_fn,_mu_package_dir_$(1),,$(_mu_package_dir_$(1))/../$(1))
+
+# Find given FILE in source path as build-data/packages/FILE
+find_package_file_fn = $(shell				\
+  set -eu$(BUILD_DEBUG) ;				\
+  d="$(call find_build_data_dir_for_package_fn,$(1))" ;	\
+  [[ -n "$${d}" ]] && d="$${d}/packages/$(2)" ;		\
+  [[ -f "$${d}" ]] && echo "$${d}")
+
+# Find first FILE in source path with name PATH/build-data/FILE
+find_build_data_file_fn = $(shell				\
+  set -eu$(BUILD_DEBUG) ;					\
+  for d in $(FIND_SOURCE_PATH) ; do				\
+    f="$${d}/$(1)" ;						\
+    [[ -f $${f} ]] && echo `cd $${d} && pwd`/$(1) && exit 0 ;	\
+  done ;							\
+  echo "")
+
+######################################################################
+# ARCH, PLATFORM
+######################################################################
+
+NATIVE_ARCH = $(shell gcc -dumpmachine | sed -e 's/\([a-zA-Z_0-9]*\)-.*/\1/')
+
+# Find all platforms.mk that we can, including those from build-root
+$(foreach d,$(FULL_SOURCE_PATH), \
+  $(eval -include $(d)/platforms.mk))
+
+# Platform should be defined somewhere by specifying $($(PLATFORM)_arch)
+ARCH = $(strip $($(PLATFORM)_arch))
+ifeq ($(ARCH),)
+  $(error "Unknown platform `$(PLATFORM)'")
+endif
+
+# map e.g. ppc7450 -> ppc
+BASIC_ARCH = \
+   ${shell case '$(ARCH)' in \
+      (native) echo $(NATIVE_ARCH) ;; \
+      (i*86*) echo i386 ;; \
+      (ppc*|powerpc*) echo ppc ;; \
+      (*) echo '$(ARCH)' ;; \
+     esac }
+
+# x86_64 can be either 32/64.  set BIACH=32 to get 32 bit libraries.
+BIARCH = 64
+
+aarch64_libdir = 64
+x86_64_libdir = $(BIARCH)
+native_libdir = $($(NATIVE_ARCH)_libdir)
+
+# lib or lib64 depending
+arch_lib_dir = lib$($(BASIC_ARCH)_libdir)
+
+# OS to configure for.  configure --host will be set to $(ARCH)-$(OS)
+# Allow per-platform overrides
+
+OS = $(strip $($(PLATFORM)_os))
+ifeq ($(OS),)
+  OS = mu-linux
+endif
+
+spu_target = spu
+native_target =
+
+is_native = $(if $(ARCH:native=),,true)
+not_native = $(if $(ARCH:native=),true,)
+
+ARCH_TARGET_tmp = $(call ifdef_fn,$(ARCH)_target,$(ARCH)-$(OS))
+TARGET = $(call ifdef_fn,$(PLATFORM)_target,$(ARCH_TARGET_tmp))
+TARGET_PREFIX = $(if $(not_native),$(TARGET)-,)
+
+# CPU microarchitecture detection. 
+# Either set <platform>_march in build-data/platforms/<platform>.mk,
+# or detect and use the build-host instruction set
+
+MARCH = $(strip $($(PLATFORM)_march))
+ifeq ($(MARCH),)
+  ifneq ($(wildcard $(TOOL_INSTALL_DIR)/bin/$(TARGET)-gcc),)
+    TARGET_GCC = $(TOOL_INSTALL_DIR)/bin/$(TARGET)-gcc
+  else ifneq ($(wildcard $(MU_BUILD_ROOT_DIR)/tools/bin/$(TARGET)-gcc),)
+    TARGET_GCC = $(MU_BUILD_ROOT_DIR)/tools/bin/$(TARGET)-gcc
+  endif
+  ifneq ($(TARGET_GCC),)
+    MARCH = $(shell $(TARGET_GCC) -Q --help=target -march=native | grep march | sed -e 's/.*march=[[:space:]]*//')
+  else
+    MARCH = native
+  endif
+else
+  ifeq ($(MARCH),nehalem)
+    override MARCH = corei7
+  else ifeq ($(MARCH),westmere)
+    override MARCH = corei7
+  else ifeq ($(MARCH),sandybridge)
+    override MARCH = corei7-avx
+  else ifeq ($(MARCH),ivybridge)
+    override MARCH = core-avx-i
+  else ifeq ($(MARCH),haswell)
+    override MARCH = core-avx2
+  endif
+endif
+export MARCH
+
+MTUNE = $(strip $($(PLATFORM)_mtune))
+ifeq ($(MTUNE),)
+  MTUNE = generic
+endif
+
+######################################################################
+# Generic build stuff
+######################################################################
+
+# The package we are currently working on
+PACKAGE = $*
+
+# Build/install tags.  This lets you have different CFLAGS/CPPFLAGS/LDFLAGS
+# for e.g. debug versus optimized compiles.  Each tag has its own set of build/install
+# areas.
+TAG = 
+TAG_PREFIX = $(if $(TAG),$(TAG)-)
+
+# yes you need the space
+tag_var_with_added_space_fn = $(if $($(TAG)_TAG_$(1)),$($(TAG)_TAG_$(1)) )
+
+# TAG=debug for debugging
+debug_TAG_CFLAGS = -g -O0 -DCLIB_DEBUG -DFORTIFY_SOURCE=2 -march=$(MARCH) \
+		   -fstack-protector-all -fPIC
+debug_TAG_LDFLAGS = -g -O0 -DCLIB_DEBUG -DFORTIFY_SOURCE=2 -march=$(MARCH) \
+		   -fstack-protector-all -fPIC
+
+BUILD_PREFIX_package = build-$(TAG_PREFIX)
+BUILD_PREFIX_tool = build-tool-$(TAG_PREFIX)
+INSTALL_PREFIX = install-$(TAG_PREFIX)
+IMAGES_PREFIX = images-$(TAG_PREFIX)
+
+# Whether we are building a tool or not
+tool_or_package_fn = $(if $(is_build_tool),tool,package)
+
+# Directory where packages are built & installed
+BUILD_DIR = $(MU_BUILD_ROOT_DIR)/$(BUILD_PREFIX_$(call tool_or_package_fn))$(ARCH)
+
+## BURT
+# we will deprecate INSTALL_DIR shortly for DFLT_INSTALL_DIR
+INSTALL_DIR = $(MU_BUILD_ROOT_DIR)/$(INSTALL_PREFIX)$(ARCH)
+# DFLT_INSTALL_DIR used in platforms.mk for $(PLATFORM)_DESTDIR_BASE
+DFLT_INSTALL_DIR := $(MU_BUILD_ROOT_DIR)/$(INSTALL_PREFIX)$(ARCH)
+## BURT
+
+PLATFORM_IMAGE_DIR = $(MU_BUILD_ROOT_DIR)/$(IMAGES_PREFIX)$(PLATFORM)
+
+# $(call VAR,DEFAULT)
+override_var_with_default_fn = $(if $($(1)),$($(1)),$(2))
+
+# $(call if_directory_exists_fn,D1,D2) returns D1 if it exists else D2
+define if_directory_exists_fn
+$(shell if test -d $(1); then echo $(1); else echo $(2); fi)
+endef
+
+# $(call if_file_exists_fn,F1,F2) returns F1 if it exists else F2
+define if_file_exists_fn
+$(shell if test -f $(1); then echo $(1); else echo $(2); fi)
+endef
+
+# Default VAR, package specified override of default PACKAGE_VAR
+package_var_fn = $(call override_var_with_default_fn,$(1)_$(2),$(1))
+
+package_build_dir_fn = $(call package_var_fn,$(1),build_dir)
+
+package_install_dir_fn = \
+  $(if $(is_build_tool),$(TOOL_INSTALL_DIR),$(INSTALL_DIR)/$(call package_build_dir_fn,$(1)))
+
+PACKAGE_BUILD_DIR = \
+  $(BUILD_DIR)/$(call package_build_dir_fn,$(PACKAGE))
+PACKAGE_INSTALL_DIR = \
+  $(call package_install_dir_fn,$(PACKAGE))
+
+# Tools (gcc, binutils, glibc...) are installed here
+TOOL_INSTALL_DIR = $(MU_BUILD_ROOT_DIR)/tools
+
+# Target specific tools go here e.g. mu-build/tools/ppc-mu-linux
+TARGET_TOOL_INSTALL_DIR = $(TOOL_INSTALL_DIR)/$(TARGET)
+
+# Set BUILD_DEBUG to vx or x enable shell command tracing.
+BUILD_DEBUG =
+
+# Message from build system itself (as opposed to make or shell commands)
+build_msg_fn = echo "@@@@ $(1) @@@@"
+
+# Allow CCACHE_DIR to be overridden, e.g. in .../build-root/build-config.mk
+ifeq ($(CCACHE_DIR),)
+  CCACHE_DIR=$(MU_BUILD_ROOT_DIR)/.ccache
+endif
+
+# Always prefer our own tools to those installed on system.
+# Note: ccache-bin must be before tool bin.
+BUILD_ENV =										\
+    export CCACHE_DIR=$(CCACHE_DIR) ;					\
+    export PATH=$(TOOL_INSTALL_DIR)/ccache-bin:$(TOOL_INSTALL_DIR)/bin:$${PATH} ;	\
+    export PATH="`echo $${PATH} | sed -e s/[.]://`" ;					\
+    $(if $(not_native),export CONFIG_SITE=$(MU_BUILD_ROOT_DIR)/config.site ;,)	\
+    export LD_LIBRARY_PATH=$(TOOL_INSTALL_DIR)/lib64:$(TOOL_INSTALL_DIR)/lib ;		\
+    set -eu$(BUILD_DEBUG) ;							        \
+    set -o pipefail
+
+######################################################################
+# Package build generic definitions
+######################################################################
+
+package_dir_fn = \
+  $(call find_build_data_dir_for_package_fn,$(1))/packages
+
+package_mk_fn = $(call package_dir_fn,$(1))/$(1).mk
+
+### BURT
+
+#next version
+#pkgPhaseDependMacro = $(foreach x,configure build install,                  \
+			$(eval $(1)_$(x)_depend := $($(1)_depend:%=%-$(x))))
+#version equivalent to original code
+pkgPhaseDependMacro = $(eval $(1)_configure_depend := $($(1)_depend:%=%-install))
+
+### BURT
+
+# Pick up built-root/pre-package-include.mk for all source directories
+$(foreach d,$(SOURCE_PATH_BUILD_ROOT_DIRS),	\
+  $(eval -include $(d)/pre-package-include.mk))
+
+$(foreach d,$(addsuffix /packages,$(FIND_SOURCE_PATH)),			\
+  $(eval -include $(d)/*.mk)						\
+  $(eval ALL_PACKAGES += $(patsubst $(d)/%.mk,%,$(wildcard $(d)/*.mk)))	\
+)
+
+# Pick up built-root/post-package-include.mk for all source directories
+$(foreach d,$(SOURCE_PATH_BUILD_ROOT_DIRS),	\
+  $(eval -include $(d)/post-package-include.mk))
+
+# Linux specific native build tools
+NATIVE_TOOLS_LINUX =				\
+  e2fsimage					\
+  e2fsprogs					\
+  fakeroot					\
+  jffs2						\
+  mkimage					\
+  zlib						\
+  xz						\
+  squashfs
+
+IS_LINUX = $(if $(findstring no,$($(PLATFORM)_uses_linux)),no,yes)
+
+NATIVE_TOOLS_$(IS_LINUX) += $(NATIVE_TOOLS_LINUX)
+
+# only build glibc for linux installs
+CROSS_TOOLS_$(IS_LINUX) += glibc gcc
+
+# must be first for bootstrapping
+NATIVE_TOOLS = findutils make
+
+# basic tools needed for build system
+NATIVE_TOOLS += git automake autoconf libtool texinfo bison flex tar
+
+# needed to compile gcc
+NATIVE_TOOLS += mpfr gmp mpc
+
+# Tool to sign binaries
+NATIVE_TOOLS += sign
+
+# ccache
+NATIVE_TOOLS += ccache
+
+# Tools needed on native host to build for platform
+NATIVE_TOOLS += $(call ifdef_fn,$(PLATFORM)_native_tools,)
+
+# Tools for cross-compiling from native -> ARCH
+CROSS_TOOLS = binutils gcc-bootstrap gdb
+
+# Tools needed on native host to build for platform
+CROSS_TOOLS += $(call ifdef_fn,$(PLATFORM)_cross_tools,)
+
+NATIVE_TOOLS += $(NATIVE_TOOLS_yes)
+CROSS_TOOLS += $(CROSS_TOOLS_yes)
+
+timestamp_name_fn = .mu_build_$(1)_timestamp
+CONFIGURE_TIMESTAMP = $(call timestamp_name_fn,configure)
+BUILD_TIMESTAMP = $(call timestamp_name_fn,build)
+INSTALL_TIMESTAMP = $(call timestamp_name_fn,install)
+
+TIMESTAMP_DIR = $(PACKAGE_BUILD_DIR)
+
+find_newer_files_fn =						\
+  "`for i in $(2) ; do						\
+      [[ -f $$i && $$i -nt $(1) ]] && echo "$$i" && exit 0;	\
+    done ;							\
+    exit 0;`"
+
+find_filter = -not -name '*~'
+find_filter += -and -not -path '*/.git*'
+find_filter += -and -not -path '*/.svn*'
+find_filter += -and -not -path '*/.CVS*'
+find_filter += -and -not -path '*/manual/*'
+find_filter += -and -not -path '*/autom4te.cache/*'
+find_filter += -and -not -path '*/doc/all-cfg.texi'
+find_filter += -and -not -path '*/.mu_build_*'
+
+find_newer_filtered_fn =			\
+  (! -f $(1)					\
+    || -n $(call find_newer_files_fn,$(1),$(3))	\
+    || -n "`find -H $(2)			\
+	      -type f				\
+              -and -newer $(1)			\
+	      -and \( $(4) \)			\
+              -print -quit`")
+
+find_newer_fn =							\
+  $(call find_newer_filtered_fn,$(1),$(2),$(3),$(find_filter))
+
+######################################################################
+# Package dependencies
+######################################################################
+
+# This must come before %-configure, %-build, %-install pattern rules
+# or else dependencies will not work.
+
+package_dependencies_fn =				\
+  $(patsubst %-install, %,				\
+    $(filter %-install,$($(1)_configure_depend)))
+
+PACKAGE_DEPENDENCIES = $(call package_dependencies_fn,$(PACKAGE))
+
+# package specific configure, build, install dependencies
+add_package_dependency_fn = \
+  $(if $($(1)_$(2)_depend), \
+       $(eval $(1)-$(2) : $($(1)_$(2)_depend)))
+
+$(foreach p,$(ALL_PACKAGES), \
+    $(call add_package_dependency_fn,$(p),configure) \
+    $(call add_package_dependency_fn,$(p),build) \
+    $(call add_package_dependency_fn,$(p),install))
+
+TARGETS_RESPECTING_DEPENDENCIES = image_install wipe diff push-all pull-all find-source
+
+# carry over packages dependencies to image install, wipe, pull-all, push-all
+$(foreach p,$(ALL_PACKAGES),							\
+  $(if $($(p)_configure_depend),						\
+    $(foreach s,$(TARGETS_RESPECTING_DEPENDENCIES),				\
+      $(eval $(p)-$(s):								\
+	     $(addsuffix -$(s), $(call package_dependencies_fn,$(p)))))))
+
+# recursively resolve dependencies
+resolve_dependencies2_fn = $(strip					\
+  $(eval __added = $(filter-out $(4),					\
+    $(call uniq_fn,							\
+      $(foreach l,$(3),							\
+       $(call ifdef3_fn,$(l)$(1),,$(call $(2),$($(l)$(1))))		\
+      ))))								\
+  $(eval __known = $(call uniq_fn,$(4) $(3) $(__added)))		\
+  $(if $(__added),							\
+    $(call resolve_dependencies2_fn,$(1),$(2),$(__added),$(__known)),	\
+    $(__known))								\
+)
+
+resolve_dependencies_null_fn = $(1)
+
+resolve_dependencies_fn = $(call resolve_dependencies2_fn,$(1),resolve_dependencies_null_fn,$(2))
+
+######################################################################
+# Package configure
+######################################################################
+
+# x86_64 can be either 32/64.  set BIACH=32 to get 32 bit libraries.
+BIARCH = 64
+
+x86_64_libdir = $(BIARCH)
+native_libdir = $($(NATIVE_ARCH)_libdir)
+
+# lib or lib64 depending
+arch_lib_dir = lib$($(BASIC_ARCH)_libdir)
+
+# find dynamic linker as absolute path
+TOOL_INSTALL_LIB_DIR=$(TOOL_INSTALL_DIR)/$(TARGET)/$(arch_lib_dir)
+DYNAMIC_LINKER=${shell cd $(TOOL_INSTALL_LIB_DIR); echo ld*.so.*}
+
+# Pad dynamic linker & rpath so elftool will never have to change ELF section sizes.
+# Yes, this is a kludge.
+lots_of_slashes_to_pad_names = "/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+
+# When PLATFORM != native we *always* use our own versions of GLIBC and dynamic linker
+# Allow per-platform overrides
+CROSS_LDFLAGS = $(strip $($(PLATFORM)_cross_ldflags))
+ifeq ($(CROSS_LDFLAGS),)
+  CROSS_LDFLAGS =											\
+    -Wl,--dynamic-linker=$(lots_of_slashes_to_pad_names)$(TOOL_INSTALL_LIB_DIR)/$(DYNAMIC_LINKER)	\
+    -Wl,-rpath -Wl,$(lots_of_slashes_to_pad_names)$(TOOL_INSTALL_LIB_DIR)
+endif
+
+cross_ldflags = $(if $(is_native)$(is_build_tool),,$(CROSS_LDFLAGS) )
+
+# $(call installed_libs_fn,PACKAGE)
+# Return install library directory for given package.
+# Some packages (e.g. openssl) don't install under lib64; instead they use lib
+define installed_lib_fn
+$(call if_directory_exists_fn,
+  $(call package_install_dir_fn,$(1))/$(arch_lib_dir),
+  $(call package_install_dir_fn,$(1))/lib)
+endef
+
+# Set -L and rpath to point to dependent libraries previously built by us.
+installed_libs_fn =					\
+  $(foreach i,$(1),					\
+    -L$(call installed_lib_fn,$(i))			\
+    -Wl,-rpath -Wl,$(call installed_lib_fn,$(i)))
+
+# As above for include files
+installed_include_fn = $(call package_install_dir_fn,$(1))/include
+
+installed_includes_fn = $(foreach i,$(1),-I$(call installed_include_fn,$(i)))
+
+# By default package CPPFLAGS (to set include path -I) and LDFLAGS (to set link path -L)
+# point at dependent install directories.
+DEFAULT_CPPFLAGS = $(call installed_includes_fn, $(PACKAGE_DEPENDENCIES))
+DEFAULT_LDFLAGS = $(call installed_libs_fn, $(PACKAGE_DEPENDENCIES))
+
+configure_var_fn = \
+  $(call tag_var_with_added_space_fn,$(1))$(call override_var_with_default_fn,$(PACKAGE)_$(1),$(DEFAULT_$(1)))
+configure_ldflags_fn = \
+  $(cross_ldflags)$(call configure_var_fn,LDFLAGS)
+
+# Allow packages to override CPPFLAGS, CFLAGS, and LDFLAGS
+CONFIGURE_ENV =								\
+    $(if $(call configure_var_fn,CPPFLAGS),				\
+	 CPPFLAGS="$(CPPFLAGS) $(call configure_var_fn,CPPFLAGS)")	\
+    $(if $(call configure_var_fn,CFLAGS),				\
+	 CFLAGS="$(CFLAGS) $(call configure_var_fn,CFLAGS)")		\
+    $(if $(call configure_var_fn,CCASFLAGS),				\
+	 CCASFLAGS="$(CCASFLAGS) $(call configure_var_fn,CCASFLAGS)")	\
+    $(if $(call configure_ldflags_fn),					\
+	 LDFLAGS="$(LDFLAGS) $(call configure_ldflags_fn)")		\
+    $(if $($(PACKAGE)_configure_env),$($(PACKAGE)_configure_env))
+
+### BURT
+# only partially used now (used in a few .mk files)
+ifeq ($(is_build_tool),yes)
+prefix     = $(PACKAGE_INSTALL_DIR)
+libdir     = $(PACKAGE_INSTALL_DIR)/$(arch_lib_dir)
+libexecdir = $(PACKAGE_INSTALL_DIR)/usr/libexec
+DESTDIR     = /
+else
+# Eventually simplify this with no per package DESTDIR or prefix
+ppdMacro = $(if $(PER_PACKAGE_DESTDIR),$(call package_build_dir_fn,$(1)))
+pppMacro = $(if $(PER_PACKAGE_PREFIX),$(call package_build_dir_fn,$(1)))
+prefixMacro     = $($(PLATFORM)_PREFIX_BASE)/$(pppMacro)
+prefix = $(call prefixMacro,$(PACKAGE))
+libdir     = $($(PLATFORM)_LIBDIR)
+libexecdir = $($(PLATFORM)_LIBEXECDIR)
+destdirMacro  = $($(PLATFORM)_DESTDIR_BASE)$(ppdMacro)
+DESTDIR  = $(call destdirMacro,$(PACKAGE))
+endif
+### BURT
+### dbarach
+image_extra_dependencies = $($(PLATFORM)_image_extra_dependencies)
+### dbarach
+
+configure_package_gnu =						\
+  s=$(call find_source_fn,$(PACKAGE_SOURCE))$(PACKAGE_SUBDIR) ;	\
+  if [ ! -f $$s/configure ] ; then				\
+    autoreconf -i -f $$s ;					\
+  fi ;								\
+  cd $(PACKAGE_BUILD_DIR) ;					\
+  env $(CONFIGURE_ENV)						\
+    $$s/configure						\
+      $(if $($(PACKAGE)_configure_host_and_target),		\
+           $($(PACKAGE)_configure_host_and_target),		\
+           $(if $(not_native),--host=$(TARGET),))		\
+      $(if $($(PACKAGE)_configure_prefix),			\
+           $($(PACKAGE)_configure_prefix),			\
+           --libdir=$(PACKAGE_INSTALL_DIR)/$(arch_lib_dir)	\
+           --prefix=$(PACKAGE_INSTALL_DIR))			\
+      $($(PACKAGE)_configure_args) 				\
+      $($(PACKAGE)_configure_args_$(PLATFORM))
+
+configure_package =							\
+  $(call build_msg_fn,Configuring $(PACKAGE) in $(PACKAGE_BUILD_DIR)) ;	\
+  mkdir -p $(PACKAGE_BUILD_DIR) ;					\
+  $(if $($(PACKAGE)_configure),						\
+       $($(PACKAGE)_configure),						\
+       $(configure_package_gnu))
+
+# Tools (e.g. gcc, binutils, gdb) required a platform to build for
+check_platform =								\
+  is_tool="$(is_build_tool)" ;							\
+  is_cross_package="$(findstring $(PACKAGE),$(CROSS_TOOLS))" ;			\
+  is_arch_native="$(if $(subst native,,$(ARCH)),,yes)" ;			\
+  if [ "$${is_tool}" == "yes"							\
+       -a "$${is_cross_package}" != ""						\
+       -a "$${is_arch_native}" != "" ]; then					\
+    $(call build_msg_fn,You must specify PLATFORM for building tools) ;		\
+    exit 1 ;									\
+  fi ;										\
+  : check that platform gcc can be found ;					\
+  target_gcc=gcc ;								\
+  if [ "$${is_arch_native}" != "yes" ] ; then					\
+    target_gcc=$(TARGET)-gcc ;							\
+  fi ;										\
+  if [ "$${is_tool}" != "yes"							\
+       -a "$${is_arch_native}" != "yes"						\
+       -a ! -x "`which 2> /dev/null $${target_gcc}`" ] ; then			\
+    $(call build_msg_fn,							\
+	   No cross-compiler found for platform $(PLATFORM) target $(TARGET);	\
+	     try make PLATFORM=$(PLATFORM) install-tools) ;			\
+    exit 1 ;									\
+  fi
+    
+configure_check_timestamp =						\
+  @$(BUILD_ENV) ;							\
+  $(check_platform) ;							\
+  mkdir -p $(PACKAGE_BUILD_DIR) ;					\
+  mkdir -p $(PACKAGE_INSTALL_DIR) ;					\
+  conf="$(TIMESTAMP_DIR)/$(CONFIGURE_TIMESTAMP)" ;			\
+  dirs="$(call package_mk_fn,$(PACKAGE))				\
+	$(wildcard $(call find_source_fn,				\
+	             $(PACKAGE_SOURCE))$(PACKAGE_SUBDIR)/configure)	\
+       $(MU_BUILD_ROOT_DIR)/config.site" ;				\
+  if [[ $(call find_newer_fn, $${conf}, $${dirs}, $?) ]]; then		\
+    $(configure_package) ;						\
+    touch $${conf} ;							\
+  else									\
+    $(call build_msg_fn,Configuring $(PACKAGE): nothing to do) ;	\
+  fi
+
+.PHONY: %-configure
+%-configure: %-find-source
+	$(configure_check_timestamp)
+
+######################################################################
+# Package build
+######################################################################
+
+# /proc/cpuinfo does not exist on platforms without a /proc and on some
+# platforms, notably inside containers, it has no content. In those cases
+# we assume there's 1 processor; we use 2*ncpu for the -j option.
+# NB: GNU Make 4.2 will let us use '$(file </proc/cpuinfo)' to both test
+# for file presence and content; for now this will have to do.
+MAKE_PARALLEL_JOBS = -j $(if $(shell [ -f /proc/cpuinfo ] && head /proc/cpuinfo), \
+	$(shell expr 2 '*' $$(grep -c ^processor /proc/cpuinfo)), 2)
+MAKE_PARALLEL_FLAGS = $(if $($(PACKAGE)_make_parallel_fails),,$(MAKE_PARALLEL_JOBS))
+
+# Make command shorthand for packages & tools.
+PACKAGE_MAKE =					\
+  $(MAKE)					\
+    -C $(PACKAGE_BUILD_DIR)			\
+    $($(PACKAGE)_make_args)			\
+    $(MAKE_PARALLEL_FLAGS)
+
+build_package =							\
+  $(call build_msg_fn,Building $* in $(PACKAGE_BUILD_DIR)) ;	\
+  mkdir -p $(PACKAGE_BUILD_DIR) ;				\
+  cd $(PACKAGE_BUILD_DIR) ;					\
+  $(if $($(PACKAGE)_build),					\
+       $($(PACKAGE)_build),					\
+       $(PACKAGE_MAKE))
+
+build_check_timestamp =									\
+  @$(BUILD_ENV) ;									\
+  comp="$(TIMESTAMP_DIR)/$(BUILD_TIMESTAMP)" ;						\
+  conf="$(TIMESTAMP_DIR)/$(CONFIGURE_TIMESTAMP)" ;					\
+  dirs="$(call find_source_fn,$(PACKAGE_SOURCE))					\
+	$($(PACKAGE)_build_timestamp_depends)						\
+	$(if $(is_build_tool),,$(addprefix $(INSTALL_DIR)/,$(PACKAGE_DEPENDENCIES)))" ;	\
+  if [[ $${conf} -nt $${comp}								\
+        || $(call find_newer_fn, $${comp}, $${dirs}, $?) ]]; then			\
+    $(build_package) ;									\
+    touch $${comp} ;									\
+  else											\
+    $(call build_msg_fn,Building $(PACKAGE): nothing to do) ;				\
+  fi
+
+.PHONY: %-build
+%-build: %-configure
+	$(build_check_timestamp)
+
+.PHONY: %-rebuild
+%-rebuild: %-wipe %-build
+	@ :
+
+######################################################################
+# Package install
+######################################################################
+
+install_package =								\
+    : by default, for non-tools, remove any previously installed bits ;		\
+    $(if $(is_build_tool)$($(PACKAGE)_keep_instdir),				\
+         true,									\
+         rm -rf $(PACKAGE_INSTALL_DIR));					\
+    mkdir -p $(PACKAGE_INSTALL_DIR) ;						\
+    $(if $($(PACKAGE)_pre_install),$($(PACKAGE)_pre_install),true);		\
+    $(if $($(PACKAGE)_install),							\
+	 $($(PACKAGE)_install),							\
+	 $(PACKAGE_MAKE)							\
+	    $($(PACKAGE)_install_args)						\
+	    install) ;								\
+    $(if $($(PACKAGE)_post_install),$($(PACKAGE)_post_install),true)
+
+install_check_timestamp =					\
+  @$(BUILD_ENV) ;						\
+  inst=$(TIMESTAMP_DIR)/$(INSTALL_TIMESTAMP) ;			\
+  dirs="$(PACKAGE_BUILD_DIR)					\
+	$($(PACKAGE)_install_dependencies)" ;			\
+  if [[ $(call find_newer_fn, $${inst}, $${dirs}, $?) ]]; then	\
+    $(call build_msg_fn,Installing $(PACKAGE)) ;		\
+    $(install_package) ;					\
+    touch $${inst} ;						\
+  else								\
+    $(call build_msg_fn,Installing $(PACKAGE): nothing to do) ;	\
+  fi
+
+.PHONY: %-install
+%-install: %-build
+	$(install_check_timestamp)
+
+######################################################################
+# Source code managment
+######################################################################
+
+GIT = git
+
+# Maps package name to source directory root.
+# Multiple packages may use a single source tree.
+# For example, gcc-bootstrap package shares gcc source.
+PACKAGE_SOURCE = $(if $($(PACKAGE)_source),$($(PACKAGE)_source),$(PACKAGE))
+PACKAGE_SUBDIR = $(if $($(PACKAGE)_configure_subdir),/$($(PACKAGE)_configure_subdir),)
+
+# Use git to download source if directory is not found
+find_source_for_package =									\
+  @$(BUILD_ENV) ;										\
+  $(call build_msg_fn,Arch for platform '$(PLATFORM)' is $(ARCH)) ;				\
+  $(call build_msg_fn,Finding source for $(PACKAGE)) ;						\
+  s="$(call find_source_fn,$(PACKAGE_SOURCE))" ;						\
+  [[ -z "$${s}" ]]										\
+    && $(call build_msg_fn,Package $(PACKAGE) not found with path $(SOURCE_PATH))		\
+    && exit 1;											\
+  mk="$(call find_build_data_dir_for_package_fn,$(PACKAGE_SOURCE))/packages/$(PACKAGE).mk";	\
+  $(call build_msg_fn,Makefile fragment found in $${mk}) ;					\
+  if [ ! -d "$${s}" ] ; then									\
+    d=`dirname $${mk}` ;									\
+    i=`cd $${d}/.. && ($(GIT) config remote.origin.url ||					\
+                    awk '/URL/ { print $$2; }' .git/remotes/origin)`;				\
+    g=`dirname $${i}` ;										\
+    $(call build_msg_fn,Fetching source: $(GIT) clone $${g}/$(PACKAGE_SOURCE) $$s) ;		\
+    if ! $(GIT) clone $${g}/$(PACKAGE_SOURCE) $$s; then						\
+      $(call build_msg_fn,No source for $(PACKAGE) in $${g});					\
+      exit 1;											\
+    fi ;											\
+    $(call build_msg_fn,Fix file dates in $${g}/$(PACKAGE_SOURCE)) ;					\
+    (cd $${s} ; $(MU_BUILD_ROOT_DIR)/autowank --touch) ;					\
+  fi ;												\
+  s=`cd $${s} && pwd` ;										\
+  $(call build_msg_fn,Source found in $${s})
+
+.PHONY: %-find-source
+%-find-source:
+	$(find_source_for_package)
+
+.PHONY: %-push %-pull %-push-all %-pull-all
+%-push %-pull %-push-all %-pull-all:
+	@$(BUILD_ENV) ;								\
+	push_or_pull=$(patsubst %-all,%,$(subst $(PACKAGE)-,,$@)) ;		\
+	$(call build_msg_fn,Git $${push_or_pull} source for $(PACKAGE)) ;	\
+	s=$(call find_source_fn,$(PACKAGE_SOURCE)) ;				\
+	if [ "x$$s" = "x" ]; then						\
+	     $(call build_msg_fn,No source for $(PACKAGE)) ;			\
+	     exit 1;								\
+	fi ;									\
+	cd $$s && $(GIT) $${push_or_pull}
+
+# Pull all packages for platform
+.PHONY: pull-all
+pull-all:
+	@$(BUILD_ENV) ;								\
+	$(call build_msg_fn,Git pull build system) ;				\
+	for d in $(MU_BUILD_ROOT_DIR)						\
+		 $(SOURCE_PATH_BUILD_ROOT_DIRS)					\
+	 	 $(SOURCE_PATH_BUILD_DATA_DIRS); do				\
+	  $(call build_msg_fn,Git pull $${d}) ;					\
+	  pushd $${d} >& /dev/null && $(GIT) pull && popd >& /dev/null ;	\
+	done ;									\
+	$(call build_msg_fn,Git pull build tools) ;				\
+	$(call tool_make_target_fn,pull-all) ;					\
+	$(call build_msg_fn,Git pull packages for platform $(PLATFORM)) ;	\
+	make PLATFORM=$(PLATFORM) $(patsubst %,%-pull-all,$(ROOT_PACKAGES))
+
+.PHONY: %-diff
+%-diff:									
+	@$(BUILD_ENV) ;							\
+	d=$(call find_source_fn,$(PACKAGE_SOURCE)) ;			\
+	$(call build_msg_fn,Git diff $(PACKAGE)) ;			\
+	if [ -d $${d}/.git ] ; then 					\
+	 cd $${d} && $(GIT) --no-pager diff 2>/dev/null; 		\
+        else								\
+	 $(call build_msg_fn, $(PACKAGE) not a git directory) ;		\
+	fi
+            
+
+
+# generate diffs for everything in source path
+.PHONY: diff-all
+diff-all:								
+	@$(BUILD_ENV) ;							\
+	$(call build_msg_fn,Generate diffs) ;				\
+	for r in $(ABSOLUTE_SOURCE_PATH); do				\
+	  for d in $${r}/* ; do						\
+	    if [ -d $${d} ] ; then					\
+	      $(call build_msg_fn,Git diff $${d}) ;			\
+	      if [ -d $${d}/.git ] ; then				\
+		cd $${d} && $(GIT) --no-pager diff 2>/dev/null;		\
+	      else							\
+		$(call build_msg_fn, $${d} not a git directory) ;	\
+	      fi ;							\
+	    fi ; 							\
+	  done ;							\
+	done
+
+######################################################################
+# System images
+######################################################################
+
+IMAGE_DIR = $(MU_BUILD_ROOT_DIR)/image-$(PLATFORM)
+
+# Reports shared libraries in given directory
+find_shared_libs_fn =				\
+  find $(1)					\
+    -maxdepth 1					\
+       -regex '.*/lib[a-z0-9_]+\+?\+?.so'		\
+    -o -regex '.*/lib[a-z0-9_]+-[0-9.]+\+?\+?.so'	\
+    -o -regex '.*/lib[a-z0-9_]+\+?\+?.so.[0-9.]+'
+
+# By default pick up files from binary directories and /etc.
+# Also include shared libraries.
+DEFAULT_IMAGE_INCLUDE =					\
+  for d in bin sbin libexec				\
+           usr/bin usr/sbin usr/libexec			\
+           etc; do					\
+    [[ -d $$d ]] && echo $$d;				\
+  done ;						\
+  [[ -d $(arch_lib_dir) ]]				\
+    && $(call find_shared_libs_fn,$(arch_lib_dir))
+
+# Define any shell functions needed by install scripts
+image_install_functions =			\
+  $(foreach p,$(ALL_PACKAGES),			\
+    $(if $($(p)_image_install_functions),	\
+	 $($(p)_image_install_functions)))
+
+# Should always be over-written by temp dir in %-root-image rule
+IMAGE_INSTALL_DIR = $(error you need to set IMAGE_INSTALL_DIR)
+
+image_install_fn =								\
+  @$(BUILD_ENV) ;								\
+  $(call build_msg_fn,Image-install $(1) for platform $(PLATFORM)) ;		\
+  inst_dir=$(IMAGE_INSTALL_DIR) ;						\
+  mkdir -p $${inst_dir} ;							\
+  cd $(2) ;									\
+  : select files to include in image ;						\
+  image_include_files="								\
+    `$(call ifdef_fn,$(1)_image_include,$(DEFAULT_IMAGE_INCLUDE)) ;		\
+     echo "" ;									\
+     exit 0 ; `";								\
+  : select files regexps to exclude from image ;				\
+  image_exclude_files="" ;							\
+  if [ ! -z "$($(1)_image_exclude)" ] ; then					\
+    image_exclude_files="${image_exclude_files}					\
+                         $(patsubst %,--exclude=%,$($(1)_image_exclude))" ;	\
+  fi ;										\
+  [[ -z "$${image_include_files}" || $${image_include_files} == " " ]]		\
+    || tar cf - $${image_include_files} $${image_exclude_files}			\
+       | tar xf - -C $${inst_dir} ;						\
+  : copy files from copyimg directories on source path if present ;		\
+  for build_data_dir in $(SOURCE_PATH_BUILD_DATA_DIRS) ; do			\
+    d="$${build_data_dir}/packages/$(1).copyimg" ;				\
+    if [ -d "$${d}" ] ; then							\
+      env $($(PLATFORM)_copyimg_env)						\
+	$(MU_BUILD_ROOT_DIR)/copyimg $${d} $${inst_dir} ;			\
+    fi ;									\
+  done ;									\
+  : run package dependent install script ;					\
+  $(if $($(1)_image_install),							\
+       $(image_install_functions)						\
+       cd $${inst_dir} ;							\
+       $($(1)_image_install))
+
+.PHONY: %-image_install
+%-image_install: %-install
+	$(call image_install_fn,$(PACKAGE),$(PACKAGE_INSTALL_DIR))
+
+basic_system_image_include =					\
+  $(call ifdef_fn,$(PLATFORM)_basic_system_image_include, 	\
+  echo bin/ldd ;						\
+  echo $(arch_lib_dir)/ld*.so* ;				\
+  $(call find_shared_libs_fn, $(arch_lib_dir)))
+
+basic_system_image_install =				\
+  mkdir -p bin lib mnt proc root sbin sys tmp etc ;	\
+  mkdir -p usr usr/{bin,sbin} usr/lib ;			\
+  mkdir -p var var/{lib,lock,log,run,tmp} ;		\
+  mkdir -p var/lock/subsys var/lib/urandom 
+
+.PHONY: basic_system-image_install
+basic_system-image_install: # linuxrc-install
+	$(if $(not_native),							\
+	     $(call image_install_fn,basic_system,$(TARGET_TOOL_INSTALL_DIR)),)
+
+ROOT_PACKAGES = $(if $($(PLATFORM)_root_packages),$($(PLATFORM)_root_packages),$(default_root_packages))
+
+.PHONY: install-packages
+install-packages: $(patsubst %,%-find-source,$(ROOT_PACKAGES))	
+	@$(BUILD_ENV) ;							        \
+	set -eu$(BUILD_DEBUG) ;							\
+	d=$(MU_BUILD_ROOT_DIR)/packages-$(PLATFORM) ;				\
+	rm -rf $${d} ;								\
+	mkdir -p $${d};								\
+	$(MAKE) -C $(MU_BUILD_ROOT_DIR) IMAGE_INSTALL_DIR=$${d}			\
+	    $(patsubst %,%-image_install,					\
+	      basic_system							\
+	      $(ROOT_PACKAGES))	|| exit 1;					\
+	$(call build_msg_fn, Relocating ELF executables to run in $${d}) ;	\
+	find $${d} -type f							\
+	    -exec elftool quiet in '{}' out '{}'				\
+		set-interpreter							\
+		    $${d}/$(arch_lib_dir)/$(DYNAMIC_LINKER)			\
+		set-rpath $${d}/$(arch_lib_dir):$${d}/lib ';' ;			\
+	: strip symbols from files ;						\
+	if [ $${strip_symbols:-no} = 'yes' ] ; then				\
+	    $(call build_msg_fn, Stripping symbols from files) ;		\
+	    find $${d} -type f							\
+		-exec								\
+		  $(TARGET_PREFIX)strip						\
+		    --strip-unneeded '{}' ';'					\
+		    >& /dev/null ;						\
+	else									\
+	    $(call build_msg_fn, NOT stripping symbols) ;			\
+	fi 
+
+# readonly root squashfs image
+# Note: $(call build_msg_fn) does not seem to work inside of fakeroot so we use echo
+.PHONY: ro-image
+$(PLATFORM_IMAGE_DIR)/ro.img ro-image: $(patsubst %,%-find-source,$(ROOT_PACKAGES))
+	@$(BUILD_ENV) ;							\
+	d=$(PLATFORM_IMAGE_DIR) ;					\
+	mkdir -p $$d;							\
+	ro_image=$$d/ro.img ;						\
+	rm -f $${ro_image} ;						\
+	tmp_dir="`mktemp -d $$d/ro-image-XXXXXX`" ;			\
+	chmod 0755 $${tmp_dir} ;					\
+	cd $${tmp_dir} ;						\
+	trap "rm -rf $${tmp_dir}" err ;					\
+	fakeroot /bin/bash -c "{					\
+	  set -eu$(BUILD_DEBUG) ;					\
+	  $(MAKE) -C $(MU_BUILD_ROOT_DIR) IMAGE_INSTALL_DIR=$${tmp_dir}	\
+	    $(patsubst %,%-image_install,				\
+	      basic_system						\
+	      $(ROOT_PACKAGES)) ;					\
+	  : make dev directory ;					\
+	  $(linuxrc_makedev) ;						\
+	  echo @@@@ Relocating ELF executables to run in / @@@@ ;	\
+	  find $${d} -type f						\
+	      -exec elftool quiet in '{}' out '{}'			\
+		set-interpreter						\
+		    /$(arch_lib_dir)/$(DYNAMIC_LINKER)			\
+	        set-rpath /$(arch_lib_dir):/lib ';' ;			\
+	  : strip symbols from files ;					\
+	  if [ '$${strip_symbols:-yes}' = 'yes' ] ; then		\
+	      echo @@@@ Stripping symbols from files @@@@ ;		\
+	      find $${tmp_dir} -type f					\
+		-exec							\
+		  $(TARGET_PREFIX)strip					\
+		    --strip-unneeded '{}' ';'				\
+		    >& /dev/null ;					\
+	  else								\
+	      echo @@@@ NOT stripping symbols @@@@ ;			\
+	  fi ;								\
+	  if [ $${sign_executables:-yes} = 'yes'			\
+	       -a -n "$($(PLATFORM)_public_key)" ] ; then		\
+	      echo @@@@ Signing executables @@@@ ;			\
+	      find $${tmp_dir} -type f					\
+		| xargs sign $($(PLATFORM)_public_key)			\
+			     $($(PLATFORM)_private_key_passphrase) ;	\
+	  fi ;								\
+	  : make read-only file system ;				\
+	  mksquashfs							\
+	    $${tmp_dir} $${ro_image}					\
+	    -no-exports -no-progress -no-recovery ;			\
+	}" ;								\
+	: cleanup tmp directory ;					\
+	rm -rf $${tmp_dir}
+
+MKFS_JFFS2_BYTE_ORDER_x86_64 = -l
+MKFS_JFFS2_BYTE_ORDER_i686 = -l
+MKFS_JFFS2_BYTE_ORDER_ppc = -b
+MKFS_JFFS2_BYTE_ORDER_mips = -b
+MKFS_JFFS2_BYTE_ORDER_native = $(MKFS_JFFS2_BYTE_ORDER_$(NATIVE_ARCH))
+
+MKFS_JFFS2_SECTOR_SIZE_IN_KBYTES = \
+  $(call ifdef_fn,$(PLATFORM)_jffs2_sector_size_in_kbytes,256)
+
+mkfs_fn_jffs2 = mkfs.jffs2				\
+  --eraseblock=$(MKFS_JFFS2_SECTOR_SIZE_IN_KBYTES)KiB	\
+  --root=$(1) --output=$(2)				\
+  $(MKFS_JFFS2_BYTE_ORDER_$(BASIC_ARCH))
+
+# As things stand the actual initrd size parameter
+# is set in .../open-repo/build-data/packages/linuxrc.mk.
+EXT2_RW_IMAGE_SIZE=notused
+
+mkfs_fn_ext2 = \
+  e2fsimage -d $(1) -f $(2) -s $(EXT2_RW_IMAGE_SIZE)
+
+RW_IMAGE_TYPE=jffs2
+
+make_rw_image_fn = \
+  $(call mkfs_fn_$(RW_IMAGE_TYPE),$(1),$(2))
+
+rw_image_embed_ro_image_fn =					\
+  mkdir -p proc initrd images ro rw union ;			\
+  cp $(PLATFORM_IMAGE_DIR)/$(1) images/$(1) ;			\
+  md5sum images/$(1) > images/$(1).md5 ;			\
+  echo Built by $(LOGNAME) at `date` > images/$(1).stamp ;	\
+  mkdir -p changes/$(1)
+
+# make sure RW_IMAGE_TYPE is a type we know how to build
+.PHONY: rw-image-check-type
+rw-image-check-type:
+	@$(BUILD_ENV) ;								\
+	if [ -z "$(make_rw_image_fn)" ] ; then					\
+	  $(call build_msg_fn,Unknown read/write fs image type;			\
+		              try RW_IMAGE_TYPE=ext2 or RW_IMAGE_TYPE=jffs2) ;	\
+	  exit 1;								\
+	fi
+
+# read write image
+.PHONY: rw-image
+rw-image: rw-image-check-type ro-image
+	@$(BUILD_ENV) ;						\
+	d=$(PLATFORM_IMAGE_DIR) ;				\
+	mkdir -p $$d ;						\
+	rw_image="$$d/rw.$(RW_IMAGE_TYPE)" ;			\
+	ro_image="ro.img" ;					\
+	rm -f $$rw_image ;					\
+	tmp_dir="`mktemp -d $$d/rw-image-XXXXXX`" ;		\
+	chmod 0755 $${tmp_dir} ;				\
+	cd $${tmp_dir} ;					\
+	trap "rm -rf $${tmp_dir}" err ;				\
+	fakeroot /bin/bash -c "{				\
+	  set -eu$(BUILD_DEBUG) ;				\
+	  $(linuxrc_makedev) ;					\
+	  $(call rw_image_embed_ro_image_fn,$${ro_image}) ;	\
+	  $(call make_rw_image_fn,$${tmp_dir},$${rw_image}) ;	\
+	}" ;							\
+	: cleanup tmp directory ;				\
+	rm -rf $${tmp_dir}
+
+images: linuxrc-install linux-install $(image_extra_dependencies) rw-image
+	@$(BUILD_ENV) ;						\
+	d=$(PLATFORM_IMAGE_DIR) ;				\
+	cd $(BUILD_DIR)/linux-$(PLATFORM) ;			\
+	i="" ;							\
+	[[ -z $$i && -f bzImage ]] && i=bzImage ;		\
+	[[ -z $$i && -f zImage ]] && i=zImage ;			\
+	[[ -z $$i && -f linux ]] && i=linux ;			\
+	[[ -z $$i && -f vmlinux ]] && i=vmlinux ;		\
+	[[ -z $$i ]]						\
+	  && $(call build_msg_fn,no linux image to install	\
+		in $(BUILD_DIR)/linux-$(PLATFORM))		\
+	  && exit 1 ;						\
+	cp $$i $$d
+
+######################################################################
+# Tool chain build/install
+######################################################################
+
+.PHONY: ccache-install
+ccache-install:
+	$(MAKE) -C $(MU_BUILD_ROOT_DIR)	ccache-build
+	mkdir -p $(TOOL_INSTALL_DIR)/ccache-bin
+	ln -sf $(MU_BUILD_ROOT_DIR)/build-tool-native/ccache/ccache \
+		$(TOOL_INSTALL_DIR)/ccache-bin/$(TARGET_PREFIX)gcc 
+
+TOOL_MAKE = $(MAKE) is_build_tool=yes
+
+tool_make_target_fn = 							\
+  $(if $(strip $(NATIVE_TOOLS)),					\
+    $(TOOL_MAKE) $(patsubst %,%-$(1),$(NATIVE_TOOLS)) ARCH=native || exit 1 ;) \
+  $(TOOL_MAKE) $(patsubst %,%-$(1),$(CROSS_TOOLS))
+
+.PHONY: install-tools
+install-tools:
+	$(call tool_make_target_fn,install)
+
+.PHONY: bootstrap-tools
+bootstrap-tools:
+	$(TOOL_MAKE) make-install findutils-install git-install \
+	automake-install autoconf-install libtool-install fakeroot-install
+
+
+######################################################################
+# Clean
+######################################################################
+
+package_clean_script =							\
+  @$(call build_msg_fn, Cleaning $* in $(PACKAGE_INSTALL_DIR)) ;	\
+  $(BUILD_ENV) ;							\
+  $(if $(is_build_tool),,rm -rf $(PACKAGE_INSTALL_DIR) ;)		\
+  rm -rf $(TIMESTAMP_DIR)/$(call timestamp_name_fn,*) ;			\
+  $(if $($(PACKAGE)_clean),						\
+    $($(PACKAGE)_clean),						\
+    $(PACKAGE_MAKE) clean)
+
+.PHONY: %-clean
+%-clean:
+	$(package_clean_script)
+
+# Wipe e.g. remove build and install directories for packages.
+package_wipe_script =											\
+  @message=$(if $(is_build_tool),"Wiping build $(PACKAGE)","Wiping build/install $(PACKAGE)") ;		\
+  $(call build_msg_fn,$$message) ;									\
+  $(BUILD_ENV) ;											\
+  rm -rf $(if $(is_build_tool),$(PACKAGE_BUILD_DIR),$(PACKAGE_INSTALL_DIR) $(PACKAGE_BUILD_DIR))
+
+.PHONY: %-wipe
+%-wipe:
+	$(package_wipe_script)
+
+# Wipe entire build/install area for TAG and PLATFORM
+.PHONY: wipe-all
+wipe-all:
+	@$(call build_msg_fn, Wiping $(BUILD_DIR) $(INSTALL_DIR)) ;	\
+	$(BUILD_ENV) ;							\
+	rm -rf $(BUILD_DIR) $(INSTALL_DIR)
+
+# Clean everything
+distclean:
+	rm -rf $(MU_BUILD_ROOT_DIR)/$(BUILD_PREFIX_package)*/
+	rm -rf $(MU_BUILD_ROOT_DIR)/$(BUILD_PREFIX_tool)*
+	rm -rf $(MU_BUILD_ROOT_DIR)/$(INSTALL_PREFIX)*
+	rm -rf $(MU_BUILD_ROOT_DIR)/$(IMAGES_PREFIX)*
+	rm -rf $(TOOL_INSTALL_DIR)
+	rm -rf $(MU_BUILD_ROOT_DIR)/*.deb
+	rm -rf $(MU_BUILD_ROOT_DIR)/*.rpm
+	rm -rf $(MU_BUILD_ROOT_DIR)/*.changes
+	rm -rf $(MU_BUILD_ROOT_DIR)/python
+	if [ -e /usr/bin/dh ];then (cd $(MU_BUILD_ROOT_DIR)/deb/;debian/rules clean); fi
+	rm -f $(MU_BUILD_ROOT_DIR)/deb/debian/*.install
+	rm -f $(MU_BUILD_ROOT_DIR)/deb/debian/changelog