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