1#! /usr/bin/env sh 2# $NetBSD: build.sh,v 1.361 2021/12/31 15:43:35 christos Exp $ 3# 4# Copyright (c) 2001-2011 The NetBSD Foundation, Inc. 5# All rights reserved. 6# 7# This code is derived from software contributed to The NetBSD Foundation 8# by Todd Vierling and Luke Mewburn. 9# 10# Redistribution and use in source and binary forms, with or without 11# modification, are permitted provided that the following conditions 12# are met: 13# 1. Redistributions of source code must retain the above copyright 14# notice, this list of conditions and the following disclaimer. 15# 2. Redistributions in binary form must reproduce the above copyright 16# notice, this list of conditions and the following disclaimer in the 17# documentation and/or other materials provided with the distribution. 18# 19# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29# POSSIBILITY OF SUCH DAMAGE. 30# 31# 32# Top level build wrapper, to build or cross-build NetBSD. 33# 34 35# 36# {{{ Begin shell feature tests. 37# 38# We try to determine whether or not this script is being run under 39# a shell that supports the features that we use. If not, we try to 40# re-exec the script under another shell. If we can't find another 41# suitable shell, then we print a message and exit. 42# 43 44errmsg='' # error message, if not empty 45shelltest=false # if true, exit after testing the shell 46re_exec_allowed=true # if true, we may exec under another shell 47 48# Parse special command line options in $1. These special options are 49# for internal use only, are not documented, and are not valid anywhere 50# other than $1. 51case "$1" in 52"--shelltest") 53 shelltest=true 54 re_exec_allowed=false 55 shift 56 ;; 57"--no-re-exec") 58 re_exec_allowed=false 59 shift 60 ;; 61esac 62 63# Solaris /bin/sh, and other SVR4 shells, do not support "!". 64# This is the first feature that we test, because subsequent 65# tests use "!". 66# 67if test -z "$errmsg"; then 68 if ( eval '! false' ) >/dev/null 2>&1 ; then 69 : 70 else 71 errmsg='Shell does not support "!".' 72 fi 73fi 74 75# Does the shell support functions? 76# 77if test -z "$errmsg"; then 78 if ! ( 79 eval 'somefunction() { : ; }' 80 ) >/dev/null 2>&1 81 then 82 errmsg='Shell does not support functions.' 83 fi 84fi 85 86# Does the shell support the "local" keyword for variables in functions? 87# 88# Local variables are not required by SUSv3, but some scripts run during 89# the NetBSD build use them. 90# 91# ksh93 fails this test; it uses an incompatible syntax involving the 92# keywords 'function' and 'typeset'. 93# 94if test -z "$errmsg"; then 95 if ! ( 96 eval 'f() { local v=2; }; v=1; f && test x"$v" = x"1"' 97 ) >/dev/null 2>&1 98 then 99 errmsg='Shell does not support the "local" keyword in functions.' 100 fi 101fi 102 103# Does the shell support ${var%suffix}, ${var#prefix}, and their variants? 104# 105# We don't bother testing for ${var+value}, ${var-value}, or their variants, 106# since shells without those are sure to fail other tests too. 107# 108if test -z "$errmsg"; then 109 if ! ( 110 eval 'var=a/b/c ; 111 test x"${var#*/};${var##*/};${var%/*};${var%%/*}" = \ 112 x"b/c;c;a/b;a" ;' 113 ) >/dev/null 2>&1 114 then 115 errmsg='Shell does not support "${var%suffix}" or "${var#prefix}".' 116 fi 117fi 118 119# Does the shell support IFS? 120# 121# zsh in normal mode (as opposed to "emulate sh" mode) fails this test. 122# 123if test -z "$errmsg"; then 124 if ! ( 125 eval 'IFS=: ; v=":a b::c" ; set -- $v ; IFS=+ ; 126 test x"$#;$1,$2,$3,$4;$*" = x"4;,a b,,c;+a b++c"' 127 ) >/dev/null 2>&1 128 then 129 errmsg='Shell does not support IFS word splitting.' 130 fi 131fi 132 133# Does the shell support ${1+"$@"}? 134# 135# Some versions of zsh fail this test, even in "emulate sh" mode. 136# 137if test -z "$errmsg"; then 138 if ! ( 139 eval 'set -- "a a a" "b b b"; set -- ${1+"$@"}; 140 test x"$#;$1;$2" = x"2;a a a;b b b";' 141 ) >/dev/null 2>&1 142 then 143 errmsg='Shell does not support ${1+"$@"}.' 144 fi 145fi 146 147# Does the shell support $(...) command substitution? 148# 149if test -z "$errmsg"; then 150 if ! ( 151 eval 'var=$(echo abc); test x"$var" = x"abc"' 152 ) >/dev/null 2>&1 153 then 154 errmsg='Shell does not support "$(...)" command substitution.' 155 fi 156fi 157 158# Does the shell support $(...) command substitution with 159# unbalanced parentheses? 160# 161# Some shells known to fail this test are: NetBSD /bin/ksh (as of 2009-12), 162# bash-3.1, pdksh-5.2.14, zsh-4.2.7 in "emulate sh" mode. 163# 164if test -z "$errmsg"; then 165 if ! ( 166 eval 'var=$(case x in x) echo abc;; esac); test x"$var" = x"abc"' 167 ) >/dev/null 2>&1 168 then 169 # XXX: This test is ignored because so many shells fail it; instead, 170 # the NetBSD build avoids using the problematic construct. 171 : ignore 'Shell does not support "$(...)" with unbalanced ")".' 172 fi 173fi 174 175# Does the shell support getopts or getopt? 176# 177if test -z "$errmsg"; then 178 if ! ( 179 eval 'type getopts || type getopt' 180 ) >/dev/null 2>&1 181 then 182 errmsg='Shell does not support getopts or getopt.' 183 fi 184fi 185 186# 187# If shelltest is true, exit now, reporting whether or not the shell is good. 188# 189if $shelltest; then 190 if test -n "$errmsg"; then 191 echo >&2 "$0: $errmsg" 192 exit 1 193 else 194 exit 0 195 fi 196fi 197 198# 199# If the shell was bad, try to exec a better shell, or report an error. 200# 201# Loops are broken by passing an extra "--no-re-exec" flag to the new 202# instance of this script. 203# 204if test -n "$errmsg"; then 205 if $re_exec_allowed; then 206 for othershell in \ 207 "${HOST_SH}" /usr/xpg4/bin/sh ksh ksh88 mksh pdksh dash bash 208 # NOTE: some shells known not to work are: 209 # any shell using csh syntax; 210 # Solaris /bin/sh (missing many modern features); 211 # ksh93 (incompatible syntax for local variables); 212 # zsh (many differences, unless run in compatibility mode). 213 do 214 test -n "$othershell" || continue 215 if eval 'type "$othershell"' >/dev/null 2>&1 \ 216 && "$othershell" "$0" --shelltest >/dev/null 2>&1 217 then 218 cat <<EOF 219$0: $errmsg 220$0: Retrying under $othershell 221EOF 222 HOST_SH="$othershell" 223 export HOST_SH 224 exec $othershell "$0" --no-re-exec "$@" # avoid ${1+"$@"} 225 fi 226 # If HOST_SH was set, but failed the test above, 227 # then give up without trying any other shells. 228 test x"${othershell}" = x"${HOST_SH}" && break 229 done 230 fi 231 232 # 233 # If we get here, then the shell is bad, and we either could not 234 # find a replacement, or were not allowed to try a replacement. 235 # 236 cat <<EOF 237$0: $errmsg 238 239The NetBSD build system requires a shell that supports modern POSIX 240features, as well as the "local" keyword in functions (which is a 241widely-implemented but non-standardised feature). 242 243Please re-run this script under a suitable shell. For example: 244 245 /path/to/suitable/shell $0 ... 246 247The above command will usually enable build.sh to automatically set 248HOST_SH=/path/to/suitable/shell, but if that fails, then you may also 249need to explicitly set the HOST_SH environment variable, as follows: 250 251 HOST_SH=/path/to/suitable/shell 252 export HOST_SH 253 \${HOST_SH} $0 ... 254EOF 255 exit 1 256fi 257 258# 259# }}} End shell feature tests. 260# 261 262progname=${0##*/} 263toppid=$$ 264results=/dev/null 265tab=' ' 266nl=' 267' 268trap "exit 1" 1 2 3 15 269 270bomb() 271{ 272 cat >&2 <<ERRORMESSAGE 273 274ERROR: $@ 275*** BUILD ABORTED *** 276ERRORMESSAGE 277 kill ${toppid} # in case we were invoked from a subshell 278 exit 1 279} 280 281# Quote args to make them safe in the shell. 282# Usage: quotedlist="$(shell_quote args...)" 283# 284# After building up a quoted list, use it by evaling it inside 285# double quotes, like this: 286# eval "set -- $quotedlist" 287# or like this: 288# eval "\$command $quotedlist \$filename" 289# 290shell_quote() 291{( 292 local result='' 293 local arg qarg 294 LC_COLLATE=C ; export LC_COLLATE # so [a-zA-Z0-9] works in ASCII 295 for arg in "$@" ; do 296 case "${arg}" in 297 '') 298 qarg="''" 299 ;; 300 *[!-./a-zA-Z0-9]*) 301 # Convert each embedded ' to '\'', 302 # then insert ' at the beginning of the first line, 303 # and append ' at the end of the last line. 304 # Finally, elide unnecessary '' pairs at the 305 # beginning and end of the result and as part of 306 # '\'''\'' sequences that result from multiple 307 # adjacent quotes in he input. 308 qarg="$(printf "%s\n" "$arg" | \ 309 ${SED:-sed} -e "s/'/'\\\\''/g" \ 310 -e "1s/^/'/" -e "\$s/\$/'/" \ 311 -e "1s/^''//" -e "\$s/''\$//" \ 312 -e "s/'''/'/g" 313 )" 314 ;; 315 *) 316 # Arg is not the empty string, and does not contain 317 # any unsafe characters. Leave it unchanged for 318 # readability. 319 qarg="${arg}" 320 ;; 321 esac 322 result="${result}${result:+ }${qarg}" 323 done 324 printf "%s\n" "$result" 325)} 326 327statusmsg() 328{ 329 ${runcmd} echo "===> $@" | tee -a "${results}" 330} 331 332statusmsg2() 333{ 334 local msg 335 336 msg="${1}" 337 shift 338 case "${msg}" in 339 ????????????????*) ;; 340 ??????????*) msg="${msg} ";; 341 ?????*) msg="${msg} ";; 342 *) msg="${msg} ";; 343 esac 344 case "${msg}" in 345 ?????????????????????*) ;; 346 ????????????????????) msg="${msg} ";; 347 ???????????????????) msg="${msg} ";; 348 ??????????????????) msg="${msg} ";; 349 ?????????????????) msg="${msg} ";; 350 ????????????????) msg="${msg} ";; 351 esac 352 statusmsg "${msg}$*" 353} 354 355warning() 356{ 357 statusmsg "Warning: $@" 358} 359 360# Find a program in the PATH, and print the result. If not found, 361# print a default. If $2 is defined (even if it is an empty string), 362# then that is the default; otherwise, $1 is used as the default. 363find_in_PATH() 364{ 365 local prog="$1" 366 local result="${2-"$1"}" 367 local oldIFS="${IFS}" 368 local dir 369 IFS=":" 370 for dir in ${PATH}; do 371 if [ -x "${dir}/${prog}" ]; then 372 result="${dir}/${prog}" 373 break 374 fi 375 done 376 IFS="${oldIFS}" 377 echo "${result}" 378} 379 380# Try to find a working POSIX shell, and set HOST_SH to refer to it. 381# Assumes that uname_s, uname_m, and PWD have been set. 382set_HOST_SH() 383{ 384 # Even if ${HOST_SH} is already defined, we still do the 385 # sanity checks at the end. 386 387 # Solaris has /usr/xpg4/bin/sh. 388 # 389 [ -z "${HOST_SH}" ] && [ x"${uname_s}" = x"SunOS" ] && \ 390 [ -x /usr/xpg4/bin/sh ] && HOST_SH="/usr/xpg4/bin/sh" 391 392 # Try to get the name of the shell that's running this script, 393 # by parsing the output from "ps". We assume that, if the host 394 # system's ps command supports -o comm at all, it will do so 395 # in the usual way: a one-line header followed by a one-line 396 # result, possibly including trailing white space. And if the 397 # host system's ps command doesn't support -o comm, we assume 398 # that we'll get an error message on stderr and nothing on 399 # stdout. (We don't try to use ps -o 'comm=' to suppress the 400 # header line, because that is less widely supported.) 401 # 402 # If we get the wrong result here, the user can override it by 403 # specifying HOST_SH in the environment. 404 # 405 [ -z "${HOST_SH}" ] && HOST_SH="$( 406 (ps -p $$ -o comm | sed -ne "2s/[ ${tab}]*\$//p") 2>/dev/null )" 407 408 # If nothing above worked, use "sh". We will later find the 409 # first directory in the PATH that has a "sh" program. 410 # 411 [ -z "${HOST_SH}" ] && HOST_SH="sh" 412 413 # If the result so far is not an absolute path, try to prepend 414 # PWD or search the PATH. 415 # 416 case "${HOST_SH}" in 417 /*) : 418 ;; 419 */*) HOST_SH="${PWD}/${HOST_SH}" 420 ;; 421 *) HOST_SH="$(find_in_PATH "${HOST_SH}")" 422 ;; 423 esac 424 425 # If we don't have an absolute path by now, bomb. 426 # 427 case "${HOST_SH}" in 428 /*) : 429 ;; 430 *) bomb "HOST_SH=\"${HOST_SH}\" is not an absolute path." 431 ;; 432 esac 433 434 # If HOST_SH is not executable, bomb. 435 # 436 [ -x "${HOST_SH}" ] || 437 bomb "HOST_SH=\"${HOST_SH}\" is not executable." 438 439 # If HOST_SH fails tests, bomb. 440 # ("$0" may be a path that is no longer valid, because we have 441 # performed "cd $(dirname $0)", so don't use $0 here.) 442 # 443 "${HOST_SH}" build.sh --shelltest || 444 bomb "HOST_SH=\"${HOST_SH}\" failed functionality tests." 445} 446 447# initdefaults -- 448# Set defaults before parsing command line options. 449# 450initdefaults() 451{ 452 makeenv= 453 makewrapper= 454 makewrappermachine= 455 runcmd= 456 operations= 457 removedirs= 458 459 [ -d usr.bin/make ] || cd "$(dirname $0)" 460 [ -d usr.bin/make ] || 461 bomb "usr.bin/make not found; build.sh must be run from the top \ 462level of source directory" 463 [ -f share/mk/bsd.own.mk ] || 464 bomb "src/share/mk is missing; please re-fetch the source tree" 465 466 # Set various environment variables to known defaults, 467 # to minimize (cross-)build problems observed "in the field". 468 # 469 # LC_ALL=C must be set before we try to parse the output from 470 # any command. Other variables are set (or unset) here, before 471 # we parse command line arguments. 472 # 473 # These variables can be overridden via "-V var=value" if 474 # you know what you are doing. 475 # 476 unsetmakeenv C_INCLUDE_PATH 477 unsetmakeenv CPLUS_INCLUDE_PATH 478 unsetmakeenv INFODIR 479 unsetmakeenv LESSCHARSET 480 unsetmakeenv MAKEFLAGS 481 unsetmakeenv TERMINFO 482 setmakeenv LC_ALL C 483 484 # Find information about the build platform. This should be 485 # kept in sync with _HOST_OSNAME, _HOST_OSREL, and _HOST_ARCH 486 # variables in share/mk/bsd.sys.mk. 487 # 488 # Note that "uname -p" is not part of POSIX, but we want uname_p 489 # to be set to the host MACHINE_ARCH, if possible. On systems 490 # where "uname -p" fails, prints "unknown", or prints a string 491 # that does not look like an identifier, fall back to using the 492 # output from "uname -m" instead. 493 # 494 uname_s=$(uname -s 2>/dev/null) 495 uname_r=$(uname -r 2>/dev/null) 496 uname_m=$(uname -m 2>/dev/null) 497 uname_p=$(uname -p 2>/dev/null || echo "unknown") 498 case "${uname_p}" in 499 ''|unknown|*[!-_A-Za-z0-9]*) uname_p="${uname_m}" ;; 500 esac 501 502 id_u=$(id -u 2>/dev/null || /usr/xpg4/bin/id -u 2>/dev/null) 503 504 # If $PWD is a valid name of the current directory, POSIX mandates 505 # that pwd return it by default which causes problems in the 506 # presence of symlinks. Unsetting PWD is simpler than changing 507 # every occurrence of pwd to use -P. 508 # 509 # XXX Except that doesn't work on Solaris. Or many Linuces. 510 # 511 unset PWD 512 TOP=$( (exec pwd -P 2>/dev/null) || (exec pwd 2>/dev/null) ) 513 514 # The user can set HOST_SH in the environment, or we try to 515 # guess an appropriate value. Then we set several other 516 # variables from HOST_SH. 517 # 518 set_HOST_SH 519 setmakeenv HOST_SH "${HOST_SH}" 520 setmakeenv BSHELL "${HOST_SH}" 521 setmakeenv CONFIG_SHELL "${HOST_SH}" 522 523 # Set defaults. 524 # 525 toolprefix=nb 526 527 # Some systems have a small ARG_MAX. -X prevents make(1) from 528 # exporting variables in the environment redundantly. 529 # 530 case "${uname_s}" in 531 Darwin | FreeBSD | CYGWIN*) 532 MAKEFLAGS="-X ${MAKEFLAGS}" 533 ;; 534 esac 535 536 # do_{operation}=true if given operation is requested. 537 # 538 do_expertmode=false 539 do_rebuildmake=false 540 do_removedirs=false 541 do_tools=false 542 do_libs=false 543 do_cleandir=false 544 do_obj=false 545 do_build=false 546 do_distribution=false 547 do_release=false 548 do_kernel=false 549 do_releasekernel=false 550 do_kernels=false 551 do_modules=false 552 do_installmodules=false 553 do_install=false 554 do_sets=false 555 do_sourcesets=false 556 do_syspkgs=false 557 do_iso_image=false 558 do_iso_image_source=false 559 do_live_image=false 560 do_install_image=false 561 do_disk_image=false 562 do_params=false 563 do_rump=false 564 do_dtb=false 565 566 # done_{operation}=true if given operation has been done. 567 # 568 done_rebuildmake=false 569 570 # Create scratch directory 571 # 572 tmpdir="${TMPDIR-/tmp}/nbbuild$$" 573 mkdir "${tmpdir}" || bomb "Cannot mkdir: ${tmpdir}" 574 trap "cd /; rm -r -f \"${tmpdir}\"" 0 575 results="${tmpdir}/build.sh.results" 576 577 # Set source directories 578 # 579 setmakeenv NETBSDSRCDIR "${TOP}" 580 581 # Make sure KERNOBJDIR is an absolute path if defined 582 # 583 case "${KERNOBJDIR}" in 584 ''|/*) ;; 585 *) KERNOBJDIR="${TOP}/${KERNOBJDIR}" 586 setmakeenv KERNOBJDIR "${KERNOBJDIR}" 587 ;; 588 esac 589 590 # Find the version of NetBSD 591 # 592 DISTRIBVER="$(${HOST_SH} ${TOP}/sys/conf/osrelease.sh)" 593 594 # Set the BUILDSEED to NetBSD-"N" 595 # 596 setmakeenv BUILDSEED "NetBSD-$(${HOST_SH} ${TOP}/sys/conf/osrelease.sh -m)" 597 598 # Set MKARZERO to "yes" 599 # 600 setmakeenv MKARZERO "yes" 601 602} 603 604# valid_MACHINE_ARCH -- A multi-line string, listing all valid 605# MACHINE/MACHINE_ARCH pairs. 606# 607# Each line contains a MACHINE and MACHINE_ARCH value, an optional ALIAS 608# which may be used to refer to the MACHINE/MACHINE_ARCH pair, and an 609# optional DEFAULT or NO_DEFAULT keyword. 610# 611# When a MACHINE corresponds to multiple possible values of 612# MACHINE_ARCH, then this table should list all allowed combinations. 613# If the MACHINE is associated with a default MACHINE_ARCH (to be 614# used when the user specifies the MACHINE but fails to specify the 615# MACHINE_ARCH), then one of the lines should have the "DEFAULT" 616# keyword. If there is no default MACHINE_ARCH for a particular 617# MACHINE, then there should be a line with the "NO_DEFAULT" keyword, 618# and with a blank MACHINE_ARCH. 619# 620valid_MACHINE_ARCH=' 621MACHINE=acorn32 MACHINE_ARCH=earmv4 ALIAS=eacorn32 DEFAULT 622MACHINE=algor MACHINE_ARCH=mips64el ALIAS=algor64 623MACHINE=algor MACHINE_ARCH=mipsel DEFAULT 624MACHINE=alpha MACHINE_ARCH=alpha 625MACHINE=amd64 MACHINE_ARCH=x86_64 626MACHINE=amiga MACHINE_ARCH=m68k 627MACHINE=amigappc MACHINE_ARCH=powerpc 628MACHINE=arc MACHINE_ARCH=mips64el ALIAS=arc64 629MACHINE=arc MACHINE_ARCH=mipsel DEFAULT 630MACHINE=atari MACHINE_ARCH=m68k 631MACHINE=bebox MACHINE_ARCH=powerpc 632MACHINE=cats MACHINE_ARCH=earmv4 ALIAS=ecats DEFAULT 633MACHINE=cesfic MACHINE_ARCH=m68k 634MACHINE=cobalt MACHINE_ARCH=mips64el ALIAS=cobalt64 635MACHINE=cobalt MACHINE_ARCH=mipsel DEFAULT 636MACHINE=dreamcast MACHINE_ARCH=sh3el 637MACHINE=emips MACHINE_ARCH=mipseb 638MACHINE=epoc32 MACHINE_ARCH=earmv4 ALIAS=eepoc32 DEFAULT 639MACHINE=evbarm MACHINE_ARCH= NO_DEFAULT 640MACHINE=evbarm MACHINE_ARCH=earmv4 ALIAS=evbearmv4-el ALIAS=evbarmv4-el 641MACHINE=evbarm MACHINE_ARCH=earmv4eb ALIAS=evbearmv4-eb ALIAS=evbarmv4-eb 642MACHINE=evbarm MACHINE_ARCH=earmv5 ALIAS=evbearmv5-el ALIAS=evbarmv5-el 643MACHINE=evbarm MACHINE_ARCH=earmv5hf ALIAS=evbearmv5hf-el ALIAS=evbarmv5hf-el 644MACHINE=evbarm MACHINE_ARCH=earmv5eb ALIAS=evbearmv5-eb ALIAS=evbarmv5-eb 645MACHINE=evbarm MACHINE_ARCH=earmv5hfeb ALIAS=evbearmv5hf-eb ALIAS=evbarmv5hf-eb 646MACHINE=evbarm MACHINE_ARCH=earmv6 ALIAS=evbearmv6-el ALIAS=evbarmv6-el 647MACHINE=evbarm MACHINE_ARCH=earmv6hf ALIAS=evbearmv6hf-el ALIAS=evbarmv6hf-el 648MACHINE=evbarm MACHINE_ARCH=earmv6eb ALIAS=evbearmv6-eb ALIAS=evbarmv6-eb 649MACHINE=evbarm MACHINE_ARCH=earmv6hfeb ALIAS=evbearmv6hf-eb ALIAS=evbarmv6hf-eb 650MACHINE=evbarm MACHINE_ARCH=earmv7 ALIAS=evbearmv7-el ALIAS=evbarmv7-el 651MACHINE=evbarm MACHINE_ARCH=earmv7eb ALIAS=evbearmv7-eb ALIAS=evbarmv7-eb 652MACHINE=evbarm MACHINE_ARCH=earmv7hf ALIAS=evbearmv7hf-el ALIAS=evbarmv7hf-el 653MACHINE=evbarm MACHINE_ARCH=earmv7hfeb ALIAS=evbearmv7hf-eb ALIAS=evbarmv7hf-eb 654MACHINE=evbarm MACHINE_ARCH=aarch64 ALIAS=evbarm64-el ALIAS=evbarm64 655MACHINE=evbarm MACHINE_ARCH=aarch64eb ALIAS=evbarm64-eb 656MACHINE=evbcf MACHINE_ARCH=coldfire 657MACHINE=evbmips MACHINE_ARCH= NO_DEFAULT 658MACHINE=evbmips MACHINE_ARCH=mips64eb ALIAS=evbmips64-eb 659MACHINE=evbmips MACHINE_ARCH=mips64el ALIAS=evbmips64-el 660MACHINE=evbmips MACHINE_ARCH=mipseb ALIAS=evbmips-eb 661MACHINE=evbmips MACHINE_ARCH=mipsel ALIAS=evbmips-el 662MACHINE=evbmips MACHINE_ARCH=mipsn64eb ALIAS=evbmipsn64-eb 663MACHINE=evbmips MACHINE_ARCH=mipsn64el ALIAS=evbmipsn64-el 664MACHINE=evbppc MACHINE_ARCH=powerpc DEFAULT 665MACHINE=evbppc MACHINE_ARCH=powerpc64 ALIAS=evbppc64 666MACHINE=evbsh3 MACHINE_ARCH= NO_DEFAULT 667MACHINE=evbsh3 MACHINE_ARCH=sh3eb ALIAS=evbsh3-eb 668MACHINE=evbsh3 MACHINE_ARCH=sh3el ALIAS=evbsh3-el 669MACHINE=ews4800mips MACHINE_ARCH=mipseb 670MACHINE=hp300 MACHINE_ARCH=m68k 671MACHINE=hppa MACHINE_ARCH=hppa 672MACHINE=hpcarm MACHINE_ARCH=earmv4 ALIAS=hpcearm DEFAULT 673MACHINE=hpcmips MACHINE_ARCH=mipsel 674MACHINE=hpcsh MACHINE_ARCH=sh3el 675MACHINE=i386 MACHINE_ARCH=i386 676MACHINE=ia64 MACHINE_ARCH=ia64 677MACHINE=ibmnws MACHINE_ARCH=powerpc 678MACHINE=iyonix MACHINE_ARCH=earm ALIAS=eiyonix DEFAULT 679MACHINE=landisk MACHINE_ARCH=sh3el 680MACHINE=luna68k MACHINE_ARCH=m68k 681MACHINE=mac68k MACHINE_ARCH=m68k 682MACHINE=macppc MACHINE_ARCH=powerpc DEFAULT 683MACHINE=macppc MACHINE_ARCH=powerpc64 ALIAS=macppc64 684MACHINE=mipsco MACHINE_ARCH=mipseb 685MACHINE=mmeye MACHINE_ARCH=sh3eb 686MACHINE=mvme68k MACHINE_ARCH=m68k 687MACHINE=mvmeppc MACHINE_ARCH=powerpc 688MACHINE=netwinder MACHINE_ARCH=earmv4 ALIAS=enetwinder DEFAULT 689MACHINE=news68k MACHINE_ARCH=m68k 690MACHINE=newsmips MACHINE_ARCH=mipseb 691MACHINE=next68k MACHINE_ARCH=m68k 692MACHINE=ofppc MACHINE_ARCH=powerpc DEFAULT 693MACHINE=ofppc MACHINE_ARCH=powerpc64 ALIAS=ofppc64 694MACHINE=or1k MACHINE_ARCH=or1k 695MACHINE=playstation2 MACHINE_ARCH=mipsel 696MACHINE=pmax MACHINE_ARCH=mips64el ALIAS=pmax64 697MACHINE=pmax MACHINE_ARCH=mipsel DEFAULT 698MACHINE=prep MACHINE_ARCH=powerpc 699MACHINE=riscv MACHINE_ARCH=riscv64 ALIAS=riscv64 DEFAULT 700MACHINE=riscv MACHINE_ARCH=riscv32 ALIAS=riscv32 701MACHINE=rs6000 MACHINE_ARCH=powerpc 702MACHINE=sandpoint MACHINE_ARCH=powerpc 703MACHINE=sbmips MACHINE_ARCH= NO_DEFAULT 704MACHINE=sbmips MACHINE_ARCH=mips64eb ALIAS=sbmips64-eb 705MACHINE=sbmips MACHINE_ARCH=mips64el ALIAS=sbmips64-el 706MACHINE=sbmips MACHINE_ARCH=mipseb ALIAS=sbmips-eb 707MACHINE=sbmips MACHINE_ARCH=mipsel ALIAS=sbmips-el 708MACHINE=sgimips MACHINE_ARCH=mips64eb ALIAS=sgimips64 709MACHINE=sgimips MACHINE_ARCH=mipseb DEFAULT 710MACHINE=shark MACHINE_ARCH=earmv4 ALIAS=eshark DEFAULT 711MACHINE=sparc MACHINE_ARCH=sparc 712MACHINE=sparc64 MACHINE_ARCH=sparc64 713MACHINE=sun2 MACHINE_ARCH=m68000 714MACHINE=sun3 MACHINE_ARCH=m68k 715MACHINE=vax MACHINE_ARCH=vax 716MACHINE=x68k MACHINE_ARCH=m68k 717MACHINE=zaurus MACHINE_ARCH=earm ALIAS=ezaurus DEFAULT 718' 719 720# getarch -- find the default MACHINE_ARCH for a MACHINE, 721# or convert an alias to a MACHINE/MACHINE_ARCH pair. 722# 723# Saves the original value of MACHINE in makewrappermachine before 724# alias processing. 725# 726# Sets MACHINE and MACHINE_ARCH if the input MACHINE value is 727# recognised as an alias, or recognised as a machine that has a default 728# MACHINE_ARCH (or that has only one possible MACHINE_ARCH). 729# 730# Leaves MACHINE and MACHINE_ARCH unchanged if MACHINE is recognised 731# as being associated with multiple MACHINE_ARCH values with no default. 732# 733# Bombs if MACHINE is not recognised. 734# 735getarch() 736{ 737 local IFS 738 local found="" 739 local line 740 741 IFS="${nl}" 742 makewrappermachine="${MACHINE}" 743 for line in ${valid_MACHINE_ARCH}; do 744 line="${line%%#*}" # ignore comments 745 line="$( IFS=" ${tab}" ; echo $line )" # normalise white space 746 case "${line} " in 747 " ") 748 # skip blank lines or comment lines 749 continue 750 ;; 751 *" ALIAS=${MACHINE} "*) 752 # Found a line with a matching ALIAS=<alias>. 753 found="$line" 754 break 755 ;; 756 "MACHINE=${MACHINE} "*" NO_DEFAULT"*) 757 # Found an explicit "NO_DEFAULT" for this MACHINE. 758 found="$line" 759 break 760 ;; 761 "MACHINE=${MACHINE} "*" DEFAULT"*) 762 # Found an explicit "DEFAULT" for this MACHINE. 763 found="$line" 764 break 765 ;; 766 "MACHINE=${MACHINE} "*) 767 # Found a line for this MACHINE. If it's the 768 # first such line, then tentatively accept it. 769 # If it's not the first matching line, then 770 # remember that there was more than one match. 771 case "$found" in 772 '') found="$line" ;; 773 *) found="MULTIPLE_MATCHES" ;; 774 esac 775 ;; 776 esac 777 done 778 779 case "$found" in 780 *NO_DEFAULT*|*MULTIPLE_MATCHES*) 781 # MACHINE is OK, but MACHINE_ARCH is still unknown 782 return 783 ;; 784 "MACHINE="*" MACHINE_ARCH="*) 785 # Obey the MACHINE= and MACHINE_ARCH= parts of the line. 786 IFS=" " 787 for frag in ${found}; do 788 case "$frag" in 789 MACHINE=*|MACHINE_ARCH=*) 790 eval "$frag" 791 ;; 792 esac 793 done 794 ;; 795 *) 796 bomb "Unknown target MACHINE: ${MACHINE}" 797 ;; 798 esac 799} 800 801# validatearch -- check that the MACHINE/MACHINE_ARCH pair is supported. 802# 803# Bombs if the pair is not supported. 804# 805validatearch() 806{ 807 local IFS 808 local line 809 local foundpair=false foundmachine=false foundarch=false 810 811 case "${MACHINE_ARCH}" in 812 "") 813 bomb "No MACHINE_ARCH provided. Use 'build.sh -m ${MACHINE} list-arch' to show options." 814 ;; 815 esac 816 817 IFS="${nl}" 818 for line in ${valid_MACHINE_ARCH}; do 819 line="${line%%#*}" # ignore comments 820 line="$( IFS=" ${tab}" ; echo $line )" # normalise white space 821 case "${line} " in 822 " ") 823 # skip blank lines or comment lines 824 continue 825 ;; 826 "MACHINE=${MACHINE} MACHINE_ARCH=${MACHINE_ARCH} "*) 827 foundpair=true 828 ;; 829 "MACHINE=${MACHINE} "*) 830 foundmachine=true 831 ;; 832 *"MACHINE_ARCH=${MACHINE_ARCH} "*) 833 foundarch=true 834 ;; 835 esac 836 done 837 838 case "${foundpair}:${foundmachine}:${foundarch}" in 839 true:*) 840 : OK 841 ;; 842 *:false:*) 843 bomb "Unknown target MACHINE: ${MACHINE}" 844 ;; 845 *:*:false) 846 bomb "Unknown target MACHINE_ARCH: ${MACHINE_ARCH}" 847 ;; 848 *) 849 bomb "MACHINE_ARCH '${MACHINE_ARCH}' does not support MACHINE '${MACHINE}'" 850 ;; 851 esac 852} 853 854# listarch -- list valid MACHINE/MACHINE_ARCH/ALIAS values, 855# optionally restricted to those where the MACHINE and/or MACHINE_ARCH 856# match specified glob patterns. 857# 858listarch() 859{ 860 local machglob="$1" archglob="$2" 861 local IFS 862 local wildcard="*" 863 local line xline frag 864 local line_matches_machine line_matches_arch 865 local found=false 866 867 # Empty machglob or archglob should match anything 868 : "${machglob:=${wildcard}}" 869 : "${archglob:=${wildcard}}" 870 871 IFS="${nl}" 872 for line in ${valid_MACHINE_ARCH}; do 873 line="${line%%#*}" # ignore comments 874 xline="$( IFS=" ${tab}" ; echo $line )" # normalise white space 875 [ -z "${xline}" ] && continue # skip blank or comment lines 876 877 line_matches_machine=false 878 line_matches_arch=false 879 880 IFS=" " 881 for frag in ${xline}; do 882 case "${frag}" in 883 MACHINE=${machglob}) 884 line_matches_machine=true ;; 885 ALIAS=${machglob}) 886 line_matches_machine=true ;; 887 MACHINE_ARCH=${archglob}) 888 line_matches_arch=true ;; 889 esac 890 done 891 892 if $line_matches_machine && $line_matches_arch; then 893 found=true 894 echo "$line" 895 fi 896 done 897 if ! $found; then 898 echo >&2 "No match for" \ 899 "MACHINE=${machglob} MACHINE_ARCH=${archglob}" 900 return 1 901 fi 902 return 0 903} 904 905# nobomb_getmakevar -- 906# Given the name of a make variable in $1, print make's idea of the 907# value of that variable, or return 1 if there's an error. 908# 909nobomb_getmakevar() 910{ 911 [ -x "${make}" ] || return 1 912 "${make}" -m ${TOP}/share/mk -s -B -f- _x_ <<EOF || return 1 913_x_: 914 echo \${$1} 915.include <bsd.prog.mk> 916.include <bsd.kernobj.mk> 917EOF 918} 919 920# bomb_getmakevar -- 921# Given the name of a make variable in $1, print make's idea of the 922# value of that variable, or bomb if there's an error. 923# 924bomb_getmakevar() 925{ 926 [ -x "${make}" ] || bomb "bomb_getmakevar $1: ${make} is not executable" 927 nobomb_getmakevar "$1" || bomb "bomb_getmakevar $1: ${make} failed" 928} 929 930# getmakevar -- 931# Given the name of a make variable in $1, print make's idea of the 932# value of that variable, or print a literal '$' followed by the 933# variable name if ${make} is not executable. This is intended for use in 934# messages that need to be readable even if $make hasn't been built, 935# such as when build.sh is run with the "-n" option. 936# 937getmakevar() 938{ 939 if [ -x "${make}" ]; then 940 bomb_getmakevar "$1" 941 else 942 echo "\$$1" 943 fi 944} 945 946setmakeenv() 947{ 948 eval "$1='$2'; export $1" 949 makeenv="${makeenv} $1" 950} 951safe_setmakeenv() 952{ 953 case "$1" in 954 955 # Look for any vars we want to prohibit here, like: 956 # Bad | Dangerous) usage "Cannot override $1 with -V";; 957 958 # That first char is OK has already been verified. 959 *[!A-Za-z0-9_]*) usage "Bad variable name (-V): '$1'";; 960 esac 961 setmakeenv "$@" 962} 963 964unsetmakeenv() 965{ 966 eval "unset $1" 967 makeenv="${makeenv} $1" 968} 969safe_unsetmakeenv() 970{ 971 case "$1" in 972 973 # Look for any vars user should not be able to unset 974 # Needed | Must_Have) usage "Variable $1 cannot be unset";; 975 976 [!A-Za-z_]* | *[!A-Za-z0-9_]*) usage "Bad variable name (-Z): '$1'";; 977 esac 978 unsetmakeenv "$1" 979} 980 981# Given a variable name in $1, modify the variable in place as follows: 982# For each space-separated word in the variable, call resolvepath. 983resolvepaths() 984{ 985 local var="$1" 986 local val 987 eval val=\"\${${var}}\" 988 local newval='' 989 local word 990 for word in ${val}; do 991 resolvepath word 992 newval="${newval}${newval:+ }${word}" 993 done 994 eval ${var}=\"\${newval}\" 995} 996 997# Given a variable name in $1, modify the variable in place as follows: 998# Convert possibly-relative path to absolute path by prepending 999# ${TOP} if necessary. Also delete trailing "/", if any. 1000resolvepath() 1001{ 1002 local var="$1" 1003 local val 1004 eval val=\"\${${var}}\" 1005 case "${val}" in 1006 /) 1007 ;; 1008 /*) 1009 val="${val%/}" 1010 ;; 1011 *) 1012 val="${TOP}/${val%/}" 1013 ;; 1014 esac 1015 eval ${var}=\"\${val}\" 1016} 1017 1018usage() 1019{ 1020 if [ -n "$*" ]; then 1021 echo "" 1022 echo "${progname}: $*" 1023 fi 1024 cat <<_usage_ 1025 1026Usage: ${progname} [-EhnoPRrUuxy] [-a arch] [-B buildid] [-C cdextras] 1027 [-c compiler] [-D dest] [-j njob] [-M obj] [-m mach] 1028 [-N noisy] [-O obj] [-R release] [-S seed] [-T tools] 1029 [-V var=[value]] [-w wrapper] [-X x11src] [-Y extsrcsrc] 1030 [-Z var] 1031 operation [...] 1032 1033 Build operations (all imply "obj" and "tools"): 1034 build Run "make build". 1035 distribution Run "make distribution" (includes DESTDIR/etc/ files). 1036 release Run "make release" (includes kernels & distrib media). 1037 1038 Other operations: 1039 help Show this message and exit. 1040 makewrapper Create ${toolprefix}make-\${MACHINE} wrapper and ${toolprefix}make. 1041 Always performed. 1042 cleandir Run "make cleandir". [Default unless -u is used] 1043 dtb Build devicetree blobs. 1044 obj Run "make obj". [Default unless -o is used] 1045 tools Build and install tools. 1046 install=idir Run "make installworld" to \`idir' to install all sets 1047 except \`etc'. Useful after "distribution" or "release" 1048 kernel=conf Build kernel with config file \`conf' 1049 kernel.gdb=conf Build kernel (including netbsd.gdb) with config 1050 file \`conf' 1051 releasekernel=conf Install kernel built by kernel=conf to RELEASEDIR. 1052 kernels Build all kernels 1053 installmodules=idir Run "make installmodules" to \`idir' to install all 1054 kernel modules. 1055 modules Build kernel modules. 1056 rumptest Do a linktest for rump (for developers). 1057 sets Create binary sets in 1058 RELEASEDIR/RELEASEMACHINEDIR/binary/sets. 1059 DESTDIR should be populated beforehand. 1060 distsets Same as "distribution sets". 1061 sourcesets Create source sets in RELEASEDIR/source/sets. 1062 syspkgs Create syspkgs in 1063 RELEASEDIR/RELEASEMACHINEDIR/binary/syspkgs. 1064 iso-image Create CD-ROM image in RELEASEDIR/images. 1065 iso-image-source Create CD-ROM image with source in RELEASEDIR/images. 1066 live-image Create bootable live image in 1067 RELEASEDIR/RELEASEMACHINEDIR/installation/liveimage. 1068 install-image Create bootable installation image in 1069 RELEASEDIR/RELEASEMACHINEDIR/installation/installimage. 1070 disk-image=target Create bootable disk image in 1071 RELEASEDIR/RELEASEMACHINEDIR/binary/gzimg/target.img.gz. 1072 params Display various make(1) parameters. 1073 list-arch Display a list of valid MACHINE/MACHINE_ARCH values, 1074 and exit. The list may be narrowed by passing glob 1075 patterns or exact values in MACHINE or MACHINE_ARCH. 1076 mkrepro-timestamp Show the latest source timestamp used for reproducable 1077 builds and exit. Requires -P or -V MKREPRO=yes. 1078 1079 Options: 1080 -a arch Set MACHINE_ARCH to arch. [Default: deduced from MACHINE] 1081 -B buildid Set BUILDID to buildid. 1082 -C cdextras Append cdextras to CDEXTRA variable for inclusion on CD-ROM. 1083 -c compiler Select compiler: 1084 clang 1085 gcc 1086 [Default: gcc] 1087 -D dest Set DESTDIR to dest. [Default: destdir.MACHINE] 1088 -E Set "expert" mode; disables various safety checks. 1089 Should not be used without expert knowledge of the build 1090 system. 1091 -h Print this help message. 1092 -j njob Run up to njob jobs in parallel; see make(1) -j. 1093 -M obj Set obj root directory to obj; sets MAKEOBJDIRPREFIX. 1094 Unsets MAKEOBJDIR. 1095 -m mach Set MACHINE to mach. Some mach values are actually 1096 aliases that set MACHINE/MACHINE_ARCH pairs. 1097 [Default: deduced from the host system if the host 1098 OS is NetBSD] 1099 -N noisy Set the noisyness (MAKEVERBOSE) level of the build: 1100 0 Minimal output ("quiet") 1101 1 Describe what is occurring 1102 2 Describe what is occurring and echo the actual 1103 command 1104 3 Ignore the effect of the "@" prefix in make commands 1105 4 Trace shell commands using the shell's -x flag 1106 [Default: 2] 1107 -n Show commands that would be executed, but do not execute them. 1108 -O obj Set obj root directory to obj; sets a MAKEOBJDIR pattern. 1109 Unsets MAKEOBJDIRPREFIX. 1110 -o Set MKOBJDIRS=no; do not create objdirs at start of build. 1111 -P Set MKREPRO and MKREPRO_TIMESTAMP to the latest source 1112 CVS timestamp for reproducible builds. 1113 -R release Set RELEASEDIR to release. [Default: releasedir] 1114 -r Remove contents of TOOLDIR and DESTDIR before building. 1115 -S seed Set BUILDSEED to seed. [Default: NetBSD-majorversion] 1116 -T tools Set TOOLDIR to tools. If unset, and TOOLDIR is not set in 1117 the environment, ${toolprefix}make will be (re)built 1118 unconditionally. 1119 -U Set MKUNPRIVED=yes; build without requiring root privileges, 1120 install from an UNPRIVED build with proper file permissions. 1121 -u Set MKUPDATE=yes; do not run "make cleandir" first. 1122 Without this, everything is rebuilt, including the tools. 1123 -V var=[value] Set variable \`var' to \`value'. 1124 -w wrapper Create ${toolprefix}make script as wrapper. 1125 [Default: \${TOOLDIR}/bin/${toolprefix}make-\${MACHINE}] 1126 -X x11src Set X11SRCDIR to x11src. [Default: /usr/xsrc] 1127 -x Set MKX11=yes; build X11 from X11SRCDIR 1128 -Y extsrcsrc Set EXTSRCSRCDIR to extsrcsrc. [Default: /usr/extsrc] 1129 -y Set MKEXTSRC=yes; build extsrc from EXTSRCSRCDIR 1130 -Z var Unset ("zap") variable \`var'. 1131 1132_usage_ 1133 exit 1 1134} 1135 1136parseoptions() 1137{ 1138 opts='a:B:C:c:D:Ehj:M:m:N:nO:oPR:rS:T:UuV:w:X:xY:yZ:' 1139 opt_a=false 1140 opt_m=false 1141 1142 if type getopts >/dev/null 2>&1; then 1143 # Use POSIX getopts. 1144 # 1145 getoptcmd='getopts ${opts} opt && opt=-${opt}' 1146 optargcmd=':' 1147 optremcmd='shift $((${OPTIND} -1))' 1148 else 1149 type getopt >/dev/null 2>&1 || 1150 bomb "Shell does not support getopts or getopt" 1151 1152 # Use old-style getopt(1) (doesn't handle whitespace in args). 1153 # 1154 args="$(getopt ${opts} $*)" 1155 [ $? = 0 ] || usage 1156 set -- ${args} 1157 1158 getoptcmd='[ $# -gt 0 ] && opt="$1" && shift' 1159 optargcmd='OPTARG="$1"; shift' 1160 optremcmd=':' 1161 fi 1162 1163 # Parse command line options. 1164 # 1165 while eval ${getoptcmd}; do 1166 case ${opt} in 1167 1168 -a) 1169 eval ${optargcmd} 1170 MACHINE_ARCH=${OPTARG} 1171 opt_a=true 1172 ;; 1173 1174 -B) 1175 eval ${optargcmd} 1176 BUILDID=${OPTARG} 1177 ;; 1178 1179 -C) 1180 eval ${optargcmd}; resolvepaths OPTARG 1181 CDEXTRA="${CDEXTRA}${CDEXTRA:+ }${OPTARG}" 1182 ;; 1183 1184 -c) 1185 eval ${optargcmd} 1186 case "${OPTARG}" in 1187 gcc) # default, no variables needed 1188 ;; 1189 clang) setmakeenv HAVE_LLVM yes 1190 setmakeenv MKLLVM yes 1191 setmakeenv MKGCC no 1192 ;; 1193 #pcc) ... 1194 # ;; 1195 *) bomb "Unknown compiler: ${OPTARG}" 1196 esac 1197 ;; 1198 1199 -D) 1200 eval ${optargcmd}; resolvepath OPTARG 1201 setmakeenv DESTDIR "${OPTARG}" 1202 ;; 1203 1204 -E) 1205 do_expertmode=true 1206 ;; 1207 1208 -j) 1209 eval ${optargcmd} 1210 parallel="-j ${OPTARG}" 1211 ;; 1212 1213 -M) 1214 eval ${optargcmd}; resolvepath OPTARG 1215 case "${OPTARG}" in 1216 \$*) usage "-M argument must not begin with '\$'" 1217 ;; 1218 *\$*) # can use resolvepath, but can't set TOP_objdir 1219 resolvepath OPTARG 1220 ;; 1221 *) resolvepath OPTARG 1222 TOP_objdir="${OPTARG}${TOP}" 1223 ;; 1224 esac 1225 unsetmakeenv MAKEOBJDIR 1226 setmakeenv MAKEOBJDIRPREFIX "${OPTARG}" 1227 ;; 1228 1229 # -m overrides MACHINE_ARCH unless "-a" is specified 1230 -m) 1231 eval ${optargcmd} 1232 MACHINE="${OPTARG}" 1233 opt_m=true 1234 ;; 1235 1236 -N) 1237 eval ${optargcmd} 1238 case "${OPTARG}" in 1239 0|1|2|3|4) 1240 setmakeenv MAKEVERBOSE "${OPTARG}" 1241 ;; 1242 *) 1243 usage "'${OPTARG}' is not a valid value for -N" 1244 ;; 1245 esac 1246 ;; 1247 1248 -n) 1249 runcmd=echo 1250 ;; 1251 1252 -O) 1253 eval ${optargcmd} 1254 case "${OPTARG}" in 1255 *\$*) usage "-O argument must not contain '\$'" 1256 ;; 1257 *) resolvepath OPTARG 1258 TOP_objdir="${OPTARG}" 1259 ;; 1260 esac 1261 unsetmakeenv MAKEOBJDIRPREFIX 1262 setmakeenv MAKEOBJDIR "\${.CURDIR:C,^$TOP,$OPTARG,}" 1263 ;; 1264 1265 -o) 1266 MKOBJDIRS=no 1267 ;; 1268 1269 -P) 1270 MKREPRO=yes 1271 ;; 1272 1273 -R) 1274 eval ${optargcmd}; resolvepath OPTARG 1275 setmakeenv RELEASEDIR "${OPTARG}" 1276 ;; 1277 1278 -r) 1279 do_removedirs=true 1280 do_rebuildmake=true 1281 ;; 1282 1283 -S) 1284 eval ${optargcmd} 1285 setmakeenv BUILDSEED "${OPTARG}" 1286 ;; 1287 1288 -T) 1289 eval ${optargcmd}; resolvepath OPTARG 1290 TOOLDIR="${OPTARG}" 1291 export TOOLDIR 1292 ;; 1293 1294 -U) 1295 setmakeenv MKUNPRIVED yes 1296 ;; 1297 1298 -u) 1299 setmakeenv MKUPDATE yes 1300 ;; 1301 1302 -V) 1303 eval ${optargcmd} 1304 case "${OPTARG}" in 1305 # XXX: consider restricting which variables can be changed? 1306 [a-zA-Z_]*=*) 1307 safe_setmakeenv "${OPTARG%%=*}" "${OPTARG#*=}" 1308 ;; 1309 [a-zA-Z_]*) 1310 safe_setmakeenv "${OPTARG}" "" 1311 ;; 1312 *) 1313 usage "-V argument must be of the form 'var[=value]'" 1314 ;; 1315 esac 1316 ;; 1317 1318 -w) 1319 eval ${optargcmd}; resolvepath OPTARG 1320 makewrapper="${OPTARG}" 1321 ;; 1322 1323 -X) 1324 eval ${optargcmd}; resolvepath OPTARG 1325 setmakeenv X11SRCDIR "${OPTARG}" 1326 ;; 1327 1328 -x) 1329 setmakeenv MKX11 yes 1330 ;; 1331 1332 -Y) 1333 eval ${optargcmd}; resolvepath OPTARG 1334 setmakeenv EXTSRCSRCDIR "${OPTARG}" 1335 ;; 1336 1337 -y) 1338 setmakeenv MKEXTSRC yes 1339 ;; 1340 1341 -Z) 1342 eval ${optargcmd} 1343 # XXX: consider restricting which variables can be unset? 1344 safe_unsetmakeenv "${OPTARG}" 1345 ;; 1346 1347 --) 1348 break 1349 ;; 1350 1351 -'?'|-h) 1352 usage 1353 ;; 1354 1355 esac 1356 done 1357 1358 # Validate operations. 1359 # 1360 eval ${optremcmd} 1361 while [ $# -gt 0 ]; do 1362 op=$1; shift 1363 operations="${operations} ${op}" 1364 1365 case "${op}" in 1366 1367 help) 1368 usage 1369 ;; 1370 1371 list-arch) 1372 listarch "${MACHINE}" "${MACHINE_ARCH}" 1373 exit 1374 ;; 1375 mkrepro-timestamp) 1376 setup_mkrepro quiet 1377 echo ${MKREPRO_TIMESTAMP:-0} 1378 [ ${MKREPRO_TIMESTAMP:-0} -ne 0 ]; exit 1379 ;; 1380 1381 kernel=*|releasekernel=*|kernel.gdb=*) 1382 arg=${op#*=} 1383 op=${op%%=*} 1384 [ -n "${arg}" ] || 1385 bomb "Must supply a kernel name with \`${op}=...'" 1386 ;; 1387 1388 disk-image=*) 1389 arg=${op#*=} 1390 op=disk_image 1391 [ -n "${arg}" ] || 1392 bomb "Must supply a target name with \`${op}=...'" 1393 1394 ;; 1395 1396 install=*|installmodules=*) 1397 arg=${op#*=} 1398 op=${op%%=*} 1399 [ -n "${arg}" ] || 1400 bomb "Must supply a directory with \`install=...'" 1401 ;; 1402 1403 distsets) 1404 operations="$(echo "$operations" | sed 's/distsets/distribution sets/')" 1405 do_sets=true 1406 op=distribution 1407 ;; 1408 1409 build|\ 1410 cleandir|\ 1411 distribution|\ 1412 dtb|\ 1413 install-image|\ 1414 iso-image-source|\ 1415 iso-image|\ 1416 kernels|\ 1417 libs|\ 1418 live-image|\ 1419 makewrapper|\ 1420 modules|\ 1421 obj|\ 1422 params|\ 1423 release|\ 1424 rump|\ 1425 rumptest|\ 1426 sets|\ 1427 sourcesets|\ 1428 syspkgs|\ 1429 tools) 1430 ;; 1431 1432 *) 1433 usage "Unknown operation \`${op}'" 1434 ;; 1435 1436 esac 1437 # ${op} may contain chars that are not allowed in variable 1438 # names. Replace them with '_' before setting do_${op}. 1439 op="$( echo "$op" | tr -s '.-' '__')" 1440 eval do_${op}=true 1441 done 1442 [ -n "${operations}" ] || usage "Missing operation to perform." 1443 1444 # Set up MACHINE*. On a NetBSD host, these are allowed to be unset. 1445 # 1446 if [ -z "${MACHINE}" ]; then 1447 [ "${uname_s}" = "NetBSD" ] || 1448 bomb "MACHINE must be set, or -m must be used, for cross builds." 1449 MACHINE=${uname_m} 1450 MACHINE_ARCH=${uname_p} 1451 fi 1452 if $opt_m && ! $opt_a; then 1453 # Settings implied by the command line -m option 1454 # override MACHINE_ARCH from the environment (if any). 1455 getarch 1456 fi 1457 [ -n "${MACHINE_ARCH}" ] || getarch 1458 validatearch 1459 1460 # Set up default make(1) environment. 1461 # 1462 makeenv="${makeenv} TOOLDIR MACHINE MACHINE_ARCH MAKEFLAGS" 1463 [ -z "${BUILDID}" ] || makeenv="${makeenv} BUILDID" 1464 [ -z "${BUILDINFO}" ] || makeenv="${makeenv} BUILDINFO" 1465 MAKEFLAGS="-de -m ${TOP}/share/mk ${MAKEFLAGS}" 1466 MAKEFLAGS="${MAKEFLAGS} MKOBJDIRS=${MKOBJDIRS-yes}" 1467 export MAKEFLAGS MACHINE MACHINE_ARCH 1468 setmakeenv USETOOLS "yes" 1469 setmakeenv MAKEWRAPPERMACHINE "${makewrappermachine:-${MACHINE}}" 1470 setmakeenv MAKE_OBJDIR_CHECK_WRITABLE no 1471} 1472 1473# sanitycheck -- 1474# Sanity check after parsing command line options, before rebuildmake. 1475# 1476sanitycheck() 1477{ 1478 # Install as non-root is a bad idea. 1479 # 1480 if ${do_install} && [ "$id_u" -ne 0 ] ; then 1481 if ${do_expertmode}; then 1482 warning "Will install as an unprivileged user." 1483 else 1484 bomb "-E must be set for install as an unprivileged user." 1485 fi 1486 fi 1487 1488 # If the PATH contains any non-absolute components (including, 1489 # but not limited to, "." or ""), then complain. As an exception, 1490 # allow "" or "." as the last component of the PATH. This is fatal 1491 # if expert mode is not in effect. 1492 # 1493 local path="${PATH}" 1494 path="${path%:}" # delete trailing ":" 1495 path="${path%:.}" # delete trailing ":." 1496 case ":${path}:/" in 1497 *:[!/~]*) 1498 if ${do_expertmode}; then 1499 warning "PATH contains non-absolute components" 1500 else 1501 bomb "PATH environment variable must not" \ 1502 "contain non-absolute components" 1503 fi 1504 ;; 1505 esac 1506 1507 while [ ${MKX11-no} = "yes" ]; do # not really a loop 1508 test -n "${X11SRCDIR}" && { 1509 test -d "${X11SRCDIR}" || 1510 bomb "X11SRCDIR (${X11SRCDIR}) does not exist (with -x)" 1511 break 1512 } 1513 for _xd in \ 1514 "${NETBSDSRCDIR%/*}/xsrc" \ 1515 "${NETBSDSRCDIR}/xsrc" \ 1516 /usr/xsrc 1517 do 1518 test -d "${_xd}" && 1519 setmakeenv X11SRCDIR "${_xd}" && 1520 break 2 1521 done 1522 bomb "Asked to build X11 but no xsrc" 1523 done 1524} 1525 1526# print_tooldir_make -- 1527# Try to find and print a path to an existing 1528# ${TOOLDIR}/bin/${toolprefix}program 1529print_tooldir_program() 1530{ 1531 local possible_TOP_OBJ 1532 local possible_TOOLDIR 1533 local possible_program 1534 local tooldir_program 1535 local program=${1} 1536 1537 if [ -n "${TOOLDIR}" ]; then 1538 echo "${TOOLDIR}/bin/${toolprefix}${program}" 1539 return 1540 fi 1541 1542 # Set host_ostype to something like "NetBSD-4.5.6-i386". This 1543 # is intended to match the HOST_OSTYPE variable in <bsd.own.mk>. 1544 # 1545 local host_ostype="${uname_s}-$( 1546 echo "${uname_r}" | sed -e 's/([^)]*)//g' -e 's/ /_/g' 1547 )-$( 1548 echo "${uname_p}" | sed -e 's/([^)]*)//g' -e 's/ /_/g' 1549 )" 1550 1551 # Look in a few potential locations for 1552 # ${possible_TOOLDIR}/bin/${toolprefix}${program}. 1553 # If we find it, then set possible_program. 1554 # 1555 # In the usual case (without interference from environment 1556 # variables or /etc/mk.conf), <bsd.own.mk> should set TOOLDIR to 1557 # "${_SRC_TOP_OBJ_}/tooldir.${host_ostype}". 1558 # 1559 # In practice it's difficult to figure out the correct value 1560 # for _SRC_TOP_OBJ_. In the easiest case, when the -M or -O 1561 # options were passed to build.sh, then ${TOP_objdir} will be 1562 # the correct value. We also try a few other possibilities, but 1563 # we do not replicate all the logic of <bsd.obj.mk>. 1564 # 1565 for possible_TOP_OBJ in \ 1566 "${TOP_objdir}" \ 1567 "${MAKEOBJDIRPREFIX:+${MAKEOBJDIRPREFIX}${TOP}}" \ 1568 "${TOP}" \ 1569 "${TOP}/obj" \ 1570 "${TOP}/obj.${MACHINE}" 1571 do 1572 [ -n "${possible_TOP_OBJ}" ] || continue 1573 possible_TOOLDIR="${possible_TOP_OBJ}/tooldir.${host_ostype}" 1574 possible_program="${possible_TOOLDIR}/bin/${toolprefix}${program}" 1575 if [ -x "${possible_make}" ]; then 1576 echo ${possible_program} 1577 return; 1578 fi 1579 done 1580 echo "" 1581} 1582# print_tooldir_make -- 1583# Try to find and print a path to an existing 1584# ${TOOLDIR}/bin/${toolprefix}make, for use by rebuildmake() before a 1585# new version of ${toolprefix}make has been built. 1586# 1587# * If TOOLDIR was set in the environment or on the command line, use 1588# that value. 1589# * Otherwise try to guess what TOOLDIR would be if not overridden by 1590# /etc/mk.conf, and check whether the resulting directory contains 1591# a copy of ${toolprefix}make (this should work for everybody who 1592# doesn't override TOOLDIR via /etc/mk.conf); 1593# * Failing that, search for ${toolprefix}make, nbmake, bmake, or make, 1594# in the PATH (this might accidentally find a version of make that 1595# does not understand the syntax used by NetBSD make, and that will 1596# lead to failure in the next step); 1597# * If a copy of make was found above, try to use it with 1598# nobomb_getmakevar to find the correct value for TOOLDIR, and believe the 1599# result only if it's a directory that already exists; 1600# * If a value of TOOLDIR was found above, and if 1601# ${TOOLDIR}/bin/${toolprefix}make exists, print that value. 1602# 1603print_tooldir_make() 1604{ 1605 local possible_make 1606 local possible_TOOLDIR 1607 local tooldir_make 1608 1609 possible_make=$(print_tooldir_program make) 1610 # If the above didn't work, search the PATH for a suitable 1611 # ${toolprefix}make, nbmake, bmake, or make. 1612 # 1613 : ${possible_make:=$(find_in_PATH ${toolprefix}make '')} 1614 : ${possible_make:=$(find_in_PATH nbmake '')} 1615 : ${possible_make:=$(find_in_PATH bmake '')} 1616 : ${possible_make:=$(find_in_PATH make '')} 1617 1618 # At this point, we don't care whether possible_make is in the 1619 # correct TOOLDIR or not; we simply want it to be usable by 1620 # getmakevar to help us find the correct TOOLDIR. 1621 # 1622 # Use ${possible_make} with nobomb_getmakevar to try to find 1623 # the value of TOOLDIR. Believe the result only if it's 1624 # a directory that already exists and contains bin/${toolprefix}make. 1625 # 1626 if [ -x "${possible_make}" ]; then 1627 possible_TOOLDIR="$( 1628 make="${possible_make}" \ 1629 nobomb_getmakevar TOOLDIR 2>/dev/null 1630 )" 1631 if [ $? = 0 ] && [ -n "${possible_TOOLDIR}" ] \ 1632 && [ -d "${possible_TOOLDIR}" ]; 1633 then 1634 tooldir_make="${possible_TOOLDIR}/bin/${toolprefix}make" 1635 if [ -x "${tooldir_make}" ]; then 1636 echo "${tooldir_make}" 1637 return 0 1638 fi 1639 fi 1640 fi 1641 return 1 1642} 1643 1644# rebuildmake -- 1645# Rebuild nbmake in a temporary directory if necessary. Sets $make 1646# to a path to the nbmake executable. Sets done_rebuildmake=true 1647# if nbmake was rebuilt. 1648# 1649# There is a cyclic dependency between building nbmake and choosing 1650# TOOLDIR: TOOLDIR may be affected by settings in /etc/mk.conf, so we 1651# would like to use getmakevar to get the value of TOOLDIR; but we can't 1652# use getmakevar before we have an up to date version of nbmake; we 1653# might already have an up to date version of nbmake in TOOLDIR, but we 1654# don't yet know where TOOLDIR is. 1655# 1656# The default value of TOOLDIR also depends on the location of the top 1657# level object directory, so $(getmakevar TOOLDIR) invoked before or 1658# after making the top level object directory may produce different 1659# results. 1660# 1661# Strictly speaking, we should do the following: 1662# 1663# 1. build a new version of nbmake in a temporary directory; 1664# 2. use the temporary nbmake to create the top level obj directory; 1665# 3. use $(getmakevar TOOLDIR) with the temporary nbmake to 1666# get the correct value of TOOLDIR; 1667# 4. move the temporary nbmake to ${TOOLDIR}/bin/nbmake. 1668# 1669# However, people don't like building nbmake unnecessarily if their 1670# TOOLDIR has not changed since an earlier build. We try to avoid 1671# rebuilding a temporary version of nbmake by taking some shortcuts to 1672# guess a value for TOOLDIR, looking for an existing version of nbmake 1673# in that TOOLDIR, and checking whether that nbmake is newer than the 1674# sources used to build it. 1675# 1676rebuildmake() 1677{ 1678 make="$(print_tooldir_make)" 1679 if [ -n "${make}" ] && [ -x "${make}" ]; then 1680 for f in usr.bin/make/*.[ch]; do 1681 if [ "${f}" -nt "${make}" ]; then 1682 statusmsg "${make} outdated" \ 1683 "(older than ${f}), needs building." 1684 do_rebuildmake=true 1685 break 1686 fi 1687 done 1688 else 1689 statusmsg "No \$TOOLDIR/bin/${toolprefix}make, needs building." 1690 do_rebuildmake=true 1691 fi 1692 1693 # Build bootstrap ${toolprefix}make if needed. 1694 if ! ${do_rebuildmake}; then 1695 return 1696 fi 1697 1698 # Silent configure with MAKEVERBOSE==0 1699 if [ ${MAKEVERBOSE:-2} -eq 0 ]; then 1700 configure_args=--silent 1701 fi 1702 1703 statusmsg "Bootstrapping ${toolprefix}make" 1704 ${runcmd} cd "${tmpdir}" 1705 ${runcmd} env CC="${HOST_CC-cc}" CPPFLAGS="${HOST_CPPFLAGS}" \ 1706 CFLAGS="${HOST_CFLAGS--O}" LDFLAGS="${HOST_LDFLAGS}" \ 1707 ${HOST_SH} "${TOP}/tools/make/configure" ${configure_args} || 1708 ( cp ${tmpdir}/config.log ${tmpdir}-config.log 1709 bomb "Configure of ${toolprefix}make failed, see ${tmpdir}-config.log for details" ) 1710 ${runcmd} ${HOST_SH} buildmake.sh || 1711 bomb "Build of ${toolprefix}make failed" 1712 make="${tmpdir}/${toolprefix}make" 1713 ${runcmd} cd "${TOP}" 1714 ${runcmd} rm -f usr.bin/make/*.o 1715 done_rebuildmake=true 1716} 1717 1718# validatemakeparams -- 1719# Perform some late sanity checks, after rebuildmake, 1720# but before createmakewrapper or any real work. 1721# 1722# Creates the top-level obj directory, because that 1723# is needed by some of the sanity checks. 1724# 1725# Prints status messages reporting the values of several variables. 1726# 1727validatemakeparams() 1728{ 1729 # MAKECONF (which defaults to /etc/mk.conf in share/mk/bsd.own.mk) 1730 # can affect many things, so mention it in an early status message. 1731 # 1732 MAKECONF=$(getmakevar MAKECONF) 1733 if [ -e "${MAKECONF}" ]; then 1734 statusmsg2 "MAKECONF file:" "${MAKECONF}" 1735 else 1736 statusmsg2 "MAKECONF file:" "${MAKECONF} (File not found)" 1737 fi 1738 1739 # Normalise MKOBJDIRS, MKUNPRIVED, and MKUPDATE. 1740 # These may be set as build.sh options or in "mk.conf". 1741 # Don't export them as they're only used for tests in build.sh. 1742 # 1743 MKOBJDIRS=$(getmakevar MKOBJDIRS) 1744 MKUNPRIVED=$(getmakevar MKUNPRIVED) 1745 MKUPDATE=$(getmakevar MKUPDATE) 1746 1747 # Non-root should always use either the -U or -E flag. 1748 # 1749 if ! ${do_expertmode} && \ 1750 [ "$id_u" -ne 0 ] && \ 1751 [ "${MKUNPRIVED}" = "no" ] ; then 1752 bomb "-U or -E must be set for build as an unprivileged user." 1753 fi 1754 1755 if [ "${runcmd}" = "echo" ]; then 1756 TOOLCHAIN_MISSING=no 1757 EXTERNAL_TOOLCHAIN="" 1758 else 1759 TOOLCHAIN_MISSING=$(bomb_getmakevar TOOLCHAIN_MISSING) 1760 EXTERNAL_TOOLCHAIN=$(bomb_getmakevar EXTERNAL_TOOLCHAIN) 1761 fi 1762 if [ "${TOOLCHAIN_MISSING}" = "yes" ] && \ 1763 [ -z "${EXTERNAL_TOOLCHAIN}" ]; then 1764 ${runcmd} echo "ERROR: build.sh (in-tree cross-toolchain) is not yet available for" 1765 ${runcmd} echo " MACHINE: ${MACHINE}" 1766 ${runcmd} echo " MACHINE_ARCH: ${MACHINE_ARCH}" 1767 ${runcmd} echo "" 1768 ${runcmd} echo "All builds for this platform should be done via a traditional make" 1769 ${runcmd} echo "If you wish to use an external cross-toolchain, set" 1770 ${runcmd} echo " EXTERNAL_TOOLCHAIN=<path to toolchain root>" 1771 ${runcmd} echo "in either the environment or mk.conf and rerun" 1772 ${runcmd} echo " ${progname} $*" 1773 exit 1 1774 fi 1775 1776 if [ "${MKOBJDIRS}" != "no" ]; then 1777 # Create the top-level object directory. 1778 # 1779 # "make obj NOSUBDIR=" can handle most cases, but it 1780 # can't handle the case where MAKEOBJDIRPREFIX is set 1781 # while the corresponding directory does not exist 1782 # (rules in <bsd.obj.mk> would abort the build). We 1783 # therefore have to handle the MAKEOBJDIRPREFIX case 1784 # without invoking "make obj". The MAKEOBJDIR case 1785 # could be handled either way, but we choose to handle 1786 # it similarly to MAKEOBJDIRPREFIX. 1787 # 1788 if [ -n "${TOP_obj}" ]; then 1789 # It must have been set by the "-M" or "-O" 1790 # command line options, so there's no need to 1791 # use getmakevar 1792 : 1793 elif [ -n "$MAKEOBJDIRPREFIX" ]; then 1794 TOP_obj="$(getmakevar MAKEOBJDIRPREFIX)${TOP}" 1795 elif [ -n "$MAKEOBJDIR" ]; then 1796 TOP_obj="$(getmakevar MAKEOBJDIR)" 1797 fi 1798 if [ -n "$TOP_obj" ]; then 1799 ${runcmd} mkdir -p "${TOP_obj}" || 1800 bomb "Can't create top level object directory" \ 1801 "${TOP_obj}" 1802 else 1803 ${runcmd} "${make}" -m ${TOP}/share/mk obj NOSUBDIR= || 1804 bomb "Can't create top level object directory" \ 1805 "using make obj" 1806 fi 1807 1808 # make obj in tools to ensure that the objdir for "tools" 1809 # is available. 1810 # 1811 ${runcmd} cd tools 1812 ${runcmd} "${make}" -m ${TOP}/share/mk obj NOSUBDIR= || 1813 bomb "Failed to make obj in tools" 1814 ${runcmd} cd "${TOP}" 1815 fi 1816 1817 # Find TOOLDIR, DESTDIR, and RELEASEDIR, according to getmakevar, 1818 # and bomb if they have changed from the values we had from the 1819 # command line or environment. 1820 # 1821 # This must be done after creating the top-level object directory. 1822 # 1823 for var in TOOLDIR DESTDIR RELEASEDIR 1824 do 1825 eval oldval=\"\$${var}\" 1826 newval="$(getmakevar $var)" 1827 if ! $do_expertmode; then 1828 : ${_SRC_TOP_OBJ_:=$(getmakevar _SRC_TOP_OBJ_)} 1829 case "$var" in 1830 DESTDIR) 1831 : ${newval:=${_SRC_TOP_OBJ_}/destdir.${MACHINE}} 1832 makeenv="${makeenv} DESTDIR" 1833 ;; 1834 RELEASEDIR) 1835 : ${newval:=${_SRC_TOP_OBJ_}/releasedir} 1836 makeenv="${makeenv} RELEASEDIR" 1837 ;; 1838 esac 1839 fi 1840 if [ -n "$oldval" ] && [ "$oldval" != "$newval" ]; then 1841 bomb "Value of ${var} has changed" \ 1842 "(was \"${oldval}\", now \"${newval}\")" 1843 fi 1844 eval ${var}=\"\${newval}\" 1845 eval export ${var} 1846 statusmsg2 "${var} path:" "${newval}" 1847 done 1848 1849 # RELEASEMACHINEDIR is just a subdir name, e.g. "i386". 1850 RELEASEMACHINEDIR=$(getmakevar RELEASEMACHINEDIR) 1851 1852 # Check validity of TOOLDIR and DESTDIR. 1853 # 1854 if [ -z "${TOOLDIR}" ] || [ "${TOOLDIR}" = "/" ]; then 1855 bomb "TOOLDIR '${TOOLDIR}' invalid" 1856 fi 1857 removedirs="${TOOLDIR}" 1858 1859 if [ -z "${DESTDIR}" ] || [ "${DESTDIR}" = "/" ]; then 1860 if ${do_distribution} || ${do_release} || \ 1861 [ "${uname_s}" != "NetBSD" ] || \ 1862 [ "${uname_m}" != "${MACHINE}" ]; then 1863 bomb "DESTDIR must != / for cross builds, or ${progname} 'distribution' or 'release'." 1864 fi 1865 if ! ${do_expertmode}; then 1866 bomb "DESTDIR must != / for non -E (expert) builds" 1867 fi 1868 statusmsg "WARNING: Building to /, in expert mode." 1869 statusmsg " This may cause your system to break! Reasons include:" 1870 statusmsg " - your kernel is not up to date" 1871 statusmsg " - the libraries or toolchain have changed" 1872 statusmsg " YOU HAVE BEEN WARNED!" 1873 else 1874 removedirs="${removedirs} ${DESTDIR}" 1875 fi 1876 if ${do_releasekernel} && [ -z "${RELEASEDIR}" ]; then 1877 bomb "Must set RELEASEDIR with \`releasekernel=...'" 1878 fi 1879 1880 # If a previous build.sh run used -U (and therefore created a 1881 # METALOG file), then most subsequent build.sh runs must also 1882 # use -U. If DESTDIR is about to be removed, then don't perform 1883 # this check. 1884 # 1885 case "${do_removedirs} ${removedirs} " in 1886 true*" ${DESTDIR} "*) 1887 # DESTDIR is about to be removed 1888 ;; 1889 *) 1890 if [ -e "${DESTDIR}/METALOG" ] && \ 1891 [ "${MKUNPRIVED}" = "no" ] ; then 1892 if $do_expertmode; then 1893 warning "A previous build.sh run specified -U." 1894 else 1895 bomb "A previous build.sh run specified -U; you must specify it again now." 1896 fi 1897 fi 1898 ;; 1899 esac 1900 1901 # live-image and install-image targets require binary sets 1902 # (actually DESTDIR/etc/mtree/set.* files) built with MKUNPRIVED. 1903 # If release operation is specified with live-image or install-image, 1904 # the release op should be performed with -U for later image ops. 1905 # 1906 if ${do_release} && ( ${do_live_image} || ${do_install_image} ) && \ 1907 [ "${MKUNPRIVED}" = "no" ] ; then 1908 bomb "-U must be specified on building release to create images later." 1909 fi 1910} 1911 1912 1913createmakewrapper() 1914{ 1915 # Remove the target directories. 1916 # 1917 if ${do_removedirs}; then 1918 for f in ${removedirs}; do 1919 statusmsg "Removing ${f}" 1920 ${runcmd} rm -r -f "${f}" 1921 done 1922 fi 1923 1924 # Recreate $TOOLDIR. 1925 # 1926 ${runcmd} mkdir -p "${TOOLDIR}/bin" || 1927 bomb "mkdir of '${TOOLDIR}/bin' failed" 1928 1929 # If we did not previously rebuild ${toolprefix}make, then 1930 # check whether $make is still valid and the same as the output 1931 # from print_tooldir_make. If not, then rebuild make now. A 1932 # possible reason for this being necessary is that the actual 1933 # value of TOOLDIR might be different from the value guessed 1934 # before the top level obj dir was created. 1935 # 1936 if ! ${done_rebuildmake} && \ 1937 ( [ ! -x "$make" ] || [ "$make" != "$(print_tooldir_make)" ] ) 1938 then 1939 rebuildmake 1940 fi 1941 1942 # Install ${toolprefix}make if it was built. 1943 # 1944 if ${done_rebuildmake}; then 1945 ${runcmd} rm -f "${TOOLDIR}/bin/${toolprefix}make" 1946 ${runcmd} cp "${make}" "${TOOLDIR}/bin/${toolprefix}make" || 1947 bomb "Failed to install \$TOOLDIR/bin/${toolprefix}make" 1948 make="${TOOLDIR}/bin/${toolprefix}make" 1949 statusmsg "Created ${make}" 1950 fi 1951 1952 # Build a ${toolprefix}make wrapper script, usable by hand as 1953 # well as by build.sh. 1954 # 1955 if [ -z "${makewrapper}" ]; then 1956 makewrapper="${TOOLDIR}/bin/${toolprefix}make-${makewrappermachine:-${MACHINE}}" 1957 [ -z "${BUILDID}" ] || makewrapper="${makewrapper}-${BUILDID}" 1958 fi 1959 1960 ${runcmd} rm -f "${makewrapper}" 1961 if [ "${runcmd}" = "echo" ]; then 1962 echo 'cat <<EOF >'${makewrapper} 1963 makewrapout= 1964 else 1965 makewrapout=">>\${makewrapper}" 1966 fi 1967 1968 case "${KSH_VERSION:-${SH_VERSION}}" in 1969 *PD\ KSH*|*MIRBSD\ KSH*) 1970 set +o braceexpand 1971 ;; 1972 esac 1973 1974 eval cat <<EOF ${makewrapout} 1975#! ${HOST_SH} 1976# Set proper variables to allow easy "make" building of a NetBSD subtree. 1977# Generated from: \$NetBSD: build.sh,v 1.361 2021/12/31 15:43:35 christos Exp $ 1978# with these arguments: ${_args} 1979# 1980 1981EOF 1982 { 1983 sorted_vars="$(for var in ${makeenv}; do echo "${var}" ; done \ 1984 | sort -u )" 1985 for var in ${sorted_vars}; do 1986 eval val=\"\${${var}}\" 1987 eval is_set=\"\${${var}+set}\" 1988 if [ -z "${is_set}" ]; then 1989 echo "unset ${var}" 1990 else 1991 qval="$(shell_quote "${val}")" 1992 echo "${var}=${qval}; export ${var}" 1993 fi 1994 done 1995 1996 cat <<EOF 1997 1998exec "\${TOOLDIR}/bin/${toolprefix}make" \${1+"\$@"} 1999EOF 2000 } | eval cat "${makewrapout}" 2001 [ "${runcmd}" = "echo" ] && echo EOF 2002 ${runcmd} chmod +x "${makewrapper}" 2003 statusmsg2 "Updated makewrapper:" "${makewrapper}" 2004} 2005 2006make_in_dir() 2007{ 2008 local dir="$1" 2009 local op="$2" 2010 ${runcmd} cd "${dir}" || 2011 bomb "Failed to cd to \"${dir}\"" 2012 ${runcmd} "${makewrapper}" ${parallel} ${op} || 2013 bomb "Failed to make ${op} in \"${dir}\"" 2014 ${runcmd} cd "${TOP}" || 2015 bomb "Failed to cd back to \"${TOP}\"" 2016} 2017 2018buildtools() 2019{ 2020 if [ "${MKOBJDIRS}" != "no" ]; then 2021 ${runcmd} "${makewrapper}" ${parallel} obj-tools || 2022 bomb "Failed to make obj-tools" 2023 fi 2024 if [ "${MKUPDATE}" = "no" ]; then 2025 make_in_dir tools cleandir 2026 fi 2027 make_in_dir tools build_install 2028 statusmsg "Tools built to ${TOOLDIR}" 2029} 2030 2031buildlibs() 2032{ 2033 if [ "${MKOBJDIRS}" != "no" ]; then 2034 ${runcmd} "${makewrapper}" ${parallel} obj || 2035 bomb "Failed to make obj" 2036 fi 2037 if [ "${MKUPDATE}" = "no" ]; then 2038 make_in_dir lib cleandir 2039 fi 2040 make_in_dir . do-distrib-dirs 2041 make_in_dir . includes 2042 make_in_dir . do-lib 2043 statusmsg "libs built" 2044} 2045 2046getkernelconf() 2047{ 2048 kernelconf="$1" 2049 if [ "${MKOBJDIRS}" != "no" ]; then 2050 # The correct value of KERNOBJDIR might 2051 # depend on a prior "make obj" in 2052 # ${KERNSRCDIR}/${KERNARCHDIR}/compile. 2053 # 2054 KERNSRCDIR="$(getmakevar KERNSRCDIR)" 2055 KERNARCHDIR="$(getmakevar KERNARCHDIR)" 2056 make_in_dir "${KERNSRCDIR}/${KERNARCHDIR}/compile" obj 2057 fi 2058 KERNCONFDIR="$(getmakevar KERNCONFDIR)" 2059 KERNOBJDIR="$(getmakevar KERNOBJDIR)" 2060 case "${kernelconf}" in 2061 */*) 2062 kernelconfpath="${kernelconf}" 2063 kernelconfname="${kernelconf##*/}" 2064 ;; 2065 *) 2066 kernelconfpath="${KERNCONFDIR}/${kernelconf}" 2067 kernelconfname="${kernelconf}" 2068 ;; 2069 esac 2070 kernelbuildpath="${KERNOBJDIR}/${kernelconfname}" 2071} 2072 2073diskimage() 2074{ 2075 ARG="$(echo $1 | tr '[:lower:]' '[:upper:]')" 2076 [ -f "${DESTDIR}/etc/mtree/set.base" ] || 2077 bomb "The release binaries must be built first" 2078 kerneldir="${RELEASEDIR}/${RELEASEMACHINEDIR}/binary/kernel" 2079 kernel="${kerneldir}/netbsd-${ARG}.gz" 2080 [ -f "${kernel}" ] || 2081 bomb "The kernel ${kernel} must be built first" 2082 make_in_dir "${NETBSDSRCDIR}/etc" "smp_${1}" 2083} 2084 2085buildkernel() 2086{ 2087 if ! ${do_tools} && ! ${buildkernelwarned:-false}; then 2088 # Building tools every time we build a kernel is clearly 2089 # unnecessary. We could try to figure out whether rebuilding 2090 # the tools is necessary this time, but it doesn't seem worth 2091 # the trouble. Instead, we say it's the user's responsibility 2092 # to rebuild the tools if necessary. 2093 # 2094 statusmsg "Building kernel without building new tools" 2095 buildkernelwarned=true 2096 fi 2097 getkernelconf $1 2098 statusmsg2 "Building kernel:" "${kernelconf}" 2099 statusmsg2 "Build directory:" "${kernelbuildpath}" 2100 ${runcmd} mkdir -p "${kernelbuildpath}" || 2101 bomb "Cannot mkdir: ${kernelbuildpath}" 2102 if [ "${MKUPDATE}" = "no" ]; then 2103 make_in_dir "${kernelbuildpath}" cleandir 2104 fi 2105 [ -x "${TOOLDIR}/bin/${toolprefix}config" ] \ 2106 || bomb "${TOOLDIR}/bin/${toolprefix}config does not exist. You need to \"$0 tools\" first." 2107 CONFIGOPTS=$(getmakevar CONFIGOPTS) 2108 ${runcmd} "${TOOLDIR}/bin/${toolprefix}config" ${CONFIGOPTS} \ 2109 -b "${kernelbuildpath}" -s "${TOP}/sys" ${configopts} \ 2110 "${kernelconfpath}" || 2111 bomb "${toolprefix}config failed for ${kernelconf}" 2112 make_in_dir "${kernelbuildpath}" depend 2113 make_in_dir "${kernelbuildpath}" all 2114 2115 if [ "${runcmd}" != "echo" ]; then 2116 statusmsg "Kernels built from ${kernelconf}:" 2117 kernlist=$(awk '$1 == "config" { print $2 }' ${kernelconfpath}) 2118 for kern in ${kernlist:-netbsd}; do 2119 [ -f "${kernelbuildpath}/${kern}" ] && \ 2120 echo " ${kernelbuildpath}/${kern}" 2121 done | tee -a "${results}" 2122 fi 2123} 2124 2125releasekernel() 2126{ 2127 getkernelconf $1 2128 kernelreldir="${RELEASEDIR}/${RELEASEMACHINEDIR}/binary/kernel" 2129 ${runcmd} mkdir -p "${kernelreldir}" 2130 kernlist=$(awk '$1 == "config" { print $2 }' ${kernelconfpath}) 2131 for kern in ${kernlist:-netbsd}; do 2132 builtkern="${kernelbuildpath}/${kern}" 2133 [ -f "${builtkern}" ] || continue 2134 releasekern="${kernelreldir}/${kern}-${kernelconfname}.gz" 2135 statusmsg2 "Kernel copy:" "${releasekern}" 2136 if [ "${runcmd}" = "echo" ]; then 2137 echo "gzip -c -9 < ${builtkern} > ${releasekern}" 2138 else 2139 gzip -c -9 < "${builtkern}" > "${releasekern}" 2140 fi 2141 done 2142} 2143 2144buildkernels() 2145{ 2146 allkernels=$( runcmd= make_in_dir etc '-V ${ALL_KERNELS}' ) 2147 for k in $allkernels; do 2148 buildkernel "${k}" 2149 done 2150} 2151 2152buildmodules() 2153{ 2154 setmakeenv MKBINUTILS no 2155 if ! ${do_tools} && ! ${buildmoduleswarned:-false}; then 2156 # Building tools every time we build modules is clearly 2157 # unnecessary as well as a kernel. 2158 # 2159 statusmsg "Building modules without building new tools" 2160 buildmoduleswarned=true 2161 fi 2162 2163 statusmsg "Building kernel modules for NetBSD/${MACHINE} ${DISTRIBVER}" 2164 if [ "${MKOBJDIRS}" != "no" ]; then 2165 make_in_dir sys/modules obj 2166 fi 2167 if [ "${MKUPDATE}" = "no" ]; then 2168 make_in_dir sys/modules cleandir 2169 fi 2170 make_in_dir sys/modules dependall 2171 make_in_dir sys/modules install 2172 2173 statusmsg "Successful build of kernel modules for NetBSD/${MACHINE} ${DISTRIBVER}" 2174} 2175 2176builddtb() 2177{ 2178 statusmsg "Building devicetree blobs for NetBSD/${MACHINE} ${DISTRIBVER}" 2179 if [ "${MKOBJDIRS}" != "no" ]; then 2180 make_in_dir sys/dtb obj 2181 fi 2182 if [ "${MKUPDATE}" = "no" ]; then 2183 make_in_dir sys/dtb cleandir 2184 fi 2185 make_in_dir sys/dtb dependall 2186 make_in_dir sys/dtb install 2187 2188 statusmsg "Successful build of devicetree blobs for NetBSD/${MACHINE} ${DISTRIBVER}" 2189} 2190 2191installmodules() 2192{ 2193 dir="$1" 2194 ${runcmd} "${makewrapper}" INSTALLMODULESDIR="${dir}" installmodules || 2195 bomb "Failed to make installmodules to ${dir}" 2196 statusmsg "Successful installmodules to ${dir}" 2197} 2198 2199installworld() 2200{ 2201 dir="$1" 2202 ${runcmd} "${makewrapper}" INSTALLWORLDDIR="${dir}" installworld || 2203 bomb "Failed to make installworld to ${dir}" 2204 statusmsg "Successful installworld to ${dir}" 2205} 2206 2207# Run rump build&link tests. 2208# 2209# To make this feasible for running without having to install includes and 2210# libraries into destdir (i.e. quick), we only run ld. This is possible 2211# since the rump kernel is a closed namespace apart from calls to rumpuser. 2212# Therefore, if ld complains only about rumpuser symbols, rump kernel 2213# linking was successful. 2214# 2215# We test that rump links with a number of component configurations. 2216# These attempt to mimic what is encountered in the full build. 2217# See list below. The list should probably be either autogenerated 2218# or managed elsewhere; keep it here until a better idea arises. 2219# 2220# Above all, note that THIS IS NOT A SUBSTITUTE FOR A FULL BUILD. 2221# 2222 2223RUMP_LIBSETS=' 2224 -lrumpvfs_nofifofs -lrumpvfs -lrump, 2225 -lrumpvfs_nofifofs -lrumpvfs -lrumpdev -lrump, 2226 -lrumpvfs_nofifofs -lrumpvfs 2227 -lrumpnet_virtif -lrumpnet_netinet -lrumpnet_net -lrumpnet -lrump, 2228 -lrumpkern_tty -lrumpvfs_nofifofs -lrumpvfs -lrump, 2229 -lrumpfs_tmpfs -lrumpvfs_nofifofs -lrumpvfs -lrump, 2230 -lrumpfs_ffs -lrumpfs_msdos -lrumpvfs_nofifofs -lrumpvfs -lrumpdev_disk -lrumpdev -lrump, 2231 -lrumpnet_virtif -lrumpnet_netinet -lrumpnet_net -lrumpnet 2232 -lrumpdev -lrumpvfs_nofifofs -lrumpvfs -lrump, 2233 -lrumpnet_sockin -lrumpfs_nfs 2234 -lrumpnet_virtif -lrumpnet_netinet -lrumpnet_net -lrumpnet 2235 -lrumpvfs_nofifofs -lrumpvfs -lrump, 2236 -lrumpdev_cgd -lrumpdev_raidframe -lrumpdev_disk -lrumpdev_rnd 2237 -lrumpdev_dm -lrumpdev -lrumpvfs_nofifofs -lrumpvfs -lrumpkern_crypto -lrump' 2238dorump() 2239{ 2240 local doclean="" 2241 local doobjs="" 2242 2243 export RUMPKERN_ONLY=1 2244 # create obj and distrib dirs 2245 if [ "${MKOBJDIRS}" != "no" ]; then 2246 make_in_dir "${NETBSDSRCDIR}/etc/mtree" obj 2247 make_in_dir "${NETBSDSRCDIR}/sys/rump" obj 2248 fi 2249 ${runcmd} "${makewrapper}" ${parallel} do-distrib-dirs \ 2250 || bomb 'could not create distrib-dirs' 2251 2252 [ "${MKUPDATE}" = "no" ] && doclean="cleandir" 2253 targlist="${doclean} ${doobjs} dependall install" 2254 # optimize: for test we build only static libs (3x test speedup) 2255 if [ "${1}" = "rumptest" ] ; then 2256 setmakeenv NOPIC 1 2257 setmakeenv NOPROFILE 1 2258 fi 2259 for cmd in ${targlist} ; do 2260 make_in_dir "${NETBSDSRCDIR}/sys/rump" ${cmd} 2261 done 2262 2263 # if we just wanted to build & install rump, we're done 2264 [ "${1}" != "rumptest" ] && return 2265 2266 ${runcmd} cd "${NETBSDSRCDIR}/sys/rump/librump/rumpkern" \ 2267 || bomb "cd to rumpkern failed" 2268 md_quirks=`${runcmd} "${makewrapper}" -V '${_SYMQUIRK}'` 2269 # one little, two little, three little backslashes ... 2270 md_quirks="$(echo ${md_quirks} | sed 's,\\,\\\\,g'";s/'//g" )" 2271 ${runcmd} cd "${TOP}" || bomb "cd to ${TOP} failed" 2272 tool_ld=`${runcmd} "${makewrapper}" -V '${LD}'` 2273 2274 local oIFS="${IFS}" 2275 IFS="," 2276 for set in ${RUMP_LIBSETS} ; do 2277 IFS="${oIFS}" 2278 ${runcmd} ${tool_ld} -nostdlib -L${DESTDIR}/usr/lib \ 2279 -static --whole-archive -lpthread -lc ${set} 2>&1 -o /tmp/rumptest.$$ | \ 2280 awk -v quirks="${md_quirks}" ' 2281 /undefined reference/ && 2282 !/more undefined references.*follow/{ 2283 if (match($NF, 2284 "`(rumpuser_|rumpcomp_|__" quirks ")") == 0) 2285 fails[NR] = $0 2286 } 2287 /cannot find -l/{fails[NR] = $0} 2288 /cannot open output file/{fails[NR] = $0} 2289 END{ 2290 for (x in fails) 2291 print fails[x] 2292 exit x!=0 2293 }' 2294 [ $? -ne 0 ] && bomb "Testlink of rump failed: ${set}" 2295 done 2296 statusmsg "Rump build&link tests successful" 2297} 2298 2299repro_date() { 2300 # try the bsd date fail back the linux one 2301 date -u -r "$1" 2> /dev/null || date -u -d "@$1" 2302} 2303 2304setup_mkrepro() 2305{ 2306 local quiet="$1" 2307 2308 if [ ${MKREPRO-no} != "yes" ]; then 2309 return 2310 fi 2311 if [ ${MKREPRO_TIMESTAMP-0} -ne 0 ]; then 2312 return; 2313 fi 2314 2315 local dirs=${NETBSDSRCDIR-/usr/src}/ 2316 if [ ${MKX11-no} = "yes" ]; then 2317 dirs="$dirs ${X11SRCDIR-/usr/xsrc}/" 2318 fi 2319 2320 local cvslatest=$(print_tooldir_program cvslatest) 2321 if [ ! -x "${cvslatest}" ]; then 2322 buildtools 2323 fi 2324 2325 local cvslatestflags= 2326 if ${do_expertmode}; then 2327 cvslatestflags=-i 2328 fi 2329 2330 MKREPRO_TIMESTAMP=0 2331 local d 2332 local t 2333 local vcs 2334 for d in ${dirs}; do 2335 if [ -d "${d}CVS" ]; then 2336 t=$("${cvslatest}" ${cvslatestflags} "${d}") 2337 vcs=cvs 2338 elif [ -d "${d}.git" ]; then 2339 t=$(cd "${d}" && git log -1 --format=%ct) 2340 vcs=git 2341 elif [ -d "${d}.hg" ]; then 2342 t=$(hg --repo "$d" log -r . --template '{date.unixtime}\n') 2343 vcs=hg 2344 elif [ -f "${d}.hg_archival.txt" ]; then 2345 local stat=$(print_tooldir_program stat) 2346 t=$("${stat}" -t '%s' -f '%m' "${d}.hg_archival.txt") 2347 vcs=hg 2348 else 2349 bomb "Cannot determine VCS for '$d'" 2350 fi 2351 2352 if [ -z "$t" ]; then 2353 bomb "Failed to get timestamp for vcs=$vcs in '$d'" 2354 fi 2355 2356 #echo "latest $d $vcs $t" 2357 if [ "$t" -gt "$MKREPRO_TIMESTAMP" ]; then 2358 MKREPRO_TIMESTAMP="$t" 2359 fi 2360 done 2361 2362 [ "${MKREPRO_TIMESTAMP}" != "0" ] || bomb "Failed to compute timestamp" 2363 if [ -z "${quiet}" ]; then 2364 statusmsg2 "MKREPRO_TIMESTAMP" \ 2365 "$(repro_date "${MKREPRO_TIMESTAMP}")" 2366 fi 2367 export MKREPRO MKREPRO_TIMESTAMP 2368} 2369 2370main() 2371{ 2372 initdefaults 2373 _args=$@ 2374 parseoptions "$@" 2375 2376 sanitycheck 2377 2378 build_start=$(date) 2379 statusmsg2 "${progname} command:" "$0 $*" 2380 statusmsg2 "${progname} started:" "${build_start}" 2381 statusmsg2 "NetBSD version:" "${DISTRIBVER}" 2382 statusmsg2 "MACHINE:" "${MACHINE}" 2383 statusmsg2 "MACHINE_ARCH:" "${MACHINE_ARCH}" 2384 statusmsg2 "Build platform:" "${uname_s} ${uname_r} ${uname_m}" 2385 statusmsg2 "HOST_SH:" "${HOST_SH}" 2386 if [ -n "${BUILDID}" ]; then 2387 statusmsg2 "BUILDID:" "${BUILDID}" 2388 fi 2389 if [ -n "${BUILDINFO}" ]; then 2390 printf "%b\n" "${BUILDINFO}" | \ 2391 while read -r line ; do 2392 [ -s "${line}" ] && continue 2393 statusmsg2 "BUILDINFO:" "${line}" 2394 done 2395 fi 2396 2397 rebuildmake 2398 validatemakeparams 2399 createmakewrapper 2400 setup_mkrepro 2401 2402 # Perform the operations. 2403 # 2404 for op in ${operations}; do 2405 case "${op}" in 2406 2407 makewrapper) 2408 # no-op 2409 ;; 2410 2411 tools) 2412 buildtools 2413 ;; 2414 libs) 2415 buildlibs 2416 ;; 2417 2418 sets) 2419 statusmsg "Building sets from pre-populated ${DESTDIR}" 2420 ${runcmd} "${makewrapper}" ${parallel} ${op} || 2421 bomb "Failed to make ${op}" 2422 setdir=${RELEASEDIR}/${RELEASEMACHINEDIR}/binary/sets 2423 statusmsg "Built sets to ${setdir}" 2424 ;; 2425 2426 build|distribution|release) 2427 ${runcmd} "${makewrapper}" ${parallel} ${op} || 2428 bomb "Failed to make ${op}" 2429 statusmsg "Successful make ${op}" 2430 ;; 2431 2432 cleandir|obj|sourcesets|syspkgs|params) 2433 ${runcmd} "${makewrapper}" ${parallel} ${op} || 2434 bomb "Failed to make ${op}" 2435 statusmsg "Successful make ${op}" 2436 ;; 2437 2438 iso-image|iso-image-source) 2439 ${runcmd} "${makewrapper}" ${parallel} \ 2440 CDEXTRA="$CDEXTRA" ${op} || 2441 bomb "Failed to make ${op}" 2442 statusmsg "Successful make ${op}" 2443 ;; 2444 2445 live-image|install-image) 2446 # install-image and live-image require mtree spec files 2447 # built with UNPRIVED. Assume UNPRIVED build has been 2448 # performed if METALOG file is created in DESTDIR. 2449 if [ ! -e "${DESTDIR}/METALOG" ] ; then 2450 bomb "The release binaries must have been built with -U to create images." 2451 fi 2452 ${runcmd} "${makewrapper}" ${parallel} ${op} || 2453 bomb "Failed to make ${op}" 2454 statusmsg "Successful make ${op}" 2455 ;; 2456 kernel=*) 2457 arg=${op#*=} 2458 buildkernel "${arg}" 2459 ;; 2460 kernel.gdb=*) 2461 arg=${op#*=} 2462 configopts="-D DEBUG=-g" 2463 buildkernel "${arg}" 2464 ;; 2465 releasekernel=*) 2466 arg=${op#*=} 2467 releasekernel "${arg}" 2468 ;; 2469 2470 kernels) 2471 buildkernels 2472 ;; 2473 2474 disk-image=*) 2475 arg=${op#*=} 2476 diskimage "${arg}" 2477 ;; 2478 2479 dtb) 2480 builddtb 2481 ;; 2482 2483 modules) 2484 buildmodules 2485 ;; 2486 2487 installmodules=*) 2488 arg=${op#*=} 2489 if [ "${arg}" = "/" ] && \ 2490 ( [ "${uname_s}" != "NetBSD" ] || \ 2491 [ "${uname_m}" != "${MACHINE}" ] ); then 2492 bomb "'${op}' must != / for cross builds." 2493 fi 2494 installmodules "${arg}" 2495 ;; 2496 2497 install=*) 2498 arg=${op#*=} 2499 if [ "${arg}" = "/" ] && \ 2500 ( [ "${uname_s}" != "NetBSD" ] || \ 2501 [ "${uname_m}" != "${MACHINE}" ] ); then 2502 bomb "'${op}' must != / for cross builds." 2503 fi 2504 installworld "${arg}" 2505 ;; 2506 2507 rump) 2508 make_in_dir . do-distrib-dirs 2509 make_in_dir . includes 2510 make_in_dir lib/csu dependall 2511 make_in_dir lib/csu install 2512 make_in_dir external/gpl3/gcc/lib/libgcc dependall 2513 make_in_dir external/gpl3/gcc/lib/libgcc install 2514 dorump "${op}" 2515 ;; 2516 2517 rumptest) 2518 dorump "${op}" 2519 ;; 2520 2521 *) 2522 bomb "Unknown operation \`${op}'" 2523 ;; 2524 2525 esac 2526 done 2527 2528 statusmsg2 "${progname} ended:" "$(date)" 2529 if [ -s "${results}" ]; then 2530 echo "===> Summary of results:" 2531 sed -e 's/^===>//;s/^/ /' "${results}" 2532 echo "===> ." 2533 fi 2534} 2535 2536main "$@" 2537