From b39c8d3711299d7ff89bbb725ad5ce6036d5c4db Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Wed, 11 Jul 2007 01:04:35 +0000 Subject: [PATCH] * 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 | 3 +- build/jam/BuildSetup | 21 ++- build/jam/HaikuImage | 18 +- build/jam/ImageRules | 305 +++++++++++++++++++++++-------- build/jam/NetBootArchive | 133 ++++++++++++++ build/jam/UserBuildConfig.sample | 11 +- build/scripts/build_tgz_archive | 53 ++++++ 7 files changed, 455 insertions(+), 89 deletions(-) create mode 100644 build/jam/NetBootArchive create mode 100755 build/scripts/build_tgz_archive diff --git a/Jamfile b/Jamfile index 5f725e70fa..1594c4e5be 100644 --- a/Jamfile +++ b/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 ; diff --git a/build/jam/BuildSetup b/build/jam/BuildSetup index 28af1eadeb..a32ef62dc0 100644 --- a/build/jam/BuildSetup +++ b/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 diff --git a/build/jam/HaikuImage b/build/jam/HaikuImage index 6cde11189d..85cf7e226e 100644 --- a/build/jam/HaikuImage +++ b/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 : US-International : Key_map ; AddFilesToHaikuImage beos system : zbeos ; # boot module links -AddBootModuleSymlinks 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 +AddBootModuleSymlinksToHaikuImage 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 ; @@ -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 = haiku.image-init-vars ; diff --git a/build/jam/ImageRules b/build/jam/ImageRules index 84cfdc9844..0e4d89142e 100644 --- a/build/jam/ImageRules +++ b/build/jam/ImageRules @@ -95,15 +95,18 @@ actions AddTargetVariableToScript1 } -rule AddDirectoryToHaikuImage directoryTokens -{ - # AddDirectoryToHaikuImage +#pragma mark - +rule AddDirectoryToContainer container : directoryTokens +{ + # AddDirectoryToContainer : + + 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 : [ : dest name ] + # AddFilesToContainer : : + # [ : dest name ] # - local directory = [ AddDirectoryToHaikuImage $(1) ] ; - local targets = $(2) ; - local destName = $(3) ; + local directory = [ AddDirectoryToContainer $(container) + : $(directoryTokens) ] ; + 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) { - targets = [ FilterImageUpdateTargets $(targets) ] ; + if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] { + 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 : [ : ] ; + # AddSymlinkToContainer : : + # [ : ] ; # # 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 : ; - - # 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 : ; + # AddDriversToContainer : : ; # - 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 : : ] ; + # AddDriverRegistrationToContainer : + # : : ] ; # - 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 ; + # AddBootModuleSymlinksToContainer : ; # # 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" - "target" \"$(target)"\"." ; - Exit "ERROR: Add*ToHaikuImage has not been invoked for it yet." ; + Echo "ERROR: AddBootModuleSymlinksToContainer: Can't create a " + "symlink to target" \"$(target)"\"." ; + 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) { - CreateHaikuImageMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ; + if $(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 + + return [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) + : $(directoryTokens) ] ; +} + +rule AddFilesToHaikuImage directory : targets : destName +{ + # AddFilesToHaikuImage : [ : dest name ] + + AddFilesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory) + : $(targets) : $(destName) ; +} + +rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName +{ + # AddSymlinkToHaikuImage : [ : ] ; + + AddSymlinkToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens) + : $(linkTarget) : $(linkName) ; +} + +rule AddSourceDirectoryToHaikuImage dirTokens : alwaysUpdate +{ + # AddSourceDirectoryToHaikuImage : ; + + # 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 : ; + + AddDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME) + : $(relativeDirectoryTokens) : $(targets) ; +} + +rule AddDriverRegistrationToHaikuImage relativeDirectoryTokens : target : links +{ + # AddDriverRegistrationToHaikuImage : : ] ; + + AddDriverRegistrationToContainer $(HAIKU_IMAGE_CONTAINER_NAME) + : $(relativeDirectoryTokens) : $(target) : $(links) ; +} + +rule AddBootModuleSymlinksToHaikuImage targets +{ + # AddBootModuleSymlinksToHaikuImage ; + + 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 : : ; - # - 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 + + return [ AddDirectoryToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) + : $(directoryTokens) ] ; +} + +rule AddFilesToNetBootArchive directory : targets : destName +{ + # AddFilesToNetBootArchive : [ : dest name ] + + AddFilesToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(directory) + : $(targets) : $(destName) ; +} + +rule AddSymlinkToNetBootArchive directoryTokens : linkTarget : linkName +{ + # AddSymlinkToNetBootArchive : [ : ] ; + + AddSymlinkToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) + : $(directoryTokens) : $(linkTarget) : $(linkName) ; +} + +rule AddDriversToNetBootArchive relativeDirectoryTokens : targets +{ + # AddDriversToNetBootArchive : ; + + AddDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) + : $(relativeDirectoryTokens) : $(targets) ; +} + +rule AddDriverRegistrationToNetBootArchive relativeDirectoryTokens : target + : links +{ + # AddDriverRegistrationToNetBootArchive : + # : ] ; + + AddDriverRegistrationToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) + : $(relativeDirectoryTokens) : $(target) : $(links) ; +} + +rule AddBootModuleSymlinksToNetBootArchive targets +{ + # AddBootModuleSymlinksToNetBootArchive ; + + 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 : ; + + 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-]) +} diff --git a/build/jam/NetBootArchive b/build/jam/NetBootArchive new file mode 100644 index 0000000000..702139104c --- /dev/null +++ b/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 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 tty zero ; +AddDriversToNetBootArchive disk scsi : scsi_cd scsi_dsk ; +AddDriversToNetBootArchive disk virtual : nbd ; +AddDriversToNetBootArchive net : $(BEOS_ADD_ONS_DRIVERS_NET) ; + +# kernel +AddFilesToNetBootArchive beos system : kernel_$(TARGET_ARCH) ; + +# scripts and data files + +local driverSettingsFiles = 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 = 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) : copyattr ; + +# create the other scripts +local makeDirsScript = haiku-netboot-make-dirs ; +local copyFilesScript = 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) ; diff --git a/build/jam/UserBuildConfig.sample b/build/jam/UserBuildConfig.sample index 661daf8daa..5f4fddbf5d 100644 --- a/build/jam/UserBuildConfig.sample +++ b/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 -# this variable, so one likely doesn't ever need to set it manually. -HAIKU_IMAGE_UPDATE_ONLY = 1 ; +# The update-image, update-vmware-image, and update-install targets always invoke +# this rule, so one likely doesn't ever need to do it manually. +SetUpdateHaikuImageOnly 1 ; # libbe.so and the kernel will be updated on image updates. Note that this -# doesn't work for pseudo targets like "kernel". -HAIKU_INCLUDE_IN_IMAGE on libbe.so kernel_x86 = 1 ; +# generally doesn't work for pseudo targets (it does where special support +# 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 diff --git a/build/scripts/build_tgz_archive b/build/scripts/build_tgz_archive new file mode 100755 index 0000000000..d65d9bf381 --- /dev/null +++ b/build/scripts/build_tgz_archive @@ -0,0 +1,53 @@ +#!/bin/sh + +if [ $# -lt 2 ]; then + echo "Usage: $0 ..." +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