sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/releasetools/x86_hdimage.sh

125 lines
4.1 KiB
Bash
Raw Permalink Normal View History

releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
#!/usr/bin/env bash
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
set -e
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
#
# This script creates a bootable image and should at some point in the future
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# be replaced by the proper NetBSD infrastructure.
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
#
x86_hdimage: increase image size for bitcode build Make disk image size sufficient for LLVM bitcode build with symbols. Edited by David van Moolenbroek to do this only when -b is given. Change-Id: I3bde164756c477b4af5ed9435ca03da3b186cf7e
2014-08-06 15:11:22 +02:00
# Supported command line switches:
# -i build iso image instead of qemu imaeg
# -b bitcode build, increase partition sizes as necessary
#
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
: ${ARCH=i386}
: ${OBJ=../obj.${ARCH}}
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
: ${TOOLCHAIN_TRIPLET=i586-elf32-minix-}
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
: ${BUILDSH=build.sh}
Split minix distribution set The minix set is now divided into minix-base, minix-comp, minix-games, minix-kernel, minix-man and minix-tests. This allows massive space savings on the installlation CD because only the base system used for installation is stored uncompressed. Also, it makes the system more modular. Change-Id: Ic8d168b4c3112204013170f07245aef98aaa51e7
2015-09-16 16:00:24 +02:00
: ${SETS="minix-base minix-comp minix-games minix-man minix-tests tests"}
x86_hdimage.sh -i: crossbuild x86 release CD . build writeisofs as a native tool too for it . also mkfs.mfs: make missing file in proto nonlethal . make setup script a little more self-sufficient . hdboot: use INSTALL_FILE instead of INSTALL so that the results get added to the METALOG Change-Id: Id233e4c861f81046bf6c4be0510b8a3bf39ff9be
2013-11-05 15:43:44 +01:00
: ${IMG=minix_x86.img}
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
if [ ! -f ${BUILDSH} ]
then
echo "Please invoke me from the root source dir, where ${BUILDSH} is."
exit 1
fi
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# we create a disk image of about 2 gig's
# for alignment reasons, prefer sizes which are multiples of 4096 bytes
: ${BOOTXX_SECS=32}
: ${ROOT_SIZE=$(( 128*(2**20) - ${BOOTXX_SECS} * 512 ))}
: ${HOME_SIZE=$(( 128*(2**20) ))}
: ${USR_SIZE=$(( 1792*(2**20) ))}
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# set up disk creation environment
. releasetools/image.defaults
. releasetools/image.functions
CREATE_IMAGE_ONLY option added to releasetools/x86_hdimage.sh
2014-06-10 17:05:29 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# all sizes are written in 512 byte blocks
ROOTSIZEARG="-b $((${ROOT_SIZE} / 512 / 8))"
USRSIZEARG="-b $((${USR_SIZE} / 512 / 8))"
HOMESIZEARG="-b $((${HOME_SIZE} / 512 / 8))"
CREATE_IMAGE_ONLY option added to releasetools/x86_hdimage.sh
2014-06-10 17:05:29 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# where the kernel & boot modules will be
MODDIR=${DESTDIR}/boot/minix/.temp
mkfs.mfs -I: insert fs at offset feature . use it in x86_hdimage.sh: avoid copying big FS images into iso & hd images each time Change-Id: I0775f43cd1821ea7be2fec5b96d107a68afb96d6
2013-11-07 08:33:39 +01:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Building work directory..."
build_workdir "$SETS"
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Adding extra files..."
# create a fstab entry in /etc
cat >${ROOT_DIR}/etc/fstab <<END_FSTAB
/dev/c0d0p1 /usr mfs rw 0 2
/dev/c0d0p2 /home mfs rw 0 2
Add PTYFS, Unix98 pseudo terminal support This patch adds support for Unix98 pseudo terminals, that is, posix_openpt(3), grantpt(3), unlockpt(3), /dev/ptmx, and /dev/pts/. The latter is implemented with a new pseudo file system, PTYFS. In effect, this patch adds secure support for unprivileged pseudo terminal allocation, allowing programs such as tmux(1) to be used by non-root users as well. Test77 has been extended with new tests, and no longer needs to run as root. The new functionality is optional. To revert to the old behavior, remove the "ptyfs" entry from /etc/fstab. Technical nodes: o The reason for not implementing the NetBSD /dev/ptm approach is that implementing the corresponding ioctl (TIOCPTMGET) would require adding a number of extremely hairy exceptions to VFS, including the PTY driver having to create new file descriptors for its own device nodes. o PTYFS is required for Unix98 PTYs in order to avoid that the PTY driver has to be aware of old-style PTY naming schemes and even has to call chmod(2) on a disk-backed file system. PTY cannot be its own PTYFS since a character driver may currently not also be a file system. However, PTYFS may be subsumed into a DEVFS in the future. o The Unix98 PTY behavior differs somewhat from NetBSD's, in that slave nodes are created on ptyfs only upon the first call to grantpt(3). This approach obviates the need to revoke access as part of the grantpt(3) call. o Shutting down PTY may leave slave nodes on PTYFS, but once PTY is restarted, these leftover slave nodes will be removed before they create a security risk. Unmounting PTYFS will make existing PTY slaves permanently unavailable, and absence of PTYFS will block allocation of new Unix98 PTYs until PTYFS is (re)mounted. Change-Id: I822b43ba32707c8815fd0f7d5bb7a438f51421c1
2015-06-22 19:14:34 +02:00
none /sys devman rw,rslabel=devman 0 0
none /dev/pts ptyfs rw,rslabel=ptyfs 0 0
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
END_FSTAB
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
add_file_spec "etc/fstab" extra.fstab
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
cp ${DESTDIR}/usr/mdec/boot_monitor ${ROOT_DIR}/boot_monitor
add_file_spec "boot_monitor" extra.boot
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
Split minix distribution set The minix set is now divided into minix-base, minix-comp, minix-games, minix-kernel, minix-man and minix-tests. This allows massive space savings on the installlation CD because only the base system used for installation is stored uncompressed. Also, it makes the system more modular. Change-Id: Ic8d168b4c3112204013170f07245aef98aaa51e7
2015-09-16 16:00:24 +02:00
add_link_spec "boot/minix_latest" "minix_default" extra.kernel
workdir_add_kernel minix_default
workdir_add_kernel minix/$RELEASE_VERSION
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
# add boot.cfg
cat >${ROOT_DIR}/boot.cfg <<END_BOOT_CFG
clear=1
timeout=5
default=2
Split minix distribution set The minix set is now divided into minix-base, minix-comp, minix-games, minix-kernel, minix-man and minix-tests. This allows massive space savings on the installlation CD because only the base system used for installation is stored uncompressed. Also, it makes the system more modular. Change-Id: Ic8d168b4c3112204013170f07245aef98aaa51e7
2015-09-16 16:00:24 +02:00
menu=Start MINIX 3:load_mods /boot/minix_default/mod*; multiboot /boot/minix_default/kernel rootdevname=c0d0p0
menu=Start latest MINIX 3:load_mods /boot/minix_latest/mod*; multiboot /boot/minix_latest/kernel rootdevname=c0d0p0
menu=Start latest MINIX 3 in single user mode:load_mods /boot/minix_latest/mod*; multiboot /boot/minix_latest/kernel rootdevname=c0d0p0 bootopts=-s
Add boot menu entry to boot an ALIX SBC. closes #95 Change-Id: Ifb49cb8e4730d50d2d6a33fcb5e9f08ac790b512
2015-10-13 12:00:09 +02:00
menu=Start MINIX 3 ALIX:load_mods /boot/minix_default/mod*;multiboot /boot/minix_default/kernel rootdevname=c0d0p0 console=tty00 consdev=com0 ata_no_dma=1
Split minix distribution set The minix set is now divided into minix-base, minix-comp, minix-games, minix-kernel, minix-man and minix-tests. This allows massive space savings on the installlation CD because only the base system used for installation is stored uncompressed. Also, it makes the system more modular. Change-Id: Ic8d168b4c3112204013170f07245aef98aaa51e7
2015-09-16 16:00:24 +02:00
menu=Edit menu option:edit
menu=Drop to boot prompt:prompt
default=2
menu=Start MINIX 3 ($RELEASE_VERSION):load_mods /boot/minix/$RELEASE_VERSION/mod*; multiboot /boot/minix/$RELEASE_VERSION/kernel rootdevname=c0d0p0
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
END_BOOT_CFG
add_file_spec "boot.cfg" extra.boot
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Bundling packages..."
bundle_packages "$BUNDLE_PACKAGES"
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Creating specification files..."
create_input_spec
create_protos "usr home"
x86_hdimage.sh -i: crossbuild x86 release CD . build writeisofs as a native tool too for it . also mkfs.mfs: make missing file in proto nonlethal . make setup script a little more self-sufficient . hdboot: use INSTALL_FILE instead of INSTALL so that the results get added to the METALOG Change-Id: Id233e4c861f81046bf6c4be0510b8a3bf39ff9be
2013-11-05 15:43:44 +01:00
Split minix distribution set The minix set is now divided into minix-base, minix-comp, minix-games, minix-kernel, minix-man and minix-tests. This allows massive space savings on the installlation CD because only the base system used for installation is stored uncompressed. Also, it makes the system more modular. Change-Id: Ic8d168b4c3112204013170f07245aef98aaa51e7
2015-09-16 16:00:24 +02:00
# Clean image
if [ -f ${IMG} ] # IMG might be a block device
then
rm -f ${IMG}
fi
Adapting build system to call MAKEDEV for /dev * Remove static proto.dev * Update releasetools/*image.sh not to use proto.dev, as well as minor comments cleanup * Add TOOL_TOPROTO Change-Id: If7dc16d4ebb3b0c4e859786fad25d4af000c999f
2013-10-03 18:26:21 +02:00
#
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
# Generate /root, /usr and /home partition images.
Adapting build system to call MAKEDEV for /dev * Remove static proto.dev * Update releasetools/*image.sh not to use proto.dev, as well as minor comments cleanup * Add TOOL_TOPROTO Change-Id: If7dc16d4ebb3b0c4e859786fad25d4af000c999f
2013-10-03 18:26:21 +02:00
#
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Writing disk image..."
ROOT_START=${BOOTXX_SECS}
echo " * ROOT"
_ROOT_SIZE=$(${CROSS_TOOLS}/nbmkfs.mfs -d ${ROOTSIZEARG} -I $((${ROOT_START}*512)) ${IMG} ${WORK_DIR}/proto.root)
_ROOT_SIZE=$(($_ROOT_SIZE / 512))
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
USR_START=$((${ROOT_START} + ${_ROOT_SIZE}))
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo " * USR"
_USR_SIZE=$(${CROSS_TOOLS}/nbmkfs.mfs -d ${USRSIZEARG} -I $((${USR_START}*512)) ${IMG} ${WORK_DIR}/proto.usr)
_USR_SIZE=$(($_USR_SIZE / 512))
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
HOME_START=$((${USR_START} + ${_USR_SIZE}))
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo " * HOME"
_HOME_SIZE=$(${CROSS_TOOLS}/nbmkfs.mfs -d ${HOMESIZEARG} -I $((${HOME_START}*512)) ${IMG} ${WORK_DIR}/proto.home)
_HOME_SIZE=$(($_HOME_SIZE / 512))
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
releasetools/*image.sh - Removed an "export CPPFLAGS=${FLAG}" which prevented proper settings from the environment to be passed to the build step. - Re-arranged variable settings at the top, so that we don't need to evaluate the argument to vfat mkfs command anymore in arm_sdimage.sh - "Merged" both script for easier comparison in the future. Change-Id: Id59f902e4eaeb7f268d5051789462f14421a114a
2014-08-08 14:05:25 +02:00
#
# Write the partition table using the natively compiled
# minix partition utility
#
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
${CROSS_TOOLS}/nbpartition -m ${IMG} ${BOOTXX_SECS} 81:${_ROOT_SIZE} 81:${_USR_SIZE} 81:${_HOME_SIZE}
${CROSS_TOOLS}/nbinstallboot -f -m ${ARCH} ${IMG} ${DESTDIR}/usr/mdec/bootxx_minixfs3
x86 hd image creator A script that creates a HD image ready to be booted by an x86 emulator, ready to work in a crossbuild environment. It's really just for qemu/kvm as there's no boot code in the MBR and no bootloader installed so we rely on the in-kvm multiboot implementation for now. This is very convenient for passing args too. To minimize reliance on external tools, we use the Minix 'partition' utility to write the partition table of the HD image, which therefore has to be compiled natively. . new script releasetools/x86_hdimage.sh . natively compile minix 'partition' utility . make <machine/partition.h> 64-bit safe for it Change-Id: If645b4691536752271e0b8a8ed59a34f248dace4
2013-09-24 15:15:55 +02:00
Adapting build system to call MAKEDEV for /dev * Remove static proto.dev * Update releasetools/*image.sh not to use proto.dev, as well as minor comments cleanup * Add TOOL_TOPROTO Change-Id: If7dc16d4ebb3b0c4e859786fad25d4af000c999f
2013-10-03 18:26:21 +02:00
mods="`( cd ${MODDIR}; echo mod* | tr ' ' ',' )`"
New image framework generation The CD now boots directly from the ISO 9660 filesystem instead of using MBR partitioning with Minix file systems. This saves some space on the CD and reduces memory requirements by some unknown amount as the root ramdisk is completely eliminated. The x86 hard drive image creation is also rewritten in the same fashion. The setup is modified to be more NetBSD-like (unpacking sets tarballs instead of blindly copying the CD contents). Splitting MINIX into sets is done in another commit due to it being a nightmare to rebase. Since MINIX lacks union mounts for now, a bunch of ramdisks are generated at run-time to make parts of the filesystem writeable for the CD. This solution isn't ideal, but it's enough for an installation CD. Change-Id: Icbd9cca4dafebf7b42c345b107a17679a622d5cd
2015-09-14 21:46:48 +02:00
echo "Disk image at `pwd`/${IMG}"
echo "To boot this image on kvm:"
echo "cd ${MODDIR} && qemu-system-i386 --enable-kvm -m 256 -kernel kernel -append \"rootdevname=c0d0p0\" -initrd \"${mods}\" -hda `pwd`/${IMG}"
Reference in a new issue Copy permalink