* Refactored the image creation rules. There are now generalized rules that

work on arbitrary "containers". The image rules are just
  specializations.
* Added rules, a definition file (build/jam/NetBootArchive), and a shell
  script for creating a gzipped tar archive containing kernel and modules
  required for network booting (the contents may need some fine-tuning).
  ATM it can be built via the haiku-netboot-archive pseudo target. It is
  generated in the output directory (e.g. "generated").


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21591 a95241bf-73f2-0310-859d-f6bbb57e9c96

Jamfile

@@ -142,8 +142,9 @@ if $(HAIKU_DONT_INCLUDE_SRC) {
 	SubInclude HAIKU_TOP src ;
 }
 
-# specify the Haiku image contents
+# specify the Haiku image and network boot archive contents
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) HaikuImage ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) NetBootArchive ] ;
 
 # Perform deferred SubIncludes.
 ExecuteDeferredSubIncludes ;

build/jam/BuildSetup

@@ -33,7 +33,7 @@ if $(JAM_TARGETS) {
 	} else if $(JAM_TARGETS[1]) = update-image
 		|| $(JAM_TARGETS[1]) = update-vmware-image
 		|| $(JAM_TARGETS[1]) = update-install {
-		HAIKU_IMAGE_UPDATE_ONLY = 1 ;
+		SetUpdateHaikuImageOnly 1 ;
 		HAIKU_INCLUDE_IN_IMAGE on $(JAM_TARGETS[2-]) = 1 ;
 
 		if $(JAM_TARGETS[1]) = update-image {
@@ -724,6 +724,25 @@ if $(TARGET_PLATFORM) = libbe_test {
 }
 
 
+#pragma mark - container settings
+
+# Haiku image
+HAIKU_IMAGE_CONTAINER_NAME = haiku-image-container ;
+HAIKU_CONTAINER_GRIST on $(HAIKU_IMAGE_CONTAINER_NAME) = HaikuImage ;
+HAIKU_INCLUDE_IN_CONTAINER_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
+	= HAIKU_INCLUDE_IN_IMAGE ;
+HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
+	= HAIKU_IMAGE_INSTALL_TARGETS ;
+
+# network boot archive
+HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME = haiku-netboot-archive-container ;
+HAIKU_CONTAINER_GRIST on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+	= NetBootArchive ;
+# HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
+HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+	= HAIKU_NET_BOOT_ARCHIVE_INSTALL_TARGETS ;
+
+
 #pragma mark -
 
 # common stuff

build/jam/HaikuImage

@@ -1,3 +1,6 @@
+# This file defines what ends up on the Haiku image (respectively in the Haiku
+# installation directory) and it executes the rules building the image
+# (respectively installing the files in the installation directory).
 
 # create directories that will remain empty
 AddDirectoryToHaikuImage home Desktop ;
@@ -6,18 +9,17 @@ AddDirectoryToHaikuImage home config lib ;
 AddDirectoryToHaikuImage var log ;
 AddDirectoryToHaikuImage var tmp ;
 
+local X86_ONLY = ;
+local PPC_ONLY = ;
 if $(TARGET_ARCH) = x86 {
 	X86_ONLY = "" ;
-	PPC_ONLY = ;
 } else if $(TARGET_ARCH) = ppc {
 	X86_ONLY = ;
-	PPC_ONLY = "" ;
 }
 
+local GPL_ONLY = ;
 if $(INCLUDE_GPL_ADDONS) = 1 {
 	GPL_ONLY = "" ;
-} else {
-	GPL_ONLY = ;
 }
 
 BEOS_BIN = "[" addattr alert arp basename bc beep bzip2 cat cardctl catattr chgrp
@@ -329,9 +331,9 @@ AddFilesToHaikuImage home config settings : <keymap>US-International : Key_map ;
 AddFilesToHaikuImage beos system : zbeos ;
 
 # boot module links
-AddBootModuleSymlinks config_manager bfs block_io fast_log generic_ide_pci
+AddBootModuleSymlinksToHaikuImage config_manager bfs block_io fast_log
-	$(X86_ONLY)isa ide ide_adapter $(X86_ONLY)ide_isa intel locked_pool
+	generic_ide_pci $(X86_ONLY)isa ide ide_adapter $(X86_ONLY)ide_isa intel
-	$(PPC_ONLY)openpic pci scsi scsi_cd scsi_dsk scsi_periph
+	locked_pool $(PPC_ONLY)openpic pci scsi scsi_cd scsi_dsk scsi_periph
 	ahci silicon_image_3112
 ;
 
@@ -395,7 +397,7 @@ MakeLocate $(HAIKU_IMAGE) : $(HAIKU_IMAGE_DIR) ;
 HAIKU_INSTALL_DIR ?= /Haiku ;
 
 # the pseudo target all image contents is attached to
-NotFile haiku-image-contents ;
+NotFile $(HAIKU_IMAGE_CONTAINER_NAME) ;
 
 # prepare the script that initializes the shell variables
 HAIKU_IMAGE_INIT_VARIABLES_SCRIPT = <HaikuImage>haiku.image-init-vars ;

build/jam/ImageRules

@@ -95,15 +95,18 @@ actions AddTargetVariableToScript1
 }
 
 
-rule AddDirectoryToHaikuImage directoryTokens
+#pragma mark -
-{
-	# AddDirectoryToHaikuImage <directoryTokens>
 
+rule AddDirectoryToContainer container : directoryTokens
+{
+	# AddDirectoryToContainer <container> : <directoryTokens>
+
+	local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
 	local directory = [ FDirName $(directoryTokens) ] ;
-	directory = $(directory:G=HaikuImage) ;
+	directory = $(directory:G=$(containerGrist)) ;
 
 	if ! [ on $(directory) return $(__is_on_image) ] {
-		INSTALL_DIRECTORIES on haiku-image-contents += $(directory) ;
+		HAIKU_INSTALL_DIRECTORIES on $(container) += $(directory) ;
 		__is_on_image on $(directory) = true ;
 		NotFile $(directory) ;
 	
@@ -112,7 +115,7 @@ rule AddDirectoryToHaikuImage directoryTokens
 		parent = [ FReverse $(parent[2-]) ] ;
 		if $(parent) {
 			parent = [ FDirName $(parent) ] ;
-			parent = $(parent:G=HaikuImage) ;
+			parent = $(parent:G=$(containerGrist)) ;
 			DONT_CREATE on $(parent) = true ;
 		}
 	}
@@ -120,35 +123,43 @@ rule AddDirectoryToHaikuImage directoryTokens
 	return $(directory) ;
 }
 
-rule FilterImageUpdateTargets targets
+rule FilterContainerUpdateTargets targets : filterVariable
 {
-	# FilterImageUpdateTargets targets
+	# FilterContainerUpdateTargets targets : filterVariable
 
 	local filteredTargets ;
 	local target ;
 	for target in $(targets) {
-		if [ on $(target) return $(HAIKU_INCLUDE_IN_IMAGE) ] {
+		if [ on $(target) return $($(filterVariable)) ] {
 			filteredTargets += $(target) ;
 		}
 	}
 	return $(filteredTargets) ;
 }
 
-rule AddFilesToHaikuImage
+rule AddFilesToContainer container : directoryTokens : targets : destName
 {
-	# AddFilesToHaikuImage <directory> : <targets> [ : dest name ]
+	# AddFilesToContainer <container> : <directoryTokens> : <targets>
+	#	[ : dest name ]
 	#
-	local directory = [ AddDirectoryToHaikuImage $(1) ] ;
+	local directory = [ AddDirectoryToContainer $(container)
-	local targets = $(2) ;
+		: $(directoryTokens) ] ;
-	local destName = $(3) ;
+	local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
 
 	# If the image shall only be updated, we filter out all targets not marked
 	# accordingly.
-	if $(HAIKU_IMAGE_UPDATE_ONLY) {
+	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] {
-		targets = [ FilterImageUpdateTargets $(targets) ] ;
+		local filterVar
+			= [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ;
+		if $(filterVar) {
+			targets = [ FilterContainerUpdateTargets $(targets)
+				: $(filterVar) ] ;
+		}
 	}
 
 	# We create a unique dummy target per target to install.
+	local installTargetsVar
+		= [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ;
 	local target ;
 	for target in $(targets) {
 		local name ;
@@ -158,25 +169,27 @@ rule AddFilesToHaikuImage
 			name = $(target:G=:D=) ;
 		}
 
-		local destTarget = $(name:G=HaikuImage__$(directory:G=)) ;
+		local destTarget = $(name:G=$(containerGrist)__$(directory:G=)) ;
 		TARGET on $(destTarget) = $(target) ;
 		INSTALL_DIR on $(destTarget) = $(directory) ;
-		INSTALL_TARGETS on $(target) += $(destTarget) ;
+		$(installTargetsVar) on $(target) += $(destTarget) ;
 		TARGETS_TO_INSTALL on $(directory) += $(destTarget) ;
 	}
 }
 
-rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName
+rule AddSymlinkToContainer container : directoryTokens : linkTarget : linkName
 {
-	# AddSymlinkToHaikuImage <directory> : <link target> [ : <link name> ] ;
+	# AddSymlinkToContainer <container> : <directory> : <link target>
+	#	[ : <link name> ] ;
 	#
 
 	# If the image shall only be updated, we don't add any symlinks.
-	if $(HAIKU_IMAGE_UPDATE_ONLY) {
+	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] {
 		return ;
 	}
 
-	local directory = [ AddDirectoryToHaikuImage $(directoryTokens) ] ;
+	local directory = [ AddDirectoryToContainer $(container)
+		: $(directoryTokens) ] ;
 
 	if ! $(linkName) {
 		local path = [ FReverse [ FSplitPath $(linkTarget) ] ] ;
@@ -188,30 +201,18 @@ rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName
 	SYMLINKS_TO_INSTALL on $(directory) += $(link) ;
 }
 
-rule AddSourceDirectoryToHaikuImage dirTokens : alwaysUpdate
+rule AddDriversToContainer container : relativeDirectoryTokens : targets
 {
-	# AddSourceDirectoryToHaikuImage <dirTokens> : <alwaysUpdate> ;
+	# AddDriversToContainer <container> : <relative directory> : <targets> ;
-
-	# If the image shall only be updated, we update sources only, if explicitely
-	# requested.
-	if ! $(HAIKU_IMAGE_UPDATE_ONLY) || $(alwaysUpdate) {
-		HAIKU_INSTALL_SOURCE_DIRS += [ FDirName $(HAIKU_TOP) $(dirTokens) ] ;
-	}
-}
-
-rule AddDriversToHaikuImage
-{
-	# AddDriversToHaikuImage <relative directory> : <targets> ;
 	#
-	local relativeDirectoryTokens = $(1) ;
-	local targets = $(2) ;
 	local directoryTokens = beos system add-ons kernel drivers dev
 		$(relativeDirectoryTokens) ;
 
-	AddFilesToHaikuImage beos system add-ons kernel drivers bin : $(targets) ;
+	AddFilesToContainer $(container) : beos system add-ons kernel drivers bin
+		: $(targets) ;
 
 	# If the image shall only be updated, we don't add any symlinks.
-	if $(HAIKU_IMAGE_UPDATE_ONLY) {
+	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] {
 		return ;
 	}
 
@@ -225,18 +226,17 @@ rule AddDriversToHaikuImage
 	# add the symlinks
 	local name ;
 	for name in $(targets:BS) {
-		AddSymlinkToHaikuImage $(directoryTokens)
+		AddSymlinkToContainer $(container) : $(directoryTokens)
 			: [ FDirName $(linkPrefix) $(name) ] : $(name) ;
 	}
 }
 
-rule AddDriverRegistrationToHaikuImage
+rule AddDriverRegistrationToContainer container : relativeDirectoryTokens
+	: target : links
 {
-	# AddDriverRegistrationToHaikuImage <directory> : <link target> : <link names> ] ;
+	# AddDriverRegistrationToContainer <container> : <directory>
+	#	: <link target> : <link names> ] ;
 	#
-	local relativeDirectoryTokens = $(1) ;
-	local target = $(2) ;
-	local links = $(3) ;
 	local directoryTokens = beos system add-ons kernel registration
 		$(relativeDirectoryTokens) ;
 
@@ -248,44 +248,46 @@ rule AddDriverRegistrationToHaikuImage
 	linkPrefix += .. drivers bin ;
 
 	# add the symlink
-	AddSymlinkToHaikuImage $(directoryTokens)
+	AddSymlinkToContainer $(container) : $(directoryTokens)
 		: [ FDirName $(linkPrefix) $(target:BS) ] : $(links) ;
 }
 
-rule AddBootModuleSymlinks targets
+rule AddBootModuleSymlinksToContainer container : targets
 {
-	# AddBootModuleSymlinks <targets> ;
+	# AddBootModuleSymlinksToContainer <container> : <targets> ;
 	#
 
 	# If the image shall only be updated, we don't add any symlinks.
-	if $(HAIKU_IMAGE_UPDATE_ONLY) {
+	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] {
 		return ;
 	}
 
 	# add the symlinks
+	local installTargetsVar
+		= [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ;
 	local target ;
 	for target in $(targets) {
 		# Symlink to the first place where the target has been installed.
-		local destTarget = [ on $(target) return $(INSTALL_TARGETS[1]) ] ;
+		local destTarget = [ on $(target) return $($(installTargetsVar)[1]) ] ;
 		local installDir = [ on $(destTarget) return $(INSTALL_DIR) ] ;
 
 		if ! $(installDir) {
-			Echo "ERROR: AddBootModuleSymlinks: Can't create a symlink to"
+			Echo "ERROR: AddBootModuleSymlinksToContainer: Can't create a "
-				"target" \"$(target)"\"." ;
+				"symlink to target" \"$(target)"\"." ;
-			Exit "ERROR: Add*ToHaikuImage has not been invoked for it yet." ;
+			Exit "ERROR: Add*ToContainer has not been invoked for it yet." ;
 		}
 
 		local name = $(target:BS) ;
 		local linkTarget = [ FDirName /boot $(installDir:G=) $(name) ] ; 
 
-		AddSymlinkToHaikuImage beos system add-ons kernel boot
+		AddSymlinkToContainer $(container) : beos system add-ons kernel boot
 			: $(linkTarget) : $(name) ;
 	}
 }
 
-rule CreateHaikuImageMakeDirectoriesScript
+
+rule CreateContainerMakeDirectoriesScript container : script
 {
-	local script = $(1) ;
 	MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
 	Always $(script) ;
 
@@ -299,7 +301,7 @@ rule CreateHaikuImageMakeDirectoriesScript
 	
 	local dirsToCreate ;
 	local dir ;
-	for dir in [ on haiku-image-contents return $(INSTALL_DIRECTORIES) ] {
+	for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] {
 		if ! [ on $(dir) return $(DONT_CREATE) ] {
 			dirsToCreate += $(dir) ;
 		}
@@ -307,19 +309,19 @@ rule CreateHaikuImageMakeDirectoriesScript
 
 	Depends $(scriptBody) : $(dirsToCreate) ;
 	# If the image shall only be updated, we don't create directories.
-	if $(dirsToCreate) && ! $(HAIKU_IMAGE_UPDATE_ONLY) {
+	if $(dirsToCreate)
-		CreateHaikuImageMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ;
+		&& ! [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] {
+		CreateContainerMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ;
 	}
 }
 
-actions piecemeal CreateHaikuImageMakeDirectoriesScript1
+actions piecemeal CreateContainerMakeDirectoriesScript1
 {
 	echo \$mkdir -p "\"\${tPrefix}$(2:G=)\"" >> $(1)
 }
 
-rule CreateHaikuImageCopyFilesScript
+rule CreateContainerCopyFilesScript container : script
 {
-	local script = $(1) ;
 	MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
 	Always $(script) ;
 
@@ -332,7 +334,7 @@ rule CreateHaikuImageCopyFilesScript
 	Depends $(script) : $(scriptBody) ;
 
 	local dir ;
-	for dir in [ on haiku-image-contents return $(INSTALL_DIRECTORIES) ] {
+	for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] {
 		# filter the targets that shall be renamed; they have to be copied
 		# individually
 		local destTargets = [ on $(dir) return $(TARGETS_TO_INSTALL) ] ;
@@ -352,7 +354,7 @@ rule CreateHaikuImageCopyFilesScript
 				Depends $(dummyTarget) : $(initScript) $(target) ;
 				Depends $(script) : $(dummyTarget) ;
 
-				AppendToHaikuImageCopyFilesScriptSingleFile $(dummyTarget)
+				AppendToContainerCopyFilesScriptSingleFile $(dummyTarget)
 					: $(initScript) $(target) ;
 			} else {
 				remainingTargets += $(target) ;
@@ -371,7 +373,7 @@ rule CreateHaikuImageCopyFilesScript
 			Depends $(script) : $(dummyTarget) ;
 
 			OUTPUT_SCRIPT on $(dummyTarget) = $(initScript) ;
-			AppendToHaikuImageCopyFilesScript $(dummyTarget) : $(targets) ;
+			AppendToContainerCopyFilesScript $(dummyTarget) : $(targets) ;
 		}
 	
 		local symlinks = [ on $(dir) return $(SYMLINKS_TO_INSTALL) ] ;
@@ -382,34 +384,108 @@ rule CreateHaikuImageCopyFilesScript
 			Depends $(script) : $(symlink) ;
 			Depends $(symlink) : $(initScript) ;
 
-			AddSymlinkToHaikuImageCopyFilesScript $(symlink) : $(initScript) ;
+			AddSymlinkToContainerCopyFilesScript $(symlink) : $(initScript) ;
 		}
 	}
 }
 
-actions piecemeal AppendToHaikuImageCopyFilesScript bind OUTPUT_SCRIPT
+actions piecemeal AppendToContainerCopyFilesScript bind OUTPUT_SCRIPT
 {
 	echo \$cp "\"\${sPrefix}$(2)\"" "\"\${tPrefix}$(TARGET_DIR)\"" >> $(OUTPUT_SCRIPT)
 }
 
-actions AppendToHaikuImageCopyFilesScriptSingleFile
+actions AppendToContainerCopyFilesScriptSingleFile
 {
 	echo \$cp "\"\${sPrefix}$(2[2])\"" \
 		"\"\${tPrefix}$(TARGET_DIR)/$(INSTALL_TARGET_NAME)\"" >> $(2[1])
 }
 
-actions AddSymlinkToHaikuImageCopyFilesScript
+actions AddSymlinkToContainerCopyFilesScript
 {
 	echo \$ln -sfn "\"$(SYMLINK_TARGET)\"" "\"\${tPrefix}$(1:G=)\"" >> $(2[1])
 }
 
-rule BuildHaikuImage
+
+#pragma mark - Haiku Image rules
+
+rule SetUpdateHaikuImageOnly flag
+{
+	HAIKU_CONTAINER_UPDATE_ONLY on $(HAIKU_IMAGE_CONTAINER_NAME) = $(flag) ;
+}
+
+rule AddDirectoryToHaikuImage directoryTokens
+{
+	# AddDirectoryToHaikuImage <directoryTokens>
+
+	return [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
+		: $(directoryTokens) ] ;
+}
+
+rule AddFilesToHaikuImage directory : targets : destName
+{
+	# AddFilesToHaikuImage <directory> : <targets> [ : dest name ]
+
+	AddFilesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory)
+		: $(targets) : $(destName) ;
+}
+
+rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName
+{
+	# AddSymlinkToHaikuImage <directory> : <link target> [ : <link name> ] ;
+
+	AddSymlinkToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens)
+		: $(linkTarget) : $(linkName) ;
+}
+
+rule AddSourceDirectoryToHaikuImage dirTokens : alwaysUpdate
+{
+	# AddSourceDirectoryToHaikuImage <dirTokens> : <alwaysUpdate> ;
+
+	# If the image shall only be updated, we update sources only, if explicitely
+	# requested.
+	if ! $(HAIKU_IMAGE_UPDATE_ONLY) || $(alwaysUpdate) {
+		HAIKU_INSTALL_SOURCE_DIRS += [ FDirName $(HAIKU_TOP) $(dirTokens) ] ;
+	}
+}
+
+rule AddDriversToHaikuImage relativeDirectoryTokens : targets
+{
+	# AddDriversToHaikuImage <relative directory> : <targets> ;
+
+	AddDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
+		: $(relativeDirectoryTokens) : $(targets) ;
+}
+
+rule AddDriverRegistrationToHaikuImage relativeDirectoryTokens : target : links
+{
+	# AddDriverRegistrationToHaikuImage <directory> : <link target> : <link names> ] ;
+
+	AddDriverRegistrationToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
+		: $(relativeDirectoryTokens) : $(target) : $(links) ;
+}
+
+rule AddBootModuleSymlinksToHaikuImage targets
+{
+	# AddBootModuleSymlinksToHaikuImage <targets> ;
+
+	AddBootModuleSymlinksToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
+		: $(targets) ;
+}
+
+rule CreateHaikuImageMakeDirectoriesScript script
+{
+	CreateContainerMakeDirectoriesScript $(HAIKU_IMAGE_CONTAINER_NAME)
+		: $(script) ;
+}
+
+rule CreateHaikuImageCopyFilesScript script
+{
+	CreateContainerCopyFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ;
+}
+
+rule BuildHaikuImage haikuImage : scripts : isImage
 {
 	# BuildHaikuImage <haiku image> : <scripts> : <is image> ;
-	#
-	local haikuImage = $(1) ;
-	local scripts = $(2) ;
-	local isImage = $(3) ;
 
 	if $(isImage) = 1 || $(isImage) = true {
 		IS_IMAGE on $(haikuImage) = 1 ;
@@ -446,3 +522,84 @@ actions BuildVMWareImage1
 	$(2[1]) -h 64k -i$(IMAGE_SIZE)M $(1) &&
 	cat $(2[2]) >> $(1)
 }
+
+
+#pragma mark - Network Boot Archive rules
+
+rule AddDirectoryToNetBootArchive directoryTokens
+{
+	# AddDirectoryToNetBootArchive <directoryTokens>
+
+	return [ AddDirectoryToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(directoryTokens) ] ;
+}
+
+rule AddFilesToNetBootArchive directory : targets : destName
+{
+	# AddFilesToNetBootArchive <directory> : <targets> [ : dest name ]
+
+	AddFilesToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(directory)
+		: $(targets) : $(destName) ;
+}
+
+rule AddSymlinkToNetBootArchive directoryTokens : linkTarget : linkName
+{
+	# AddSymlinkToNetBootArchive <directory> : <link target> [ : <link name> ] ;
+
+	AddSymlinkToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(directoryTokens) : $(linkTarget) : $(linkName) ;
+}
+
+rule AddDriversToNetBootArchive relativeDirectoryTokens : targets
+{
+	# AddDriversToNetBootArchive <relative directory> : <targets> ;
+
+	AddDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(relativeDirectoryTokens) : $(targets) ;
+}
+
+rule AddDriverRegistrationToNetBootArchive relativeDirectoryTokens : target
+	: links
+{
+	# AddDriverRegistrationToNetBootArchive <directory> : <link target>
+	#	: <link names> ] ;
+
+	AddDriverRegistrationToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(relativeDirectoryTokens) : $(target) : $(links) ;
+}
+
+rule AddBootModuleSymlinksToNetBootArchive targets
+{
+	# AddBootModuleSymlinksToNetBootArchive <targets> ;
+
+	AddBootModuleSymlinksToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(targets) ;
+}
+
+rule CreateNetBootArchiveMakeDirectoriesScript script
+{
+	CreateContainerMakeDirectoriesScript
+		$(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(script) ;
+}
+
+rule CreateNetBootArchiveCopyFilesScript script
+{
+	CreateContainerCopyFilesScript $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
+		: $(script) ;
+}
+
+rule BuildNetBootArchive archive : scripts
+{
+	# BuildHNetBootArchive <archive> : <scripts>  ;
+
+	local mainScript = build_tgz_archive ;
+	SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
+
+	Depends $(archive) : $(mainScript) $(scripts) ;
+	BuildNetBootArchive1 $(archive) : $(mainScript) $(scripts) ;
+}
+
+actions BuildNetBootArchive1
+{
+	$(2[1]) $(1) $(2[2-])
+}

build/jam/NetBootArchive

@@ -0,0 +1,133 @@
+# This file defines what ends up in the network boot archive and it executes the
+# rules building the archive.
+
+local X86_ONLY = ;
+local PPC_ONLY = ;
+if $(TARGET_ARCH) = x86 {
+	X86_ONLY = "" ;
+} else if $(TARGET_ARCH) = ppc {
+	X86_ONLY = ;
+}
+
+local GPL_ONLY = ;
+if $(INCLUDE_GPL_ADDONS) = 1 {
+	GPL_ONLY = "" ;
+}
+
+BEOS_NETWORK_DEVICES = ethernet loopback ;
+BEOS_NETWORK_DATALINK_PROTOCOLS = ethernet_frame <module>arp loopback_frame
+	ipv4_datagram ;
+BEOS_NETWORK_PROTOCOLS = ipv4 tcp udp icmp ;
+
+BEOS_ADD_ONS_DRIVERS_NET = etherpci ipro1000 rtl8139 rtl8169 sis900
+	via-rhine wb840 net_stack vlance
+	$(GPL_ONLY)bcm440x $(GPL_ONLY)bcm570x
+;
+BEOS_ADD_ONS_BUS_MANAGERS = pci $(X86_ONLY)ps2 $(X86_ONLY)isa ide scsi
+	config_manager $(X86_ONLY)agp
+;
+BEOS_ADD_ONS_FILE_SYSTEMS = bfs cdda dos googlefs iso9660 nfs ;
+
+
+# modules
+AddFilesToNetBootArchive beos system add-ons kernel bus_managers
+	: $(BEOS_ADD_ONS_BUS_MANAGERS) ;
+AddFilesToNetBootArchive beos system add-ons kernel busses ide
+	: ahci generic_ide_pci $(X86_ONLY)ide_isa silicon_image_3112 ;
+AddFilesToNetBootArchive beos system add-ons kernel console : vga_text ;
+AddFilesToNetBootArchive beos system add-ons kernel file_systems
+	: $(BEOS_ADD_ONS_FILE_SYSTEMS) ;
+AddFilesToNetBootArchive beos system add-ons kernel generic
+	: block_io fast_log ide_adapter locked_pool mpu401 scsi_periph ;
+AddFilesToNetBootArchive beos system add-ons kernel partitioning_systems
+	: intel session ;
+AddFilesToNetBootArchive beos system add-ons kernel interrupt_controllers
+	: $(PPC_ONLY)openpic ;
+
+if $(TARGET_ARCH) = x86 {
+	AddFilesToNetBootArchive beos system add-ons kernel cpu : generic_x86 ;
+}
+
+# drivers
+AddDriversToNetBootArchive				: console dprintf $(X86_ONLY)keyboard
+										  null random <driver>tty zero ;
+AddDriversToNetBootArchive disk scsi	: scsi_cd scsi_dsk ;
+AddDriversToNetBootArchive disk virtual	: nbd ;
+AddDriversToNetBootArchive net			: $(BEOS_ADD_ONS_DRIVERS_NET) ;
+
+# kernel
+AddFilesToNetBootArchive beos system : <revisioned>kernel_$(TARGET_ARCH) ;
+
+# scripts and data files
+
+local driverSettingsFiles = <driver-settings>kernel ;
+SEARCH on $(driverSettingsFiles)
+	= [ FDirName $(HAIKU_TOP) data settings kernel drivers ] ;
+AddFilesToNetBootArchive home config settings kernel drivers
+	: $(driverSettingsFiles) ;
+
+# boot module links
+#AddBootModuleSymlinksToNetBootArchive config_manager bfs block_io fast_log
+#	generic_ide_pci $(X86_ONLY)isa ide ide_adapter $(X86_ONLY)ide_isa intel
+#	locked_pool $(PPC_ONLY)openpic pci scsi scsi_cd scsi_dsk scsi_periph
+#	ahci silicon_image_3112
+#;
+
+# add-ons
+AddFilesToNetBootArchive beos system add-ons kernel network
+	: stack socket ;
+AddFilesToNetBootArchive beos system add-ons kernel network devices
+	: $(BEOS_NETWORK_DEVICES) ;
+AddFilesToNetBootArchive beos system add-ons kernel network datalink_protocols
+	: $(BEOS_NETWORK_DATALINK_PROTOCOLS) ;
+AddFilesToNetBootArchive beos system add-ons kernel network ppp
+	: $(BEOS_NETWORK_PPP) ;
+AddFilesToNetBootArchive beos system add-ons kernel network protocols
+	: $(BEOS_NETWORK_PROTOCOLS) ;
+
+
+#pragma mark - Build The Archive
+
+# archive target
+HAIKU_NET_BOOT_ARCHIVE = haiku-netboot.tgz ;
+MakeLocate $(haiku-netboot-archive) : $(HAIKU_OUTPUT_DIR) ;
+
+# the pseudo target all archive contents is attached to
+NotFile $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) ;
+
+# prepare the script that initializes the shell variables
+local initVarsScript = <NetBootArchive>haiku-netboot-init-vars ;
+local script = $(initVarsScript) ;
+MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
+Always $(script) ;
+
+AddVariableToScript $(script) : tmpDir : $(HAIKU_TMP_DIR) ;
+AddVariableToScript $(script) : addBuildCompatibilityLibDir
+	: $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ;
+AddTargetVariableToScript $(script) : <build>copyattr ;
+
+# create the other scripts
+local makeDirsScript = <NetBootArchive>haiku-netboot-make-dirs ;
+local copyFilesScript = <NetBootArchive>haiku-netboot-copy-files ;
+MakeLocate $(makeDirsScript) $(copyFilesScript) : $(HAIKU_OUTPUT_DIR) ;
+
+CreateNetBootArchiveMakeDirectoriesScript $(makeDirsScript) ;
+CreateNetBootArchiveCopyFilesScript $(copyFilesScript) ;
+
+# build the archive
+
+BuildNetBootArchive $(HAIKU_NET_BOOT_ARCHIVE) :
+	$(initVarsScript)
+	$(makeDirsScript)
+	$(copyFilesScript)
+;
+
+# remove the scripts we have generated
+RmTemps $(HAIKU_NET_BOOT_ARCHIVE) :
+	$(initVarsScript)
+	$(makeDirsScript)
+	$(copyFilesScript)
+;
+
+NotFile haiku-netboot-archive ;
+Depends haiku-netboot-archive : $(HAIKU_NET_BOOT_ARCHIVE) ;

build/jam/UserBuildConfig.sample

@@ -38,13 +38,14 @@ HAIKU_INSTALL_DIR = /Haiku ;
 # Affects the haiku-image, haiku-vmware-image, and install-haiku targets. Only
 # targets on which the HAIKU_INCLUDE_IN_IMAGE variable has been set will be
 # updated in the image file/installation directory.
-# The update-image, update-vmware-image, and update-install targets always set
+# The update-image, update-vmware-image, and update-install targets always invoke
-# this variable, so one likely doesn't ever need to set it manually.
+# this rule, so one likely doesn't ever need to do it manually.
-HAIKU_IMAGE_UPDATE_ONLY = 1 ;
+SetUpdateHaikuImageOnly 1 ;
 
 # libbe.so and the kernel will be updated on image updates. Note that this
-# doesn't work for pseudo targets like "kernel".
+# generally doesn't work for pseudo targets (it does where special support
-HAIKU_INCLUDE_IN_IMAGE on libbe.so kernel_x86 = 1 ;
+# has been added, like for "kernel").
+HAIKU_INCLUDE_IN_IMAGE on libbe.so kernel = 1 ;
 
 # Add "crashing_app" to the beos/bin directory of the Haiku image/installation.
 # Note, that this also makes the image depend on the target, i.e. it is

build/scripts/build_tgz_archive

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+if [ $# -lt 2 ]; then
+	echo "Usage: $0 <archive> <scripts> ..."
+fi
+
+# get the archive name
+archive=$1
+shift
+
+# The second argument is the shell script that initializes the variables:
+# tmpDir
+# addBuildCompatibilityLibDir
+# 
+# copyattr
+#
+. $1
+shift
+
+outputDir=$tmpDir/archive
+
+# this adds the build library dir to LD_LIBRARY_PATH
+eval "$addBuildCompatibilityLibDir"
+
+# map the shell commands
+sPrefix=
+tPrefix="$outputDir/"
+cd=cd
+scd=:
+cp="$copyattr -d"
+ln=ln
+mkdir=mkdir
+rm=rm
+
+# clear output dir
+$rm -rf $outputDir
+$mkdir $outputDir
+
+# populate output dir
+echo "Preparing contents of archive $archive ..."
+while [ $# -gt 0 ]; do
+	. $1
+	shift
+done
+
+# build the archive
+echo "Building archive $archive ..."
+$rm -f $archive
+contents=$(cd $outputDir; ls)
+tar -C $outputDir -czf $archive $contents || exit 1
+
+# clean up
+$rm -rf $outputDir