[BACK]Return to build.sh CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/build.sh between version 1.104 and 1.105

version 1.104, 2003/05/18 10:57:11 version 1.105, 2003/05/25 12:34:27
Line 127  initdefaults()
Line 127  initdefaults()
         do_distribution=false          do_distribution=false
         do_release=false          do_release=false
         do_kernel=false          do_kernel=false
           do_releasekernel=false
         do_install=false          do_install=false
         do_sets=false          do_sets=false
         do_sourcesets=false          do_sourcesets=false
Line 342  Usage: ${progname} [-EnorUu] [-a arch] [
Line 343  Usage: ${progname} [-EnorUu] [-a arch] [
                         (Always done)                          (Always done)
     obj                 Run "make obj" (default unless -o is used)      obj                 Run "make obj" (default unless -o is used)
     tools               Build and install tools      tools               Build and install tools
     kernel=conf         Build kernel with config file \`conf'  
     install=idir        Run "make installworld" to \`idir'      install=idir        Run "make installworld" to \`idir'
                         (useful after 'distribution' or 'release')                          (useful after 'distribution' or 'release')
       kernel=conf         Build kernel with config file \`conf'
       releasekernel=conf  Install kernel built by kernel=conf to RELEASEDIR
     sets                Create binary sets in RELEASEDIR/MACHINE/binary/sets      sets                Create binary sets in RELEASEDIR/MACHINE/binary/sets
     sourcesets          Create source sets in RELEASEDIR/source/sets      sourcesets          Create source sets in RELEASEDIR/source/sets
   
Line 562  parseoptions()
Line 564  parseoptions()
                 makewrapper|obj|tools|build|distribution|release|sets|sourcesets)                  makewrapper|obj|tools|build|distribution|release|sets|sourcesets)
                         ;;                          ;;
   
                 kernel=*)                  kernel=*|releasekernel=*)
                         arg=${op#*=}                          arg=${op#*=}
                         op=${op%%=*}                          op=${op%%=*}
                         [ -n "${arg}" ] ||                          [ -n "${arg}" ] ||
                             bomb "Must supply a kernel name with \`kernel=...'"                              bomb "Must supply a kernel name with \`${op}=...'"
                         ;;                          ;;
   
                 install=*)                  install=*)
Line 683  validatemakeparams()
Line 685  validatemakeparams()
                 ${runcmd} mkdir -p "${makeobjdir}"                  ${runcmd} mkdir -p "${makeobjdir}"
         fi          fi
   
         statusmsg "MACHINE:         ${MACHINE}"          statusmsg "MACHINE:          ${MACHINE}"
         statusmsg "MACHINE_ARCH:    ${MACHINE_ARCH}"          statusmsg "MACHINE_ARCH:     ${MACHINE_ARCH}"
   
         # Find TOOLDIR, DESTDIR, and RELEASEDIR.          # Find TOOLDIR, DESTDIR, and RELEASEDIR.
         #          #
         TOOLDIR=$(getmakevar TOOLDIR)          TOOLDIR=$(getmakevar TOOLDIR)
         statusmsg "TOOLDIR path:    ${TOOLDIR}"          statusmsg "TOOLDIR path:     ${TOOLDIR}"
         DESTDIR=$(getmakevar DESTDIR)          DESTDIR=$(getmakevar DESTDIR)
         RELEASEDIR=$(getmakevar RELEASEDIR)          RELEASEDIR=$(getmakevar RELEASEDIR)
         if ! $do_expertmode; then          if ! $do_expertmode; then
                 _SRCTOPOBJ_=$(getmakevar _SRC_TOP_OBJ_)                  _SRC_TOP_OBJ_=$(getmakevar _SRC_TOP_OBJ_)
                 : ${DESTDIR:=${_SRCTOPOBJ_}/destdir.${MACHINE}}                  : ${DESTDIR:=${_SRC_TOP_OBJ_}/destdir.${MACHINE}}
                 : ${RELEASEDIR:=${_SRCTOPOBJ_}/releasedir}                  : ${RELEASEDIR:=${_SRC_TOP_OBJ_}/releasedir}
                 makeenv="${makeenv} DESTDIR RELEASEDIR"                  makeenv="${makeenv} DESTDIR RELEASEDIR"
         fi          fi
         export TOOLDIR DESTDIR RELEASEDIR          export TOOLDIR DESTDIR RELEASEDIR
         statusmsg "DESTDIR path:    ${DESTDIR}"          statusmsg "DESTDIR path:     ${DESTDIR}"
         statusmsg "RELEASEDIR path: ${RELEASEDIR}"          statusmsg "RELEASEDIR path:  ${RELEASEDIR}"
   
         # Check validity of TOOLDIR and DESTDIR.          # Check validity of TOOLDIR and DESTDIR.
         #          #
Line 735  validatemakeparams()
Line 737  validatemakeparams()
                         bomb "-U or -E must be set for build as an unprivileged user."                          bomb "-U or -E must be set for build as an unprivileged user."
                 fi                  fi
         fi          fi
           if ${do_releasekernel} && [ -z "${RELEASEDIR}" ]; then
                   bomb "Must set RELEASEDIR with \`releasekernel=...'"
           fi
 }  }
   
   
Line 798  exec "\${TOOLDIR}/bin/${toolprefix}make"
Line 803  exec "\${TOOLDIR}/bin/${toolprefix}make"
 EOF  EOF
         [ "${runcmd}" = "echo" ] && echo EOF          [ "${runcmd}" = "echo" ] && echo EOF
         ${runcmd} chmod +x "${makewrapper}"          ${runcmd} chmod +x "${makewrapper}"
         statusmsg "makewrapper:     ${makewrapper}"          statusmsg "makewrapper:      ${makewrapper}"
         statusmsg "Updated ${makewrapper}"          statusmsg "Updated ${makewrapper}"
 }  }
   
Line 819  buildtools()
Line 824  buildtools()
         statusmsg "Tools built to ${TOOLDIR}"          statusmsg "Tools built to ${TOOLDIR}"
 }  }
   
 buildkernel()  getkernelconf()
 {  {
         kernconf="$1"          kernelconf="$1"
         if ! ${do_tools}; then  
                 # Building tools every time we build a kernel is clearly  
                 # unnecessary.  We could try to figure out whether rebuilding  
                 # the tools is necessary this time, but it doesn't seem worth  
                 # the trouble.  Instead, we say it's the user's responsibility  
                 # to rebuild the tools if necessary.  
                 #  
                 statusmsg "Building kernel without building new tools"  
         fi  
         statusmsg "Building kernel ${kernconf}"  
         if [ "${MKOBJDIRS}" != "no" ] && [ ! -z "${makeobjdir}" ]; then          if [ "${MKOBJDIRS}" != "no" ] && [ ! -z "${makeobjdir}" ]; then
                 # The correct value of KERNOBJDIR might                  # The correct value of KERNOBJDIR might
                 # depend on a prior "make obj" in                  # depend on a prior "make obj" in
Line 846  buildkernel()
Line 841  buildkernel()
         fi          fi
         KERNCONFDIR="$(getmakevar KERNCONFDIR)"          KERNCONFDIR="$(getmakevar KERNCONFDIR)"
         KERNOBJDIR="$(getmakevar KERNOBJDIR)"          KERNOBJDIR="$(getmakevar KERNOBJDIR)"
         case "${kernconf}" in          case "${kernelconf}" in
         */*)          */*)
                 kernconfpath="${kernconf}"                  kernelconfpath="${kernelconf}"
                 kernconfbase="$(basename "${kernconf}")"                  kernelconfname="${kernelconf##*/}"
                 ;;                  ;;
         *)          *)
                 kernconfpath="${KERNCONFDIR}/${kernconf}"                  kernelconfpath="${KERNCONFDIR}/${kernelconf}"
                 kernconfbase="${kernconf}"                  kernelconfname="${kernelconf}"
                 ;;                  ;;
         esac          esac
         kernbuilddir="${KERNOBJDIR}/${kernconfbase}"          kernelbuildpath="${KERNOBJDIR}/${kernelconfname}"
         statusmsg "Kernel build directory: ${kernbuilddir}"  }
         ${runcmd} mkdir -p "${kernbuilddir}" ||  
             bomb "Cannot mkdir: ${kernbuilddir}"  buildkernel()
   {
           if ! ${do_tools} && ! ${buildkernelwarned:-false}; then
                   # Building tools every time we build a kernel is clearly
                   # unnecessary.  We could try to figure out whether rebuilding
                   # the tools is necessary this time, but it doesn't seem worth
                   # the trouble.  Instead, we say it's the user's responsibility
                   # to rebuild the tools if necessary.
                   #
                   statusmsg "Building kernel without building new tools"
                   buildkernelwarned=true
           fi
           getkernelconf $1
           statusmsg "Building kernel:  ${kernelconf}"
           statusmsg "Build directory:  ${kernelbuildpath}"
           ${runcmd} mkdir -p "${kernelbuildpath}" ||
               bomb "Cannot mkdir: ${kernelbuildpath}"
         if [ -z "${UPDATE}" ]; then          if [ -z "${UPDATE}" ]; then
                 ${runcmd} cd "${kernbuilddir}"                  ${runcmd} cd "${kernelbuildpath}"
                 ${runcmd} "${makewrapper}" cleandir ||                  ${runcmd} "${makewrapper}" cleandir ||
                     bomb "Failed to make cleandir in ${kernbuilddir}"                      bomb "Failed to make cleandir in ${kernelbuildpath}"
                 ${runcmd} cd "${TOP}"                  ${runcmd} cd "${TOP}"
         fi          fi
         ${runcmd} "${TOOLDIR}/bin/${toolprefix}config" -b "${kernbuilddir}" \          ${runcmd} "${TOOLDIR}/bin/${toolprefix}config" -b "${kernelbuildpath}" \
                 -s "${TOP}/sys" "${kernconfpath}" ||                  -s "${TOP}/sys" "${kernelconfpath}" ||
             bomb "${toolprefix}config failed for ${kernconf}"              bomb "${toolprefix}config failed for ${kernelconf}"
         ${runcmd} cd "${kernbuilddir}"          ${runcmd} cd "${kernelbuildpath}"
         ${runcmd} "${makewrapper}" depend ||          ${runcmd} "${makewrapper}" depend ||
             bomb "Failed to make depend in ${kernbuilddir}"              bomb "Failed to make depend in ${kernelbuildpath}"
         ${runcmd} "${makewrapper}" ${parallel} all ||          ${runcmd} "${makewrapper}" ${parallel} all ||
             bomb "Failed to make all in ${kernbuilddir}"              bomb "Failed to make all in ${kernelbuildpath}"
         ${runcmd} cd "${TOP}"          ${runcmd} cd "${TOP}"
   
         if [ "${runcmd}" != "echo" ]; then          if [ "${runcmd}" != "echo" ]; then
                 statusmsg "Kernels built from ${kernconf}:"                  statusmsg "Kernels built from ${kernelconf}:"
                 kernlist=$(awk '$1 == "config" { print $2 }' ${kernconfpath})                  kernlist=$(awk '$1 == "config" { print $2 }' ${kernelconfpath})
                 for kern in ${kernlist:-netbsd}; do                  for kern in ${kernlist:-netbsd}; do
                         [ -f "${kernbuilddir}/${kern}" ] && \                          [ -f "${kernelbuildpath}/${kern}" ] && \
                             echo "  ${kernbuilddir}/${kern}"                              echo "  ${kernelbuildpath}/${kern}"
                 done | tee -a "${results}"                  done | tee -a "${results}"
         fi          fi
 }  }
   
   releasekernel()
   {
           getkernelconf $1
           kernelreldir="${RELEASEDIR}/${MACHINE}/binary/kernel"
           ${runcmd} mkdir -p "${kernelreldir}"
           kernlist=$(awk '$1 == "config" { print $2 }' ${kernelconfpath})
   echo "releasekernel: conf ${kernelconf}, name ${kernelconfname}, build ${kernelbuildpath}"
           for kern in ${kernlist:-netbsd}; do
   echo "  checking ${kern} in ${kernelbuildpath}"
                   builtkern="${kernelbuildpath}/${kern}"
                   [ -f "${builtkern}" ] || continue
                   releasekern="${kernelreldir}/${kern}-${kernelconfname}.gz"
                   statusmsg "Kernel copy:      ${releasekern}"
                   ${runcmd} gzip -c -9 < "${builtkern}" > "${releasekern}"
           done
   }
   
 installworld()  installworld()
 {  {
         dir="$1"          dir="$1"
Line 932  main()
Line 960  main()
                         buildkernel "${arg}"                          buildkernel "${arg}"
                         ;;                          ;;
   
                   releasekernel=*)
                           arg=${op#*=}
                           releasekernel "${arg}"
                           ;;
   
                 install=*)                  install=*)
                         arg=${op#*=}                          arg=${op#*=}
                         if [ "${arg}" = "/" ] && \                          if [ "${arg}" = "/" ] && \
Legend:
Removed from v.1.104  
changed lines
  Added in v.1.105
CVSweb <webmaster@jp.NetBSD.org>