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
|
||
log "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
|