tools/tools/nanobsd/gateworks/common

   1 # $FreeBSD$
   2
   3 NANO_CFGDIR=${NANO_CFGDIR:-${NANO_SRC}/${NANO_TOOLS}/gateworks/cfg}
   4 test -d ${NANO_CFGDIR} || NANO_CFGDIR=/var/empty
   5 NANO_PMAKE="make"                                       # NB: disable -j 3
   6
   7 NANO_ARCH=arm
   8 TARGET_CPUTYPE=xscale; export TARGET_CPUTYPE            # XXX
   9 TARGET_BIG_ENDIAN=true; export TARGET_BIG_ENDIAN        # XXX
  10
  11 NANO_CUSTOMIZE="cust_allow_ssh_root"
  12
  13 clean_usr_local()
  14 {
  15         LOCAL_DIR=${NANO_WORLDDIR}/usr/local
  16         pprint 2 "Clean and create world directory (${LOCAL_DIR})"
  17         if rm -rf ${LOCAL_DIR}/ > /dev/null 2>&1 ; then
  18                 true
  19         else
  20                 chflags -R noschg ${LOCAL_DIR}/
  21                 rm -rf ${LOCAL_DIR}/
  22         fi
  23         for f in bin etc lib libdata libexec sbin share; do
  24                 mkdir -p ${LOCAL_DIR}/$f
  25         done
  26 }
  27 NANO_CUSTOMIZE="$NANO_CUSTOMIZE clean_usr_local"
  28
  29 cust_install_machine_files()
  30 {
  31         echo "cd ${NANO_TOOLS}/gateworks/Files"
  32         cd ${NANO_TOOLS}/gateworks/Files
  33         find . -print | grep -Ev '/(CVS|\.svn)' | cpio -dumpv ${NANO_WORLDDIR}
  34 }
  35 NANO_CUSTOMIZE="$NANO_CUSTOMIZE cust_install_files cust_install_machine_files"
  36
  37 buildenv()
  38 {
  39         cd ${NANO_SRC}
  40         env TARGET_ARCH=${NANO_ARCH} __MAKE_CONF=${NANO_MAKE_CONF} \
  41             DESTDIR=${NANO_WORLDDIR} make buildenv
  42 }
  43
  44 net80211_tools()
  45 {
  46         for f in wlanstats wlanwds wlanwatch; do
  47                 echo "(cd tools/tools/net80211/$f; make $1)";
  48         done | buildenv
  49 }
  50 net80211_clean_tools()
  51 {
  52         net80211_tools "clean"
  53 }
  54 net80211_build_tools()
  55 {
  56         net80211_tools ""
  57 }
  58 net80211_install_tools()
  59 {
  60         net80211_tools "install"
  61 }
  62 NANO_CUSTOMIZE="$NANO_CUSTOMIZE net80211_clean_tools"
  63 NANO_CUSTOMIZE="$NANO_CUSTOMIZE net80211_build_tools"
  64 NANO_CUSTOMIZE="$NANO_CUSTOMIZE net80211_install_tools"
  65
  66 ath_clean_tools()
  67 {
  68         echo "cd tools/tools/ath; make clean" | buildenv
  69 }
  70 ath_build_tools()
  71 {
  72         echo "cd tools/tools/ath; make" | buildenv
  73 }
  74 ath_install_tools()
  75 {
  76         echo "cd tools/tools/ath; make install" | buildenv
  77 }
  78 NANO_CUSTOMIZE="$NANO_CUSTOMIZE ath_clean_tools"
  79 NANO_CUSTOMIZE="$NANO_CUSTOMIZE ath_build_tools"
  80 NANO_CUSTOMIZE="$NANO_CUSTOMIZE ath_install_tools"
  81
  82 npe_clean_tools()
  83 {
  84         echo "cd tools/tools/npe; make clean" | buildenv
  85 }
  86 npe_build_tools()
  87 {
  88         echo "cd tools/tools/npe; make" | buildenv
  89 }
  90 npe_install_tools()
  91 {
  92         echo "cd tools/tools/npe; make install" | buildenv
  93 }
  94 NANO_CUSTOMIZE="$NANO_CUSTOMIZE npe_clean_tools"
  95 NANO_CUSTOMIZE="$NANO_CUSTOMIZE npe_build_tools"
  96 NANO_CUSTOMIZE="$NANO_CUSTOMIZE npe_install_tools"
  97
  98 NANO_MAKEFS="makefs -B big \
  99         -o bsize=4096,fsize=512,density=8192,optimization=space"
 100 export NANO_MAKEFS
 101
 102 # NB: leave c++ enabled so devd can be built
 103 CONF_BUILD="
 104 WITHOUT_ACPI=true
 105 WITHOUT_ATM=true
 106 WITHOUT_AUDIT=true
 107 WITHOUT_BIND_DNSSEC=true
 108 WITHOUT_BIND_ETC=true
 109 WITHOUT_BIND_LIBS_LWRES=true
 110 WITHOUT_BLUETOOTH=true
 111 WITHOUT_CALENDAR=true
 112 WITHOUT_CDDL=true
 113 WITHOUT_CVS=true
 114 WITHOUT_DICT=true
 115 WITHOUT_EXAMPLES=true
 116 WITHOUT_FORTRAN=true
 117 WITHOUT_GAMES=true
 118 WITHOUT_GCOV=true
 119 WITHOUT_GPIB=true
 120 WITHOUT_HTML=true
 121 WITHOUT_I4B=true
 122 WITHOUT_INET6=true
 123 WITHOUT_INFO=true
 124 WITHOUT_IPFILTER=true
 125 WITHOUT_IPX=true
 126 WITHOUT_KERBEROS=true
 127 WITHOUT_LIBKSE=true
 128 WITHOUT_LOCALES=true
 129 WITHOUT_LPR=true
 130 WITHOUT_MAN=true
 131 WITHOUT_NETCAT=true
 132 WITHOUT_NIS=true
 133 WITHOUT_NLS=true
 134 WITHOUT_NS_CACHING=true
 135 WITHOUT_OBJC=true
 136 WITHOUT_PROFILE=true
 137 WITHOUT_RCMDS=true
 138 WITHOUT_RCS=true
 139 WITHOUT_RESCUE=true
 140 WITHOUT_SENDMAIL=true
 141 WITHOUT_SHAREDOCS=true
 142 WITHOUT_SSP=true
 143 WITHOUT_SYSCONS=true
 144 WITHOUT_TCSH=true
 145 "
 146 CONF_INSTALL="$CONF_BUILD
 147 WITHOUT_TOOLCHAIN=true
 148 WITHOUT_INSTALLLIB=true
 149 "
 150
 151 # NB: override to suppress install of kernel.symbols
 152 install_kernel()
 153 {
 154         pprint 2 "install kernel"
 155         pprint 3 "log: ${MAKEOBJDIRPREFIX}/_.ik"
 156
 157         cd ${NANO_SRC}
 158         env TARGET_ARCH=${NANO_ARCH} ${NANO_PMAKE} installkernel \
 159                 INSTALL_NODEBUG=true \
 160                 DESTDIR=${NANO_WORLDDIR} \
 161                 __MAKE_CONF=${NANO_MAKE_CONF} KERNCONF=`basename ${NANO_KERNEL}` \
 162                 > ${MAKEOBJDIRPREFIX}/_.ik 2>&1
 163 }
 164
 165 # NB: override to force / on s1 instead of s1a
 166 setup_nanobsd_etc()
 167 {
 168         pprint 2 "configure nanobsd /etc"
 169
 170         (
 171         cd ${NANO_WORLDDIR}
 172
 173         # create diskless marker file
 174         touch etc/diskless
 175
 176         # Make root filesystem R/O by default
 177         echo "root_rw_mount=NO" >> etc/defaults/rc.conf
 178
 179         # save config file for scripts
 180         echo "NANO_DRIVE=${NANO_DRIVE}" > etc/nanobsd.conf
 181
 182         echo "/dev/${NANO_DRIVE}s1 / ufs ro 1 1" > etc/fstab
 183         echo "/dev/${NANO_DRIVE}s3 /cfg ufs rw,noauto 2 2" >> etc/fstab
 184         mkdir -p cfg
 185         )
 186 }
 187
 188 create_arm_diskimage()
 189 {
 190         pprint 2 "build diskimage"
 191         pprint 3 "log: ${MAKEOBJDIRPREFIX}/_.di"
 192
 193         (
 194         echo "NANO_MEDIASIZE:   $NANO_MEDIASIZE"
 195         echo "NANO_IMAGES:      $NANO_IMAGES"
 196         echo "NANO_SECTS:       $NANO_SECTS"
 197         echo "NANO_HEADS:       $NANO_HEADS"
 198         echo "NANO_CODESIZE:    $NANO_CODESIZE"
 199         echo "NANO_CONFSIZE:    $NANO_CONFSIZE"
 200         echo "NANO_DATASIZE:    $NANO_DATASIZE"
 201
 202         echo $NANO_MEDIASIZE $NANO_IMAGES \
 203                 $NANO_SECTS $NANO_HEADS \
 204                 $NANO_CODESIZE $NANO_CONFSIZE $NANO_DATASIZE |
 205         awk '
 206         {
 207                 printf "# %s\n", $0
 208
 209                 # size of cylinder in sectors
 210                 cs = $3 * $4
 211
 212                 # number of full cylinders on media
 213                 cyl = int ($1 / cs)
 214
 215                 # output fdisk geometry spec, truncate cyls to 1023
 216                 if (cyl <= 1023)
 217                         print "g c" cyl " h" $4 " s" $3
 218                 else
 219                         print "g c" 1023 " h" $4 " s" $3
 220
 221                 if ($7 > 0) {
 222                         # size of data partition in full cylinders
 223                         dsl = int (($7 + cs - 1) / cs)
 224                 } else {
 225                         dsl = 0;
 226                 }
 227
 228                 # size of config partition in full cylinders
 229                 csl = int (($6 + cs - 1) / cs)
 230
 231                 if ($5 == 0) {
 232                         # size of image partition(s) in full cylinders
 233                         isl = int ((cyl - dsl - csl) / $2)
 234                 } else {
 235                         isl = int (($5 + cs - 1) / cs)
 236                 }
 237
 238                 # First image partition start at second track
 239                 print "p 1 165 " $3, isl * cs - $3
 240                 c = isl * cs;
 241
 242                 # Second image partition (if any) also starts offset one
 243                 # track to keep them identical.
 244                 if ($2 > 1) {
 245                         print "p 2 165 " $3 + c, isl * cs - $3
 246                         c += isl * cs;
 247                 }
 248
 249                 # Config partition starts at cylinder boundary.
 250                 print "p 3 165 " c, csl * cs
 251                 c += csl * cs
 252
 253                 # Data partition (if any) starts at cylinder boundary.
 254                 if ($7 > 0) {
 255                         print "p 4 165 " c, dsl * cs
 256                 } else if ($7 < 0 && $1 > c) {
 257                         print "p 4 165 " c, $1 - c
 258                 } else if ($1 < c) {
 259                         print "Disk space overcommitted by", \
 260                             c - $1, "sectors" > "/dev/stderr"
 261                         exit 2
 262                 }
 263
 264                 # Force slice 1 to be marked active. This is necessary
 265                 # for booting the image from a USB device to work.
 266                 print "a 1"
 267         }
 268         ' > ${MAKEOBJDIRPREFIX}/_.fdisk
 269
 270         IMG=${NANO_DISKIMGDIR}/${NANO_IMGNAME}
 271         BS=${NANO_SECTS}b
 272
 273         if [ "${NANO_MD_BACKING}" = "swap" ] ; then
 274                 MD=`mdconfig -a -t swap -s ${NANO_MEDIASIZE} -x ${NANO_SECTS} \
 275                         -y ${NANO_HEADS}`
 276         else
 277                 echo ""; echo "Creating md backing file ${IMG} ..."
 278                 _c=`expr ${NANO_MEDIASIZE} / ${NANO_SECTS}`
 279                 pprint 2 "dd if=/dev/zero of=${IMG} bs=${BS} count=${_c}"
 280                 dd if=/dev/zero of=${IMG} bs=${BS} count=${_c}
 281                 pprint 2 "mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} -y ${NANO_HEADS}"
 282                 MD=`mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} \
 283                         -y ${NANO_HEADS}`
 284         fi
 285
 286         trap "mdconfig -d -u $MD" 1 2 15 EXIT
 287
 288         echo ""; echo "Write partition table ..."
 289         FDISK=${MAKEOBJDIRPREFIX}/_.fdisk
 290         pprint 2 "fdisk -i -f ${FDISK} ${MD}"
 291         fdisk -i -f ${FDISK} ${MD}
 292         pprint 2 "fdisk ${MD}"
 293         fdisk ${MD}
 294
 295         # Create first image
 296         IMG1=${NANO_DISKIMGDIR}/_.disk.image1
 297         echo ""; echo "Create first image ${IMG1} ..."
 298         SIZE=`awk '/^p 1/ { print $5 "b" }' ${FDISK}`
 299         pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${IMG1} ${NANO_WORLDDIR}"
 300         ${NANO_MAKEFS} -s ${SIZE} ${IMG1} ${NANO_WORLDDIR}
 301         pprint 2 "dd if=${IMG1} of=/dev/${MD}s1 bs=${BS}"
 302         dd if=${IMG1} of=/dev/${MD}s1 bs=${BS}
 303
 304         if [ $NANO_IMAGES -gt 1 -a $NANO_INIT_IMG2 -gt 0 ] ; then
 305                 IMG2=${NANO_DISKIMGDIR}/_.disk.image2
 306                 echo ""; echo "Create second image ${IMG2}..."
 307                 for f in ${NANO_WORLDDIR}/etc/fstab ${NANO_WORLDDIR}/conf/base/etc/fstab
 308                 do
 309                         sed -i "" "s/${NANO_DRIVE}s1/${NANO_DRIVE}s2/g" $f
 310                 done
 311
 312                 SIZE=`awk '/^p 2/ { print $5 "b" }' ${FDISK}`
 313                 pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${IMG2} ${NANO_WORLDDIR}"
 314                 ${NANO_MAKEFS} -s ${SIZE} ${IMG2} ${NANO_WORLDDIR}
 315                 pprint 2 "dd if=${IMG2} of=/dev/${MD}s2 bs=${BS}"
 316                 dd if=${IMG2} of=/dev/${MD}s2 bs=${BS}
 317         fi
 318
 319         # Create Config slice
 320         CFG=${NANO_DISKIMGDIR}/_.disk.cfg
 321         echo ""; echo "Creating config partition ${CFG}..."
 322         SIZE=`awk '/^p 3/ { print $5 "b" }' ${FDISK}`
 323         # XXX: fill from where ?
 324         pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${CFG} ${NANO_CFGDIR}"
 325         ${NANO_MAKEFS} -s ${SIZE} ${CFG} ${NANO_CFGDIR}
 326         pprint 2 "dd if=${CFG} of=/dev/${MD}s3 bs=${BS}"
 327         dd if=${CFG} of=/dev/${MD}s3 bs=${BS}
 328         pprint 2 "rm ${CFG}"
 329         rm ${CFG}; CFG=                 # NB: disable printing below
 330
 331         # Create Data slice, if any.
 332         if [ $NANO_DATASIZE -gt 0 ] ; then
 333                 DATA=${NANO_DISKIMGDIR}/_.disk.data
 334                 echo ""; echo "Creating data partition ${DATA}..."
 335                 SIZE=`awk '/^p 4/ { print $5 "b" }' ${FDISK}`
 336                 # XXX: fill from where ?
 337                 pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${DATA} /var/empty"
 338                 ${NANO_MAKEFS} -s ${SIZE} ${DATA} /var/empty
 339                 pprint 2 "dd if=${DATA} of=/dev/${MD}s4 bs=${BS}"
 340                 dd if=${DATA} of=/dev/${MD}s4 bs=${BS}
 341                 pprint 2 "rm ${DATA}"
 342                 rm ${DATA}; DATA=       # NB: disable printing below
 343         fi
 344
 345         if [ "${NANO_MD_BACKING}" = "swap" ] ; then
 346                 echo "Writing out _.disk.full..."
 347                 dd if=/dev/${MD} of=${IMG} bs=${BS}
 348         fi
 349
 350         echo ""
 351         echo "Completed images in:"
 352         echo ""
 353         echo "Full disk:         ${IMG}"
 354         echo "Primary partition: ${IMG1}"
 355         test "${IMG2}" && echo "2ndary partition:  ${IMG2}"
 356         test "${CFG}" &&  echo "/cfg partition:    ${CFG}"
 357         test "${DATA}" && echo "/data partition:   ${DATA}"
 358         echo ""
 359         echo "Use dd if=<file> of=/dev/<somewhere> bs=${BS} to transfer an"
 360         echo "image to bootable media /dev/<somewhere>."
 361         ) > ${MAKEOBJDIRPREFIX}/_.di 2>&1
 362 }