267d023df8
Following a suggestion by Ruslan, the initial creation of the includes and libraries (and build tools) is now done by invoking "make buildworld" (with -DPICOBSD which eventually will limit the amount of stuff built with a 2-line change in Makefile.inc1). The correct environment is then used for subsequent builds. Also remove write_mfs_in_kernel.c in favour of using dd All the above is conditional on __FreeBSD_version, as the previous method still worked for versions earlier than 500035, and I am unsure on how the "new" method works for earlier versions. Finally, note that the crunch.conf files need some work because some libraries (e.g. gmd) have gone away from the base installation.
945 lines
26 KiB
Bash
Executable File
945 lines
26 KiB
Bash
Executable File
#!/bin/sh -
|
||
#
|
||
# $FreeBSD$
|
||
#
|
||
# The new PicoBSD build script. Invoked as
|
||
#
|
||
# picobsd [options] floppy_type site_name
|
||
#
|
||
# Where floppy_type is a directory where the picobsd config info
|
||
# is held, and ${floppy_type}/floppy.tree.${site_name} contains
|
||
# optional site-specific configuration.
|
||
#
|
||
# For Options, see the bottom of the file where the processing is
|
||
# done. The picobsd(8) manpage might be of some help, but code and docs
|
||
# tend to lose sync over time...
|
||
#
|
||
# This script depends on the following files:
|
||
#
|
||
# in ${PICO_TREE} :
|
||
# Makefile.conf Makefile used to build the kernel
|
||
# config shell variables, sourced here.
|
||
# mfs.mtree mtree config file
|
||
#
|
||
# floppy.tree/ files which go on the floppy
|
||
# mfs_tree/ files which go onto the mfs
|
||
#
|
||
# in ${MY_TREE} :
|
||
# PICOBSD kernel config file
|
||
# config shell variables, sourced here.
|
||
# crunch.conf crunchgen configuration
|
||
# floppy.tree.exclude files from floppy.tree/ which we do not need here.
|
||
# floppy.tree/ local additions to the floppy.tree
|
||
# floppy.tree.${site}/ same as above, site specific.
|
||
|
||
#
|
||
#--- The main entry point is at the end.
|
||
#
|
||
|
||
# There are two set of initialization. The first one (set_defaults)
|
||
# is done on entry to the script, and is used to set default values
|
||
# for all variables which do not depend on floppy type and source tree.
|
||
#
|
||
# The second set is done after command line parsing, e.g.
|
||
# to resolve dependencies on the source tree.
|
||
#
|
||
# Naming:
|
||
# + variables that control operation (e.g. verbosity) and are generally
|
||
# set from the command line have o_ ("option") as a name prefix
|
||
#
|
||
# + variables which contain pathnames and values that should not change
|
||
# have c_ ("constant") as a name prefix
|
||
#
|
||
# + variables exported to Makefiles and subshells are CAPITAL
|
||
#
|
||
# + variables local to the script are lowercase, possibly with
|
||
# an l_ ("local") prefix
|
||
|
||
# SRC points to your FreeBSD source tree.
|
||
# l_usrtree points to the /usr subdir for the source tree.
|
||
# Normally /usr or ${SRC}/../usr
|
||
# l_objtree points to the obj tree. Normally ${l_usrtree}/obj-pico
|
||
# PICO_TREE is where standard picobsd stuff resides.
|
||
# Normally ${SRC}/release/picobsd
|
||
# You can set SRC with --src <directory>
|
||
# It is not recommended to override the other variables.
|
||
|
||
# MY_TREE (set later) is where this floppy type resides.
|
||
# BUILDDIR is the build directory
|
||
|
||
# set some default values for variables.
|
||
# needs to be done as the first thing in the script.
|
||
|
||
# log something on stdout if verbose.
|
||
o_verbose=0 # this needs to be here!
|
||
log() {
|
||
if [ ${o_verbose} -gt 0 ] ; then
|
||
printf "\n*** %s\n" "$*"
|
||
if [ ${o_verbose} -gt 1 ] ; then
|
||
read -p "=== Press enter to continue" foo
|
||
fi
|
||
fi
|
||
}
|
||
|
||
logverbose() {
|
||
printf "\n*** %s\n" "$*"
|
||
read -p "=== Press enter to continue" foo
|
||
}
|
||
|
||
set_defaults() {
|
||
# no way to use logging in this function, variable not set yet.
|
||
|
||
# EDITOR is the editor you use
|
||
# fd_size floppy size in KB (default to 1440). You can use 1480,
|
||
# 1720, 2880, etc. but beware that only 1440 and 1480 will boot
|
||
# from 1.44M floppy drives (1480 will not work on vmware).
|
||
EDITOR=${EDITOR:-vi}
|
||
fd_size=${fd_size:-1440}
|
||
|
||
o_all_in_mfs="yes" # put all files in mfs so you can boot and run
|
||
# the image via diskless boot.
|
||
o_clean="" # do not clean
|
||
o_interactive="" # default is interactive
|
||
o_verbose=0 # verbose level, 0 is silent
|
||
o_tarv="" # tar verbose flag, "" or "v"
|
||
o_init_src="" # non "" if we need to init libs and includes.
|
||
o_makeopts=${MAKEOPTS:--s} # make options, be silent by default
|
||
o_no_devfs=yes # we do not want devfs
|
||
o_do_modules="" # do not build modules
|
||
|
||
SRC="/usr/src" # default location for sources
|
||
c_startdir=`pwd` # directory where we start
|
||
# used to lookup config and create BUILDDIR
|
||
|
||
c_boot1=/boot/boot1 # boot blocks (in case you want custom ones)
|
||
c_boot2=/boot/boot2
|
||
|
||
c_reply=${c_reply:-`mktemp "/tmp/reply.XXXXXXXXXX"`}
|
||
# file where User replies will be put
|
||
c_mnt=`mktemp -d "/tmp/picobsd.XXXXXXXXXX"`
|
||
# mountpoint used to build memory filesystems
|
||
c_fs=fs.PICOBSD # filename used for the memory filesystem
|
||
c_img=picobsd.bin # filename used for the picobsd image
|
||
|
||
# select the right memory disk name
|
||
case `uname -r` in
|
||
5.*)
|
||
l_vn="md"
|
||
l_makedev="${SRC}/etc/MAKEDEV"
|
||
;;
|
||
*)
|
||
l_vn="vn"
|
||
l_makedev="/dev/MAKEDEV"
|
||
esac
|
||
# Find a suitable vnode
|
||
l_vnum=`mount | awk "/${l_vn}/ { num++ } END { printf \"%d\", num }"`
|
||
l_vndev=${l_vn}${l_vnum}
|
||
|
||
set -e
|
||
|
||
trap fail 2
|
||
#trap fail 3
|
||
#trap fail 6
|
||
trap fail 15
|
||
free_vnode # cleanup old vnodes
|
||
}
|
||
|
||
create_includes_and_libraries2() {
|
||
log "create_includes_and_libraries2() for ${SRC}"
|
||
MAKEOBJDIRPREFIX=${l_objtree}
|
||
export MAKEOBJDIRPREFIX
|
||
( cd ${SRC};
|
||
make -DNOCLEAN -DNOPROFILE -DNOGAMES -DNOLIBC_R -DPICOBSD buildworld
|
||
)
|
||
}
|
||
|
||
create_includes_and_libraries() {
|
||
log "create_includes_and_libraries() for ${SRC}"
|
||
# Optionally creates include directory and libraries.
|
||
mkdir -p ${l_usrtree}/include # the include directory...
|
||
mkdir -p ${l_usrtree}/share/misc # a few things go here
|
||
mkdir -p ${l_usrtree}/lib # libraries
|
||
mkdir -p ${l_usrtree}/sbin # some binaries
|
||
(cd ${SRC}; INCOWN=`id -un` BINOWN=`id -un` DESTDIR=${l_usrtree}/.. \
|
||
make -m ${SRC}/share/mk includes ) || fail $? includes
|
||
# Pick up the correct headers for libraries.
|
||
CFLAGS="-nostdinc -I${l_usrtree}/include" ; export CFLAGS
|
||
|
||
(cd ${SRC}
|
||
# $e is the invocation of make with correct environment
|
||
e="MAKEOBJDIRPREFIX=${l_objtree}/picobsd/libraries \
|
||
INCOWN=`id -un` BINOWN=`id -un` DESTDIR=${l_usrtree}/.. \
|
||
make -m ${SRC}/share/mk \
|
||
-DNOHTML -DNOINFO -DNOMAN -DNOSHARE -DNOFSCHG "
|
||
log "do a 'make obj' in a few places."
|
||
# This is very version-specific... The following works for 5.0
|
||
for i in lib secure/lib gnu/lib usr.sbin/pcvt/keycap \
|
||
gnu/usr.bin/perl usr.bin/lex usr.sbin/config ; do
|
||
(cd ${i}; eval $e obj)
|
||
done
|
||
log "now make the static libraries"
|
||
eval $e -DNOPROFILE -DNOPIC libraries
|
||
(cd ${SRC}/usr.sbin/config
|
||
eval $e # build binary
|
||
eval $e install # install it
|
||
)
|
||
) || fail $? "libraries"
|
||
log "Libraries done"
|
||
}
|
||
|
||
# set_type <type> looks in user or system directories for the floppy type
|
||
# specified as first argument, and sets variables according to the config.
|
||
# file. Also sets MY_TREE and BUILDDIR and SITE
|
||
|
||
set_type() {
|
||
local a
|
||
|
||
log "set_type()"
|
||
THETYPE=$1
|
||
SITE=$2
|
||
a=$1
|
||
for i in ${c_startdir}/${a} ${PICO_TREE}/${a} ; do
|
||
log "set_type: checking $i"
|
||
if [ -d $i -a -f $i/PICOBSD -a -f $i/crunch.conf ] ; then
|
||
set -- `cat $i/PICOBSD | \
|
||
awk '/^#PicoBSD/ {print $2, $3, $4, $5, $6}'`
|
||
if [ "$1" != "" ]; then
|
||
MFS_SIZE=$1 ; init_name=$2
|
||
mfs_inodes=$3 ; fd_inodes=$4
|
||
name=`(cd $i ; pwd) `
|
||
name=`basename $name`
|
||
MY_TREE=$i
|
||
BUILDDIR=${c_startdir}/build_dir-${name}
|
||
log "Matching file $name in $i"
|
||
return ;
|
||
fi
|
||
fi
|
||
done
|
||
echo "Type $a NOT FOUND"
|
||
}
|
||
|
||
clean_tree() {
|
||
log "clean_tree()"
|
||
if [ "${name}" = "" ] ; then
|
||
echo "---> Wrong floppy type"
|
||
exit 3
|
||
fi
|
||
rm -rf ${BUILDDIR}
|
||
}
|
||
|
||
# free as much as possible from the vnode
|
||
free_vnode() {
|
||
log "free_vnode() ${l_vndev} "
|
||
umount ${c_mnt} 2> /dev/null || true
|
||
umount /dev/${l_vndev} 2> /dev/null || true
|
||
if [ "${l_vn}" = "vn" ] ; then
|
||
vnconfig -u ${l_vndev} 2> /dev/null || true
|
||
else
|
||
mdconfig -d -u ${l_vnum} 2> /dev/null || true
|
||
fi
|
||
}
|
||
|
||
# prepare a message to be printed in the dialog menus.
|
||
set_msgs() { # OK
|
||
log "set_msgs()"
|
||
|
||
MSG1="Type: ${THETYPE} name $name"
|
||
|
||
MSG="PicoBSD build -- Current parameters:\n\n\t1. ${MSG1}\n\
|
||
\t2. MFS size: ${MFS_SIZE} kB\n\
|
||
\t3. Site-info: ${SITE}\n\t4. Full-path: ${MY_TREE}\n"
|
||
}
|
||
|
||
|
||
# Main build procedure.
|
||
build_image() {
|
||
log "build_image() <${name}>"
|
||
[ "${name}" != "" ] || fail $? bad_type
|
||
clear
|
||
set_msgs
|
||
printf "${MSG}---> We'll use the sources living in ${SRC}\n\n"
|
||
|
||
# read config variables from a global and then a type-specific file
|
||
# basically STAND_LINKS and MY_DEVS, but can also override other
|
||
# variables.
|
||
#
|
||
. ${PICO_TREE}/build/config
|
||
if [ -f ${MY_TREE}/config ] ; then
|
||
. ${MY_TREE}/config
|
||
fi
|
||
|
||
# location of the object directory
|
||
PICO_OBJ=${l_objtree}/picobsd/${THETYPE}
|
||
log "PICO_OBJ is ${PICO_OBJ}"
|
||
|
||
if [ ${OSVERSION} -ge 500035 ] ; then
|
||
MAKEOBJDIRPREFIX=${l_objtree}
|
||
export MAKEOBJDIRPREFIX
|
||
log `cd ${SRC}; make -f Makefile.inc1 -V WMAKEENV`
|
||
eval export `cd ${SRC}; make -f Makefile.inc1 -V WMAKEENV`
|
||
fi
|
||
# create build directory and subtree
|
||
mkdir -p ${BUILDDIR}/crunch
|
||
# remove any old stuff
|
||
rm -f ${BUILDDIR}/kernel.gz ${BUILDDIR}/${c_fs}
|
||
# invoke commands to build a kernel
|
||
do_kernel
|
||
# fill a subdirectory with things that go into the floppy
|
||
# (mostly /etc and similar stuff)
|
||
populate_floppy_fs
|
||
# populate it and produce a file with the MFS image
|
||
populate_mfs_tree # things which go into mfs
|
||
# create, mount and fill a filesystem with floppy image
|
||
fill_floppy_image # copies everything into the floppy
|
||
}
|
||
|
||
build_package() {
|
||
local z msg
|
||
|
||
log "build_package()"
|
||
touch build.status
|
||
echo "##############################################" >>build.status
|
||
echo "## `date` ">>build.status
|
||
echo "##############################################" >>build.status
|
||
for z in bridge dial router net isp ; do
|
||
set_type ${z}
|
||
echo "---------------------------------------------">>build.status
|
||
echo "Building TYPE=${z}, SIZE=${MFS_SIZE}" >>build.status
|
||
msg="(ok)" # error message
|
||
build_image || msg="** FAILED! **"
|
||
echo " ${msg}">>build.status
|
||
# where do i put things ?
|
||
# clean_tree
|
||
done
|
||
exit 0
|
||
}
|
||
|
||
# Set build parameters interactively
|
||
|
||
main_dialog() {
|
||
local ans i l
|
||
|
||
log "main_dialog()"
|
||
while [ true ] ; do
|
||
set_msgs
|
||
rm ${c_reply}
|
||
dialog --menu "PicoBSD build menu -- (29 sep 2001)" 19 70 12 \
|
||
N "--> READY, build it <---" \
|
||
T "${MSG1}" \
|
||
K "edit Kernel config file" \
|
||
E "Edit crunch.conf file" \
|
||
S "MFS Size: ${MFS_SIZE}kB" \
|
||
I "Init type: ${init_name}" \
|
||
F "Floppy size: ${fd_size}kB" \
|
||
M "MFS bytes per inode: ${mfs_inodes}" \
|
||
U "UFS bytes per inode: ${fd_inodes}" \
|
||
$ "Site-info: ${SITE}" \
|
||
Q "Quit" \
|
||
2> ${c_reply}
|
||
ans=`cat ${c_reply}`
|
||
rm ${c_reply}
|
||
case ${ans} in
|
||
T)
|
||
l=""
|
||
for i in ${c_startdir} ${c_startdir}/* ${PICO_TREE}/* ; do
|
||
if [ -d $i -a -f $i/PICOBSD -a -f $i/crunch.conf ]; then
|
||
l="$l `basename $i` `basename $i`"
|
||
fi
|
||
done
|
||
log $l
|
||
{ dialog --menu "Setup the type of configuration" 12 70 5 $l \
|
||
2> ${c_reply} && set_type "`cat ${c_reply}`" ${SITE} ; } || true
|
||
;;
|
||
I)
|
||
{ dialog --menu "Choose your init(8) program" \
|
||
10 70 2 init "Standard init (requires getty)" \
|
||
oinit "small init from TinyWare" 2> ${c_reply} \
|
||
&& init_name=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
K) ${EDITOR} ${MY_TREE}/PICOBSD ;;
|
||
|
||
E) ${EDITOR} ${MY_TREE}/crunch.conf ;;
|
||
|
||
S)
|
||
{ dialog --title "MFS Size setup" --inputbox \
|
||
"MFS size depends on what you need to put on the MFS image. Typically \
|
||
ranges between 820kB (for very small bridge/router images) to \
|
||
as much as 2500kB kB for a densely packed image. \
|
||
Keep in mind that this memory is \
|
||
totally lost to other programs. Usually you want to keep \
|
||
this as small as possible. " 10 70 2> ${c_reply} \
|
||
&& MFS_SIZE=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
\$)
|
||
{ dialog --title "Site info setup" --inputbox \
|
||
"Please enter the full path to the directory \
|
||
containing site-specific setup. \
|
||
This directory tree must contain files that replace \
|
||
standard ones in floppy.tree/ and mfs.tree/ . " \
|
||
10 70 2> ${c_reply} && SITE=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
F)
|
||
{ dialog --menu "Set floppy size" 15 70 4 \
|
||
1440 "1.44MB" 1720 "1.72MB" 2880 "2.88MB" 4096 "4MB" \
|
||
2> ${c_reply} && fd_size=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
M)
|
||
{ dialog --title "MFS bytes per inode:" --inputbox \
|
||
"Enter MFS bytes per inode (typically 4096..65536). \
|
||
A larger value means fewer inodes but more space on MFS" \
|
||
10 70 2> ${c_reply} && mfs_inodes=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
U)
|
||
{ dialog --title "Floppy bytes per inode:" --inputbox \
|
||
"Enter floppy bytes per inode (typically 3072..65536). \
|
||
A larger value means fewer inodes but more space on the floppy." \
|
||
10 70 2> ${c_reply} && fd_inodes=`cat ${c_reply}` ; } || true
|
||
;;
|
||
|
||
N) break 2
|
||
;;
|
||
|
||
Q) exit 0 ;;
|
||
|
||
*) echo "Unknown option \"${ans}\". Try again."
|
||
sleep 2
|
||
clear
|
||
;;
|
||
esac
|
||
done
|
||
}
|
||
|
||
# Call the build procedure
|
||
# Install image
|
||
do_install() {
|
||
log "do_install()"
|
||
|
||
if [ "${o_interactive}" = "NO" ] ; then
|
||
echo "+++ Build completed +++"
|
||
cat .build.reply
|
||
return
|
||
fi
|
||
dialog --title "Build ${THETYPE} completed" --inputbox \
|
||
"\nThe build process was completed successfuly.\n\
|
||
`cat .build.reply` \n\n\
|
||
Now we are going to install the image on the floppy.\n\
|
||
Please insert a blank floppy in /dev/fd0.\\n
|
||
WARNING: the contents of the floppy will be permanently erased!\n\
|
||
\n\
|
||
Your options:\n\
|
||
* ^C or [Cancel] to abort,\n\
|
||
* Enter to install ${c_img},\n\
|
||
" 20 80 2> ${c_reply}
|
||
if [ "$?" = "0" ]; then
|
||
echo "Writing ${c_img}..."
|
||
dd if=${BUILDDIR}/${c_img} of=/dev/fd0.${fd_size}
|
||
else
|
||
echo "Ok, the image is in ${c_img}"
|
||
fi
|
||
echo "Done."
|
||
}
|
||
|
||
|
||
#-------------------------------------------------------------------
|
||
|
||
# invoke the Makefile to compile the kernel.
|
||
do_kernel() { # OK
|
||
log "do_kernel() Preparing kernel \"$name\" in $MY_TREE"
|
||
(cd $MY_TREE; export name SRC BUILDDIR # used in this makefile ;
|
||
# export CONFIG
|
||
if [ "${o_do_modules}" = "yes" ] ; then
|
||
MODULES=""
|
||
export MODULES
|
||
fi
|
||
make -m ${SRC}/share/mk -v -f ${PICO_TREE}/build/Makefile.conf ) || \
|
||
fail $? missing_kernel
|
||
}
|
||
|
||
# Populate the variable part of the floppy filesystem. Must be done before
|
||
# the MFS because its content might need to be copied there as well.
|
||
#
|
||
# This involves fetching files from three subtrees, in this order:
|
||
#
|
||
# 1. a standard one, from which type-specific files are excluded;
|
||
# 2. a type-specific one;
|
||
# 3. a site-specific one.
|
||
#
|
||
# Files are first copied to a local tree and then compressed.
|
||
|
||
populate_floppy_fs() { # OK
|
||
local dst excl srcdir
|
||
|
||
log "populate_floppy_fs()"
|
||
dst=${BUILDDIR}/floppy.tree
|
||
log "pwd=`pwd` Populating floppy filesystem..."
|
||
|
||
# clean relics from old compilations.
|
||
rm -rf ${dst} || true
|
||
mkdir ${dst}
|
||
|
||
excl=${MY_TREE}/floppy.tree.exclude
|
||
if [ -f ${excl} ] ; then
|
||
excl="--exclude-from ${excl}"
|
||
log "Files excluded from generic tree: `echo;cat ${excl}`"
|
||
else
|
||
excl=""
|
||
fi
|
||
(cd ${PICO_TREE}/floppy.tree ; tar -cf - --exclude CVS ${excl} . ) | \
|
||
(cd ${dst} ; tar x${o_tarv}f - )
|
||
log "Copied from generic floppy-tree `echo; ls -laR ${dst}`"
|
||
|
||
srcdir=${MY_TREE}/floppy.tree
|
||
if [ -d ${srcdir} ] ; then
|
||
log "update with type-specific files:"
|
||
(cd ${srcdir} ; tar -cf - --exclude CVS . ) | \
|
||
(cd ${dst} ; tar x${o_tarv}f - )
|
||
log "Copied from type floppy-tree `echo; ls -laR ${dst}`"
|
||
else
|
||
log "No type-specific floppy-tree"
|
||
fi
|
||
if [ -d ${srcdir}.${SITE} ] ; then
|
||
log "Update with site-specific (${SITE}) files:"
|
||
(cd ${srcdir}.${SITE} ; tar -cf - --exclude CVS . ) | \
|
||
(cd ${dst} ; tar x${o_tarv}f - )
|
||
log "Copied from site floppy-tree `echo; ls -laR ${dst}`"
|
||
else
|
||
log "No site-specific floppy-tree"
|
||
fi
|
||
|
||
# gzip returns an error if it fails to compress some file
|
||
(cd $dst ; gzip -9 etc/*
|
||
log "Compressed files in etc/ `echo; ls -l etc`"
|
||
) || true
|
||
}
|
||
|
||
create_mfs() { # OK
|
||
log "create_mfs() Preparing MFS filesystem..."
|
||
|
||
free_vnode
|
||
|
||
# zero-fill the MFS image
|
||
init_fs_image ${BUILDDIR}/${c_fs} ${MFS_SIZE}
|
||
|
||
log "Labeling MFS image"
|
||
# Disklabel "auto" behaves strangely for sizes < 1024K. Basically
|
||
# it fails to install a label on the system. On the other hand,
|
||
# if you provide a specific disk type, the boot code is not
|
||
# installed so you have more space on the disk...
|
||
# For small image sizes, use std disktypes
|
||
if [ ${MFS_SIZE} -lt 1024 ] ; then
|
||
disklabel -rw ${l_vndev} fd${MFS_SIZE} || fail $? mfs_disklabel
|
||
else
|
||
disklabel -rw ${l_vndev} auto || fail $? mfs_disklabel
|
||
fi
|
||
newfs -i ${mfs_inodes} -m 0 -p 0 -o space -f 512 -b 4096 \
|
||
/dev/${l_vndev}c > /dev/null
|
||
mount /dev/${l_vndev}c ${c_mnt} || fail $? no_mount
|
||
log "`df /dev/${l_vndev}c`"
|
||
}
|
||
|
||
# Populate the memory filesystem with binaries and non-variable
|
||
# configuration files.
|
||
# First do an mtree pass, then create directory links and device entries,
|
||
# then run crunchgen etc. to build the binary and create links.
|
||
# Then copy the specific/generic mfs_tree.
|
||
# Finally, if required, make a copy of the floppy.tree onto /fd
|
||
|
||
populate_mfs_tree() {
|
||
local a dst
|
||
|
||
log "populate_mfs_tree()"
|
||
early_mfs_mount=0
|
||
if [ "${early_mfs_mount}" = "1" ] ; then
|
||
create_mfs
|
||
dst=${c_mnt}
|
||
else
|
||
dst=${BUILDDIR}/mfs.tree
|
||
# clean relics from old compilations.
|
||
rm -rf ${dst} || true
|
||
mkdir ${dst}
|
||
fi
|
||
|
||
log "pwd=`pwd`, Populating MFS tree..."
|
||
|
||
# use type-specific mfs.mtree, default to generic one.
|
||
a=${MY_TREE}/mfs.mtree
|
||
[ -f ${a} ] || a=${PICO_TREE}/build/mfs.mtree
|
||
log "Running mtree using $a..."
|
||
mtree -deU -f $a -p ${dst} > /dev/null || fail $? mtree
|
||
|
||
# XXX create links
|
||
for i in ${STAND_LINKS}; do
|
||
ln -s /stand ${dst}/$i
|
||
done
|
||
ln -s /dev/null ${dst}/var/run/log
|
||
ln -s /etc/termcap ${dst}/usr/share/misc/termcap
|
||
|
||
|
||
(
|
||
cd ${BUILDDIR}/crunch
|
||
log "Making and installing crunch1 from `pwd` src ${SRC}..."
|
||
a=${BUILDDIR}/crunch1.conf
|
||
( export BUILDDIR SRC MY_TREE PICO_OBJ ;
|
||
make -m ${SRC}/share/mk \
|
||
-v -f ${PICO_TREE}/build/Makefile.conf ${BUILDDIR}/crunch.mk )
|
||
log "Libs are ${LIBS} "
|
||
export SRC # used by crunch.mk
|
||
# export LIBS CFLAGS
|
||
log "Now make -f crunch.mk"
|
||
make -m ${SRC}/share/mk ${o_makeopts} -f ${BUILDDIR}/crunch.mk
|
||
strip --remove-section=.note --remove-section=.comment crunch1
|
||
mv crunch1 ${dst}/stand/crunch
|
||
chmod 555 ${dst}/stand/crunch
|
||
log "Making links for binaries..."
|
||
for i in `crunchgen -l $a` ; do
|
||
ln ${dst}/stand/crunch ${dst}/stand/${i};
|
||
done
|
||
# rm $a # do not remove!
|
||
) || fail $? crunch
|
||
|
||
if [ -f ${dst}/stand/sshd ] ; then
|
||
log "Setting up host key for sshd:"
|
||
if [ -f ${BUILDDIR}/floppy.tree/etc/ssh_host_key.gz ] ; then
|
||
log "Using existing host key"
|
||
else
|
||
log "Generating new host key"
|
||
ssh-keygen -f ${BUILDDIR}/floppy.tree/etc/ssh_host_key \
|
||
-N "" -C "root@picobsd"
|
||
gzip -9 ${BUILDDIR}/floppy.tree/etc/ssh_host_key* || true
|
||
fi
|
||
fi
|
||
|
||
log "Copy generic and site-specific MFS tree..."
|
||
for MFS_TREE in ${PICO_TREE}/mfs_tree ${MY_TREE}/mfs_tree ; do
|
||
if [ -d ${MFS_TREE} ] ; then
|
||
log "Copy ${MFS_TREE} ..."
|
||
(cd ${MFS_TREE} ; tar -cf - --exclude CVS . ) | \
|
||
(cd ${dst} ; tar x${o_tarv}f - )
|
||
fi
|
||
done
|
||
|
||
if [ "${o_all_in_mfs}" = "yes" ]; then
|
||
log "Copy generic floppy_tree into MFS..."
|
||
cp -Rp ${BUILDDIR}/floppy.tree/* ${dst}/fd
|
||
fi
|
||
|
||
[ "`id -u`" = "0" ] || cat <<__EOF
|
||
|
||
### -------------------------------------------------------------------
|
||
###
|
||
### WARNING: You are not running with root permissions, so the next
|
||
### stages are likely to fail because they call commands such as
|
||
### chown, {vn|md}config, mount/umount which need adequate rights.
|
||
###
|
||
### The results of the compilation so far is in directory
|
||
### ${BUILDDIR}
|
||
### which has the following content:
|
||
|
||
`ls -l ${BUILDDIR}`
|
||
|
||
###
|
||
### -------------------------------------------------------------------
|
||
|
||
__EOF
|
||
|
||
if [ "${o_no_devfs}" != "" ] ; then
|
||
# create device entries using MAKEDEV
|
||
(cd ${dst}/dev
|
||
ln -s ${l_makedev} ; chmod 555 MAKEDEV
|
||
./MAKEDEV ${MY_DEVS}
|
||
rm MAKEDEV
|
||
)
|
||
fi
|
||
log "Fixing permissions"
|
||
(cd ${dst}; chown -R root . )
|
||
|
||
if [ -n "${import_files}" ] ; then
|
||
log "importing ${import_files} into mfs"
|
||
# We do it in a chroot environment on the target so
|
||
# symlinks are followed correctly.
|
||
cp `which tar` ${dst}/my_copy_of_tar
|
||
(cd ${l_usrtree}/.. ; tar cf - ${import_files} ) | \
|
||
(chroot ${dst} /my_copy_of_tar xf - )
|
||
rm ${dst}/my_copy_of_tar
|
||
fi
|
||
|
||
if [ "${early_mfs_mount}" != "1" ] ; then
|
||
create_mfs
|
||
log "Copy mfs tree into file"
|
||
(cd ${dst} ; tar cf - . ) | ( cd ${c_mnt} ; tar xf - )
|
||
fi
|
||
# now umount and fsck the filesystem.
|
||
log "Status of mfs image"
|
||
df -ik ${c_mnt}
|
||
umount ${c_mnt}
|
||
fsck -p /dev/${l_vndev}c
|
||
free_vnode
|
||
}
|
||
|
||
final_cleanup() {
|
||
log "final_cleanup()"
|
||
free_vnode
|
||
rm -rf ${c_mnt} ${c_reply} 2> /dev/null || true
|
||
rm -f ${c_reply}
|
||
}
|
||
|
||
# fail errno errcode
|
||
# This function is used to trap errors and print msgs
|
||
#
|
||
fail() {
|
||
local errno errocode where
|
||
|
||
errno=$1
|
||
errcode=$2
|
||
where=$3
|
||
echo "---> fail: Error <${errno}> error code <${errcode}> in <${where}>"
|
||
case ${errcode} in
|
||
no_vnconfig)
|
||
echo "Error in vnconfig on /dev/${l_vndev}..."
|
||
echo "Either you are not running as root or your running kernel"
|
||
echo "does not have the ${l_vn}(4) device."
|
||
;;
|
||
mfs_disklabel)
|
||
echo "Error while labeling ${c_fs} size ${MFS_SIZE}"
|
||
;;
|
||
no_mount)
|
||
echo "Error while mounting ${c_fs} (/dev/${l_vndev}c) on ${c_mnt}"
|
||
;;
|
||
mtree)
|
||
echo "Error while making hierarchy in ${c_mnt}"
|
||
;;
|
||
crunch)
|
||
echo "Error while building ${name}."
|
||
;;
|
||
floppy_disklabel)
|
||
echo "Error while doing disklabel on of floppy.img size $fd_size"
|
||
;;
|
||
missing_kernel)
|
||
echo "Error: you must build PICOBSD${suffix} kernel first"
|
||
;;
|
||
includes)
|
||
echo "Error: failed while making includes"
|
||
;;
|
||
libraries)
|
||
echo "Error: failed while making libraries"
|
||
;;
|
||
bad_type)
|
||
echo "Error: unknown floppy type ${name}"
|
||
;;
|
||
no_space)
|
||
echo "Error: no space left on device (${where})"
|
||
;;
|
||
no_mfs)
|
||
echo "Error: while writing MFS into the kernel."
|
||
;;
|
||
"")
|
||
echo "User break"
|
||
errcode="userbreak"
|
||
;;
|
||
*)
|
||
echo "unknown error, maybe user break: $errno $errcode"
|
||
;;
|
||
esac
|
||
echo "---> Aborting $0"
|
||
# try to cleanup the vnode.
|
||
final_cleanup
|
||
exit 2
|
||
}
|
||
|
||
#
|
||
# Create a zero-filled disk image with a boot sector, and vnconfig it.
|
||
#
|
||
|
||
init_fs_image() { # filename size_in_kbytes
|
||
local imgname imgsize
|
||
|
||
log "init_fs_image() $1 $2"
|
||
imgname=$1 ; imgsize=$2
|
||
dd if=/dev/zero of=${imgname} count=${imgsize} bs=1k 2> /dev/null
|
||
dd if=${c_boot1} of=${imgname} conv=notrunc 2> /dev/null
|
||
|
||
if [ "${l_vn}" = "vn" ] ; then
|
||
vnconfig -c -s labels ${l_vndev} ${imgname} || fail $? no_vnconfig
|
||
else
|
||
mdconfig -a -t vnode -u ${l_vnum} -f ${imgname} || fail $? no_vnconfig
|
||
fi
|
||
}
|
||
|
||
|
||
fill_floppy_image() {
|
||
local blocks sectors dst
|
||
|
||
log "fill_floppy_image()"
|
||
dst=${c_mnt} # where to create the image
|
||
|
||
log "Preparing ${fd_size}kB floppy filesystem..."
|
||
|
||
# correct block and number of sectors according to size.
|
||
blocks=${fd_size}; sectors=18
|
||
if [ "${blocks}" = "1720" ]; then
|
||
blocks=1722 ; sectors=21
|
||
elif [ "${blocks}" = "1480" ]; then
|
||
blocks=1476 ;
|
||
fi
|
||
|
||
init_fs_image ${BUILDDIR}/${c_img} ${blocks}
|
||
|
||
log "Labeling floppy image"
|
||
b2=${BUILDDIR}/boot2 # modified boot2
|
||
perl -pne 's/\/boot\/loader/\/kernel\0\0\0\0\0/' ${c_boot2} > ${b2}
|
||
|
||
# create a disklabel ...
|
||
disklabel -Brw -b ${c_boot1} -s ${b2} ${l_vndev} auto || \
|
||
fail $? floppy_disklabel
|
||
|
||
# and copy partition c: into partition a: using some sed magic
|
||
disklabel ${l_vndev} | sed -e '/ c:/{p;s/c:/a:/;}' | \
|
||
disklabel -R ${l_vndev} /dev/stdin
|
||
|
||
log "Newfs floppy image"
|
||
newfs -i ${fd_inodes} -m 0 -p 0 -o space -f 512 -b 4096 \
|
||
/dev/${l_vndev}a > /dev/null
|
||
|
||
log "Mounting floppy image"
|
||
mount /dev/${l_vndev}a ${dst}
|
||
|
||
(
|
||
cd ${BUILDDIR}
|
||
# $1 takes the offset of the MFS filesystem
|
||
set `strings -at d kernel | grep "MFS Filesystem goes here"`
|
||
mfs_ofs=$(($1 + 8192))
|
||
log "Preload kernel with file ${c_fs} at ${mfs_ofs}"
|
||
dd if=${c_fs} ibs=8192 iseek=1 of=kernel obs=${mfs_ofs} \
|
||
oseek=1 conv=notrunc
|
||
log "Compress with kgzip and copy to floppy image"
|
||
kgzip -o kernel.gz kernel
|
||
cp -p kernel.gz ${dst}/kernel || fail $? no_space "copying kernel"
|
||
|
||
log "now transfer floppy tree if needed"
|
||
# now transfer the floppy tree. If it is already in mfs, dont bother.
|
||
if [ "${o_all_in_mfs}" != "yes" ] ; then
|
||
cp -Rp floppy.tree/* ${dst} || \
|
||
fail $? no_space "copying floppy tree"
|
||
fi
|
||
)
|
||
(log "Fixing permissions"; cd ${dst}; chown -R root *)
|
||
# rm -rf ${BUILDDIR}/floppy.tree || true # cleanup
|
||
|
||
df -ik ${dst} | colrm 70 > .build.reply
|
||
free_vnode
|
||
rm -rf ${dst}
|
||
rm ${BUILDDIR}/kernel.gz ${BUILDDIR}/${c_fs}
|
||
}
|
||
|
||
# This function creates variables which depend on the source tree in use:
|
||
# SRC, l_usrtree, l_objtree
|
||
# Optionally creates libraries, includes and the like (for cross compiles,
|
||
# needs to be done once).
|
||
|
||
set_build_parameters() {
|
||
log "set_build_parameters() SRC is ${SRC}"
|
||
if [ "${SRC}" = "/usr/src" ] ; then
|
||
l_usrtree=${USR:-/usr}
|
||
else
|
||
l_usrtree=${USR:-${SRC}/../usr}
|
||
fi
|
||
l_objtree=${l_usrtree}/obj-pico
|
||
PICO_TREE=${PICO_TREE:-${SRC}/release/picobsd}
|
||
set `grep "#define[\t ]__FreeBSD_version" ${SRC}/sys/sys/param.h`
|
||
OSVERSION=$3
|
||
logverbose "OSVERSION is ${OSVERSION}"
|
||
if [ "${o_init_src}" != "" ] ; then
|
||
if [ ${OSVERSION} -lt 500035 ] ; then
|
||
create_includes_and_libraries
|
||
else
|
||
create_includes_and_libraries2
|
||
fi
|
||
fi
|
||
if [ ${OSVERSION} -lt 500035 ] ; then
|
||
# Create the right LIBS and CFLAGS for further builds.
|
||
# and build the config program
|
||
LIBS="-L${l_usrtree}/lib"
|
||
CFLAGS="-nostdinc -I${l_usrtree}/include"
|
||
export LIBS CFLAGS
|
||
CONFIG=${l_usrtree}/sbin/config
|
||
export CONFIG
|
||
fi
|
||
}
|
||
|
||
#-------------------------------------------------------------------
|
||
# Main entry of the script. Initialize variables, parse command line
|
||
# arguments.
|
||
|
||
set_defaults
|
||
while [ true ]; do
|
||
case $1 in
|
||
--src) # set the source path instead of /usr/src
|
||
SRC=`(cd $2; pwd)`
|
||
shift
|
||
;;
|
||
--init)
|
||
o_init_src="YES"
|
||
;;
|
||
|
||
--floppy_size)
|
||
fd_size=$2
|
||
shift
|
||
;;
|
||
|
||
--all_in_mfs)
|
||
o_all_in_mfs="yes"
|
||
;;
|
||
|
||
--no_all_in_mfs)
|
||
o_all_in_mfs=""
|
||
;;
|
||
|
||
--modules) # also build kernel modules
|
||
o_do_modules="yes"
|
||
;;
|
||
-n)
|
||
o_interactive="NO"
|
||
;;
|
||
|
||
-clear|-clean|-c) # clean
|
||
o_clean="YES"
|
||
o_interactive="NO"
|
||
;;
|
||
|
||
-v) # need -v -v to wait for user input
|
||
o_verbose=$((${o_verbose}+1)) # verbose level
|
||
o_tarv="v" # tar verbose flag
|
||
o_makeopts="-d l" # be verbose
|
||
;;
|
||
*)
|
||
break ;
|
||
;;
|
||
|
||
esac
|
||
shift
|
||
done
|
||
set_build_parameters # things that depend on ${SRC}
|
||
set_type $1 $2 # type and site, respectively
|
||
|
||
# If $1="package", it creates a neat set of floppies
|
||
|
||
if [ "$1" = "package" ] ; then
|
||
build_package
|
||
fi
|
||
if [ "${o_interactive}" != "NO" ] ; then
|
||
main_dialog
|
||
fi
|
||
if [ "${o_clean}" = "YES" ] ; then
|
||
clean_tree
|
||
else
|
||
build_image
|
||
do_install
|
||
fi
|
||
final_cleanup
|
||
exit 0
|