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_DICT=true
 117 WITHOUT_EXAMPLES=true
 118 WITHOUT_FLOPPY=true
 119 WITHOUT_FORTRAN=true
 120 WITHOUT_GAMES=true
 121 WITHOUT_GCOV=true
 122 WITHOUT_GPIB=true
 123 WITHOUT_GROFF=true
 124 WITHOUT_HTML=true
 125 WITHOUT_INET6=true
 126 WITHOUT_INFO=true
 127 WITHOUT_IPFILTER=true
 128 WITHOUT_KERBEROS=true
 129 WITHOUT_LOCALES=true
 130 WITHOUT_LPR=true
 131 WITHOUT_MAN=true
 132 WITHOUT_MAIL=true
 133 WITHOUT_MAILWRAPPER=true
 134 WITHOUT_NETCAT=true
 135 WITHOUT_NIS=true
 136 WITHOUT_NLS=true
 137 WITHOUT_NS_CACHING=true
 138 WITHOUT_OBJC=true
 139 WITHOUT_PMC=true
 140 WITHOUT_PORTSNAP=true
 141 WITHOUT_PROFILE=true
 142 WITHOUT_QUOTAS=true
 143 WITHOUT_RCMDS=true
 144 WITHOUT_RCS=true
 145 WITHOUT_RESCUE=true
 146 WITHOUT_SENDMAIL=true
 147 WITHOUT_SHAREDOCS=true
 148 WITHOUT_SSP=true
 149 WITHOUT_SYSCONS=true
 150 WITHOUT_SYSINSTALL=true
 151 WITHOUT_TCSH=true
 152 WITHOUT_TFTPD=true
 153 WITHOUT_ZFS=true
 154 "
 155 CONF_INSTALL="$CONF_BUILD
 156 WITHOUT_TOOLCHAIN=true
 157 WITHOUT_INSTALLLIB=true
 158 INSTALL_NODEBUG=true
 159 "
 160
 161 # NB: override to force / on s1 instead of s1a
 162 setup_nanobsd_etc()
 163 {
 164         pprint 2 "configure nanobsd /etc"
 165
 166         (
 167         cd ${NANO_WORLDDIR}
 168
 169         # create diskless marker file
 170         touch etc/diskless
 171
 172         # Make root filesystem R/O by default
 173         echo "root_rw_mount=NO" >> etc/defaults/rc.conf
 174
 175         # save config file for scripts
 176         echo "NANO_DRIVE=${NANO_DRIVE}" > etc/nanobsd.conf
 177
 178         echo "/dev/${NANO_DRIVE}s1 / ufs ro 1 1" > etc/fstab
 179         echo "/dev/${NANO_DRIVE}s3 /cfg ufs rw,noauto 2 2" >> etc/fstab
 180         mkdir -p cfg
 181         )
 182 }
 183
 184 create_arm_diskimage()
 185 {
 186         pprint 2 "build diskimage"
 187         pprint 3 "log: ${MAKEOBJDIRPREFIX}/_.di"
 188
 189         (
 190         echo "NANO_MEDIASIZE:   $NANO_MEDIASIZE"
 191         echo "NANO_IMAGES:      $NANO_IMAGES"
 192         echo "NANO_SECTS:       $NANO_SECTS"
 193         echo "NANO_HEADS:       $NANO_HEADS"
 194         echo "NANO_CODESIZE:    $NANO_CODESIZE"
 195         echo "NANO_CONFSIZE:    $NANO_CONFSIZE"
 196         echo "NANO_DATASIZE:    $NANO_DATASIZE"
 197
 198         echo $NANO_MEDIASIZE $NANO_IMAGES \
 199                 $NANO_SECTS $NANO_HEADS \
 200                 $NANO_CODESIZE $NANO_CONFSIZE $NANO_DATASIZE |
 201         awk '
 202         {
 203                 printf "# %s\n", $0
 204
 205                 # size of cylinder in sectors
 206                 cs = $3 * $4
 207
 208                 # number of full cylinders on media
 209                 cyl = int ($1 / cs)
 210
 211                 # output fdisk geometry spec, truncate cyls to 1023
 212                 if (cyl <= 1023)
 213                         print "g c" cyl " h" $4 " s" $3
 214                 else
 215                         print "g c" 1023 " h" $4 " s" $3
 216
 217                 if ($7 > 0) {
 218                         # size of data partition in full cylinders
 219                         dsl = int (($7 + cs - 1) / cs)
 220                 } else {
 221                         dsl = 0;
 222                 }
 223
 224                 # size of config partition in full cylinders
 225                 csl = int (($6 + cs - 1) / cs)
 226
 227                 if ($5 == 0) {
 228                         # size of image partition(s) in full cylinders
 229                         isl = int ((cyl - dsl - csl) / $2)
 230                 } else {
 231                         isl = int (($5 + cs - 1) / cs)
 232                 }
 233
 234                 # First image partition start at second track
 235                 print "p 1 165 " $3, isl * cs - $3
 236                 c = isl * cs;
 237
 238                 # Second image partition (if any) also starts offset one
 239                 # track to keep them identical.
 240                 if ($2 > 1) {
 241                         print "p 2 165 " $3 + c, isl * cs - $3
 242                         c += isl * cs;
 243                 }
 244
 245                 # Config partition starts at cylinder boundary.
 246                 print "p 3 165 " c, csl * cs
 247                 c += csl * cs
 248
 249                 # Data partition (if any) starts at cylinder boundary.
 250                 if ($7 > 0) {
 251                         print "p 4 165 " c, dsl * cs
 252                 } else if ($7 < 0 && $1 > c) {
 253                         print "p 4 165 " c, $1 - c
 254                 } else if ($1 < c) {
 255                         print "Disk space overcommitted by", \
 256                             c - $1, "sectors" > "/dev/stderr"
 257                         exit 2
 258                 }
 259
 260                 # Force slice 1 to be marked active. This is necessary
 261                 # for booting the image from a USB device to work.
 262                 print "a 1"
 263         }
 264         ' > ${MAKEOBJDIRPREFIX}/_.fdisk
 265
 266         IMG=${NANO_DISKIMGDIR}/${NANO_IMGNAME}
 267         BS=${NANO_SECTS}b
 268
 269         if [ "${NANO_MD_BACKING}" = "swap" ] ; then
 270                 MD=`mdconfig -a -t swap -s ${NANO_MEDIASIZE} -x ${NANO_SECTS} \
 271                         -y ${NANO_HEADS}`
 272         else
 273                 echo ""; echo "Creating md backing file ${IMG} ..."
 274                 _c=`expr ${NANO_MEDIASIZE} / ${NANO_SECTS}`
 275                 pprint 2 "dd if=/dev/zero of=${IMG} bs=${BS} count=${_c}"
 276                 dd if=/dev/zero of=${IMG} bs=${BS} count=${_c}
 277                 pprint 2 "mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} -y ${NANO_HEADS}"
 278                 MD=`mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} \
 279                         -y ${NANO_HEADS}`
 280         fi
 281
 282         trap "mdconfig -d -u $MD" 1 2 15 EXIT
 283
 284         echo ""; echo "Write partition table ..."
 285         FDISK=${MAKEOBJDIRPREFIX}/_.fdisk
 286         pprint 2 "fdisk -i -f ${FDISK} ${MD}"
 287         fdisk -i -f ${FDISK} ${MD}
 288         pprint 2 "fdisk ${MD}"
 289         fdisk ${MD}
 290
 291         # Create first image
 292         IMG1=${NANO_DISKIMGDIR}/_.disk.image1
 293         echo ""; echo "Create first image ${IMG1} ..."
 294         SIZE=`awk '/^p 1/ { print $5 "b" }' ${FDISK}`
 295         pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${IMG1} ${NANO_WORLDDIR}"
 296         ${NANO_MAKEFS} -s ${SIZE} ${IMG1} ${NANO_WORLDDIR}
 297         pprint 2 "dd if=${IMG1} of=/dev/${MD}s1 bs=${BS}"
 298         dd if=${IMG1} of=/dev/${MD}s1 bs=${BS}
 299
 300         if [ $NANO_IMAGES -gt 1 -a $NANO_INIT_IMG2 -gt 0 ] ; then
 301                 IMG2=${NANO_DISKIMGDIR}/_.disk.image2
 302                 echo ""; echo "Create second image ${IMG2}..."
 303                 for f in ${NANO_WORLDDIR}/etc/fstab ${NANO_WORLDDIR}/conf/base/etc/fstab
 304                 do
 305                         sed -i "" "s/${NANO_DRIVE}s1/${NANO_DRIVE}s2/g" $f
 306                 done
 307
 308                 SIZE=`awk '/^p 2/ { print $5 "b" }' ${FDISK}`
 309                 pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${IMG2} ${NANO_WORLDDIR}"
 310                 ${NANO_MAKEFS} -s ${SIZE} ${IMG2} ${NANO_WORLDDIR}
 311                 pprint 2 "dd if=${IMG2} of=/dev/${MD}s2 bs=${BS}"
 312                 dd if=${IMG2} of=/dev/${MD}s2 bs=${BS}
 313         fi
 314
 315         # Create Config slice
 316         CFG=${NANO_DISKIMGDIR}/_.disk.cfg
 317         echo ""; echo "Creating config partition ${CFG}..."
 318         SIZE=`awk '/^p 3/ { print $5 "b" }' ${FDISK}`
 319         # XXX: fill from where ?
 320         pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${CFG} ${NANO_CFGDIR}"
 321         ${NANO_MAKEFS} -s ${SIZE} ${CFG} ${NANO_CFGDIR}
 322         pprint 2 "dd if=${CFG} of=/dev/${MD}s3 bs=${BS}"
 323         dd if=${CFG} of=/dev/${MD}s3 bs=${BS}
 324         pprint 2 "rm ${CFG}"
 325         rm ${CFG}; CFG=                 # NB: disable printing below
 326
 327         # Create Data slice, if any.
 328         if [ $NANO_DATASIZE -gt 0 ] ; then
 329                 DATA=${NANO_DISKIMGDIR}/_.disk.data
 330                 echo ""; echo "Creating data partition ${DATA}..."
 331                 SIZE=`awk '/^p 4/ { print $5 "b" }' ${FDISK}`
 332                 # XXX: fill from where ?
 333                 pprint 2 "${NANO_MAKEFS} -s ${SIZE} ${DATA} /var/empty"
 334                 ${NANO_MAKEFS} -s ${SIZE} ${DATA} /var/empty
 335                 pprint 2 "dd if=${DATA} of=/dev/${MD}s4 bs=${BS}"
 336                 dd if=${DATA} of=/dev/${MD}s4 bs=${BS}
 337                 pprint 2 "rm ${DATA}"
 338                 rm ${DATA}; DATA=       # NB: disable printing below
 339         fi
 340
 341         if [ "${NANO_MD_BACKING}" = "swap" ] ; then
 342                 echo "Writing out _.disk.full..."
 343                 dd if=/dev/${MD} of=${IMG} bs=${BS}
 344         fi
 345
 346         echo ""
 347         echo "Completed images in:"
 348         echo ""
 349         echo "Full disk:         ${IMG}"
 350         echo "Primary partition: ${IMG1}"
 351         test "${IMG2}" && echo "2ndary partition:  ${IMG2}"
 352         test "${CFG}" &&  echo "/cfg partition:    ${CFG}"
 353         test "${DATA}" && echo "/data partition:   ${DATA}"
 354         echo ""
 355         echo "Use dd if=<file> of=/dev/<somewhere> bs=${BS} to transfer an"
 356         echo "image to bootable media /dev/<somewhere>."
 357         ) > ${MAKEOBJDIRPREFIX}/_.di 2>&1
 358 }