freebsd-src/release/picobsd/build/Makefile
Greg Lehey 4b61b305c0 Handle building individual targets better. It's still broken; the
only way to be sure the build works correctly is to do a 'make all'.
But with these changes, it's easier to test individual targets.  In
particular, ensure that the vnode file systems are mounted before
writing to them.

Ensure that we don't get CVS directories on our floppies.

Use kgzip instead of kzip to compress the loader.  This saves a few
kB.

Remove some test cruft.
1999-12-20 02:07:42 +00:00

251 lines
7.9 KiB
Makefile

# PicoBSD Makefile
#
# $FreeBSD$
#
# Building a PicoBSD kernel involves four basic operations:
#
# 1. Build a kernel. This is done by the 'kernel' target.
# 2. Build a PicoBSD file system. This file system is loaded into an
# MFS at boot time. This is done by the 'fs' target.
# 3. Build a single executable file for all the programs, and install it in
# the mfs image. This is done by the 'crunch' target.
# 4. Build a floppy image containing the MFS image and some helper code
# to boot it. This is done by the 'image' target.
# 5. Copy the image to the floppy. Done by the 'copy' target.
# You can set the SRC variable which points to your source tree. It's
# /usr/src by default (most people shouldn't change it).
SRC ?= /usr/src
EDITOR = vi
# LANGUAGE language to be used (en or pl)
LANGUAGE = en
# FLOPPY_SIZE floppy size in KB (default to 1440)
FLOPPY_SIZE = 1440
# BUILDDIR is this directory
BUILDDIR = ${.CURDIR}
# These programs are built with non-standard parameters. To be sure of
# getting them right, we need to rebuild every time; otherwise we might
# trip over the 'make world' objects.
# To do this right, we need to build the objects in a different directory.
# FIXME.
SPECIAL_PROGS = ../../../usr.bin/login ../../../usr.bin/passwd
# Get default parameters for MFS
.include "mfsinfo"
# MFS information
MFS_NAME = fs.PICOBSD
MFS_MOUNTPOINT = mmnt
MFS_VNODE = /dev/vn0
# /etc/rc for the mfs image. This reads the real stuff off the floppy
MFS_RC = floppy.tree/etc/mfs.rc
FLOPPY_NAME = picobsd.bin
FLOPPY_VNODE = /dev/vn1
FLOPPY_MOUNTPOINT = fmnt
# Variables for building kernel
CONF ?= $(SRC)/sys/i386/conf
CONFFILE = PICOBSD${suffix}
COMPILE = $(SRC)/sys/compile/$(CONFFILE)
KERNFILE = $(COMPILE)/kernel
FDEV ?= /dev/fd0
# DEVFS is currently broken. Always set this.
#
NO_DEVFS = yes
# Should we keep this?
VER = 0.445
all: kernel.gz ${MFS_NAME} crunch ${FLOPPY_NAME} copy crunch-2
kernel.gz: ${COMPILE}/kernel
@echo "--> Compressing kernel"
cp -p ${COMPILE}/kernel kernel
strip kernel
strip --remove-section=.note --remove-section=.comment kernel
gzip -f -9 -v -n kernel
@ls -l kernel.gz
# Create the MFS image file
${MFS_NAME}: ${MFS_VNODE} ${MFS_MOUNTPOINT}
@echo "--> Building and mounting MFS image vnode"
-umount -f ${MFS_MOUNTPOINT}
-umount -f ${MFS_VNODE}
rm -f .mfs_mounted
-vnconfig -u ${MFS_VNODE}
rm -f ${MFS_NAME}
dd of=${MFS_NAME} if=/dev/zero count=${MFS_SIZE} bs=1k
awk 'BEGIN {printf "%c%c", 85, 170}' | \
dd of=${MFS_NAME} obs=1 seek=510 conv=notrunc 2> /dev/null
vnconfig -s labels -c ${MFS_VNODE} ${MFS_NAME}
dd if=/boot/boot1 of=${MFS_NAME} conv=notrunc
disklabel -rw vn0 auto
newfs -i ${MFS_INODES} -m 0 -p 0 -o space ${MFS_VNODE}c
make .mfs_mounted
make -f Makefile.mfs DESTDIR=${MFS_MOUNTPOINT} LANGUAGE=${LANGUAGE}
make -f Makefile.mfs devnodes DESTDIR=${MFS_MOUNTPOINT} LANGUAGE=${LANGUAGE}
MFS_MOUNTPOINT=${MFS_MOUNTPOINT} INIT=${INIT} VER=${VER} BUILDDIR=${BUILDDIR} LANGUAGE=${LANGUAGE}
# Populate the MFS image.
crunch: ${MFS_MOUNTPOINT}
@echo "--> Populating MFS image"
-vnconfig -c ${MFS_VNODE} ${MFS_NAME}
make .mfs_mounted
# We need to make login with other options
for i in ${SPECIAL_PROGS}; do (cd $$i; make clean); done
cd crunch1; make SRC=${SRC} INIT=${INIT}; make install MFS_MOUNTPOINT=../${MFS_MOUNTPOINT}
# who can tell me how these damned help files get in here?
rm -rf ${MFS_MOUNTPOINT}/sbin/help
# Other files for the mfs file system
(cd mfs; tar cXf ../floppy.tree.exclude - . | (cd ../${MFS_MOUNTPOINT}; tar xf -))
cd ${MFS_MOUNTPOINT}; chown -R root *
df -ik ${MFS_MOUNTPOINT}
umount ${MFS_MOUNTPOINT}
rm .mfs_mounted
fsck -p ${MFS_VNODE}
# Create and mount the floppy image
${FLOPPY_NAME}: ${FLOPPY_VNODE} ${FLOPPY_MOUNTPOINT} ${MFS_NAME} .mfs_mounted
@echo "--> Preparing ${FLOPPY_SIZE}kB floppy filesystem"
-umount ${FLOPPY_VNODE}
rm -f .floppy_mounted
-vnconfig -u ${FLOPPY_VNODE}
dd of=${FLOPPY_NAME} if=/dev/zero count=${FLOPPY_SIZE} bs=1k
awk 'BEGIN {printf "%c%c", 85, 170}' | \
dd of=${FLOPPY_NAME} obs=1 seek=510 conv=notrunc
-vnconfig -s labels -c ${FLOPPY_VNODE} ${FLOPPY_NAME}
dd if=/boot/boot1 of=${FLOPPY_NAME} conv=notrunc
disklabel -Brw -b /boot/boot1 -s /boot/boot2 ${FLOPPY_VNODE}c fd${FLOPPY_SIZE}
newfs -i ${FLOPPY_INODES} -m 0 -p 0 -o space ${FLOPPY_VNODE}c
make .floppy_mounted
copy: ../floppy.tree/boot .floppy_mounted
@echo "--> Populating floppy filesystem from ../floppy.tree"
@echo -- Make a loader
kgzip -o floppy.tree/boot/loader /boot/loader
@echo -- copy base floppy tree
(wd=`pwd`; cd ../floppy.tree ; tar cXhf $${wd}/floppy.tree.exclude - . ) | \
(cd ${FLOPPY_MOUNTPOINT} ; tar xvf - )
@echo -- Now update from our private floppy tree if it exists
@echo -- Local files in `pwd`/floppy.tree
if [ -d floppy.tree ] ; then \
(cd floppy.tree; tar cXhf ../floppy.tree.exclude - .) | \
(cd ${FLOPPY_MOUNTPOINT} ; tar xvf - ); \
fi
# We get stuff here that we can't use. When the transition
# to Makefile-based build is complete, we can delete this.
# XXX
rm -rf ${FLOPPY_MOUNTPOINT}/etc
(cd floppy.etc; tar czvXf ../floppy.tree.exclude ../${FLOPPY_MOUNTPOINT}/etc.tar.gz .)
df -ik ${FLOPPY_MOUNTPOINT}
@echo -- Generate password file if we don't have one on the floppy.
@echo -- The variable PASSWD is defined in mfsinfo
if [ ${PASSWD} = NO ] ; then \
cp -p ${FLOPPY_MOUNTPOINT}/etc/master.passwd .; \
pwd_mkdb -d . master.passwd; \
mv spwd.db ${FLOPPY_MOUNTPOINT}/etc/; \
rm pwd.db master.passwd; \
fi
cp kernel.gz ${FLOPPY_MOUNTPOINT}/kernel.gz
if [ -f .mfs_mounted ]; then \
umount ${MFS_VNODE}; \
rm .mfs_mounted; \
fi
@echo -- Insert the MFS image
gzip -9cv ${MFS_NAME} > ${FLOPPY_MOUNTPOINT}/${MFS_NAME}.gz
(echo "-> Fixing permissions"; cd ${FLOPPY_MOUNTPOINT}; chown -R root *)
df -ik ${FLOPPY_MOUNTPOINT}
umount ${FLOPPY_MOUNTPOINT}
rm .floppy_mounted
floppy:
@if [ -f .floppy_mounted ]; then \
umount ${FLOPPY_MOUNTPOINT}; \
rm .floppy_mounted; \
fi
@echo Copying ${FLOPPY_NAME} to ${FDEV}c. This will take about 50 seconds.
@dd if=${FLOPPY_NAME} of=${FDEV}c bs=36b >/dev/null
@echo Safe to remove disk from ${FDEV}
floppy2:
@if [ -d crunch2 ]; then \
if [ ! -d crunch2/floppy2 ]; then \
(cd crunch2; make); \
fi; \
echo copying crunch2/floppy to ${FDEV}c. This will take about 50 seconds.; \
cd crunch2/floppy2; tar czvf - . | dd of=/dev/rfd0 conv=sync; \
echo Safe to remove disk from ${FDEV}; \
else \
echo No second floppy; \
fi
# crunch-2: Build second floppy
crunch-2:
if [ -d crunch2 ]; then cd crunch2; make; fi
# Secondary targets
${COMPILE}/kernel: ${CONFFILE}
@echo "--> Building kernel"
grep -q MD_ROOT ${CONFFILE}; if [ $$? -ne 0 ]; then \
echo -- '***** Config file must include MD_ROOT'; \
exit 1; \
fi
cp ${CONFFILE} ${CONF}; \
cd ${CONF}; \
config ${CONFFILE}; \
cd ${COMPILE}; \
make depend all
# Device nodes for the vnode devices
${FLOPPY_VNODE} ${MFS_VNODE}:
(cd /dev; ./MAKEDEV `basename $@`)
# Directories to make
${MFS_MOUNTPOINT} ${FLOPPY_MOUNTPOINT} ../floppy.tree/boot:
mkdir -p $@
tidy: umount vnunconfig
rm -f ${MFS_NAME} ${MFS_NAME}.gz ${FLOPPY_NAME} *~ Make.log kernel.gz
clean: tidy
if [ -d floppy.tree ]; then \
cd floppy.tree; rm -f boot/loader; \
fi
rm -rf ${MFS_MOUNTPOINT} ${FLOPPY_MOUNTPOINT} crunch1.conf
cd crunch1; make clean
if [ -d crunch2 ]; then cd crunch2; make clean; fi
if [ -d ${COMPILE} ] ; then cd ${COMPILE}; make clean; fi
# XXX Just for testing
vnconfig: vnunconfig
vnconfig -c ${MFS_VNODE} ${MFS_NAME}
vnconfig -c ${FLOPPY_VNODE} ${FLOPPY_NAME}
vnunconfig:
-vnconfig -u ${MFS_VNODE}
-vnconfig -u ${FLOPPY_VNODE}
mount: .floppy_mounted .mfs_mounted
umount:
-umount ${MFS_VNODE} ${MFS_MOUNTPOINT} ${FLOPPY_VNODE} ${FLOPPY_MOUNTPOINT}
rm -f .floppy_mounted .mfs_mounted
.floppy_mounted:
mount ${FLOPPY_VNODE} ${FLOPPY_MOUNTPOINT}
touch $@
.mfs_mounted:
mount ${MFS_VNODE} ${MFS_MOUNTPOINT}
touch $@