build/lbuild

   1 #!/bin/bash
   2
   3 # vim:expandtab:shiftwidth=4:softtabstop=4:tabstop=4:
   4
   5 # this is an alternative FD for stdout, to be used especially when we are
   6 # taking stdout from a function as it's return value.  i.e. foo=$(bar)
   7 # this is a workaround until a version of bash where we can put xtrace
   8 # on a specific FD
   9 exec 3>&1; STDOUT=3
  10
  11 #set -x
  12 xtrace="+x"
  13 if [[ $SHELLOPTS = *xtrace* ]]; then
  14     xtrace="-x"
  15 fi
  16 shopt -s extdebug
  17
  18 # include the exit_traps library
  19 . ${0%/lbuild}/exit_traps.sh
  20 . ${0%/lbuild}/funcs.sh
  21
  22 # our children should die when we do
  23 push_exit_trap "kill -INT -$$ || true" kill_children
  24
  25 # increment this if you have made a change that should force a new kernel
  26 # to build built
  27 BUILD_GEN=1
  28
  29 TOPDIR=$PWD
  30
  31 # CVSROOT is inherited from the environment
  32 KERNELDIR=
  33 LINUX=
  34 LUSTRE=
  35 RELEASE=false
  36 # XXX - some recent hacking has pretty much neutered this option.
  37 #       search through this file (and lbuild.old_school -- but that will
  38 #       be going away soon) for "-bb" and see how many places
  39 #       simply don't account for this option
  40 DO_SRC=true
  41 DOWNLOAD=true
  42 TAG=
  43 CANONICAL_TARGET=
  44 TARGET=
  45 TARGET_ARCH="$(uname -m)"
  46 # change default behavior to only build for the current arch
  47 TARGET_ARCHS="$TARGET_ARCH"
  48 TARGET_ARCHS_ALL="$TARGET_ARCH"
  49 [ "$TARGET_ARCH" = "i686" ] && TARGET_ARCHS_ALL="i686 i586 i386"
  50 CONFIGURE_FLAGS=
  51 EXTERNAL_PATCHES=
  52 EXTRA_VERSION=
  53 STAGEDIR=
  54 TMPDIR=${TMPDIR:-"/var/tmp"}
  55 TIMESTAMP=
  56 # this is a dir to try reuse old kernel RPMs in (although, it seems to be
  57 # unused in any real manner
  58 REUSERPM=
  59 # this is the dir that should be used to store reuse products
  60 REUSEBUILD=
  61 # should cached products be used or force rebuilding?
  62 USE_BUILD_CACHE=true
  63 # what does this do exactly?  does it imply no kernel build?
  64 NORPM=false
  65 LDISKFSRPM=true
  66 SKIPLDISKFSRPM="v1_4_* b1_4"
  67 SMPTYPES="smp bigsmp default ''"
  68 PATCHLESS=false
  69 XEN=false
  70 LINUXOBJ=
  71 DISTRO=
  72 KERNELTREE=
  73 # default to not adding -lustre- into the kernel RPM package names
  74 KERNEL_LUSTRE_NAMING=false
  75 # default not use kabi check.
  76 USE_KABI=false
  77
  78 # patchless build
  79 KERNELRPMSBASE=
  80 RPMSMPTYPE=
  81
  82 # from target file
  83 SERIES=
  84 BASE_ARCHS=
  85 BIGMEM_ARCHS=
  86 BOOT_ARCHS=
  87 JENSEN_ARCHS=
  88 SMP_ARCHS=
  89 BIGSMP_ARCHS=
  90 PSERIES64_ARCHS=
  91 UP_ARCHS=
  92
  93 # not in the target file any more
  94 CONFIG=
  95
  96 # build the lustre-tests rpm?
  97 LUSTRE_TESTS=true
  98
  99 # these are disabled by default, enabled with command line switches or by
 100 # the calling environment
 101 BUILD_MPTLINUX=${BUILD_MPTLINUX:-false}
 102 BUILD_RDAC=${BUILD_RDAC:-false}
 103
 104 DATE=$(date)
 105
 106 USE_DATESTAMP=1
 107 RPMBUILD=
 108
 109 OLD_SCHOOL=false
 110
 111 export CC=${CC:-gcc}
 112
 113 # Readlink is not present on some older distributions: emulate it.
 114 readlink() {
 115     local path=$1 ll
 116
 117     if [ -L "$path" ]; then
 118         ll="$(LC_ALL=C ls -l "$path" 2> /dev/null)" &&
 119         echo "${ll/* -> }"
 120     else
 121         return 1
 122     fi
 123 }
 124
 125 usage() {
 126     cat <<EOF
 127 Usage: ${0##*/} [OPTION]... [-- <lustre configure options>]
 128
 129   -d CVSROOT
 130     Specifies the CVS Root to use when pulling files from CVS.  The
 131     environment variable \$CVSROOT is used if this option is not
 132     present.
 133
 134   --downstream-release
 135     Set the downstream version.
 136
 137   --external-patches=EXTERNAL_PATCHES
 138     Directory similar to lustre/lustre/kernel_patches/ that lbuild should
 139     look for seres and config files in before looking in the lustre
 140     tree.
 141
 142   --extraversion=EXTRAVERSION
 143     Text to use for the rpm release and kernel extraversion.
 144
 145   --timestamp=TIMESTAMP
 146     Date of building lustre in format YYYYMMDDhhmmss
 147
 148   --reuserpm=DIR
 149     Try to reuse old kernel RPMs from DIR
 150
 151   --reusebuild=DIR
 152     Try to reuse old kernel builds from DIR
 153
 154   --kernelrpm=DIR
 155     Path to distro kernel RPM collection
 156
 157   --ccache
 158     Use ccache
 159
 160   --norpm
 161     Do not build RPMs (compile only mode)
 162
 163   --patchless
 164     Build lustre client only
 165
 166   --distro=DISTRO
 167     Which distro using. Autodetect by default
 168
 169   --kerneldir=KERNELDIR
 170     Directory containing Linux source tarballs referenced by target
 171     files.
 172
 173   --kerneltree=KERNELTREE
 174     Directory containing dirs with Linux source tarballs referenced by target
 175     files. Dir names in format kernel version ('2.6.9', etc.)
 176
 177   --linux=LINUX --with-linux=LINUX
 178     Directory of Linux kernel sources.  When this option is used, only
 179     Lustre modules and userspace are built.
 180
 181   --lustre=LUSTRE
 182     Path to an existing lustre source tarball to use instead of
 183     pulling from CVS.
 184
 185   --nodownload
 186     Do not try to download a kernel from downloads.lustre.org
 187
 188   --nosrc
 189     Do not build a .src.rpm, a full kernel patch, or a patched kernel
 190     tarball.
 191
 192   --ldiskfs
 193     Do ldiskfs RPM. Now true by default
 194
 195   --publish
 196     Unused.
 197
 198   --release
 199     Specifies that the files generated do not include timestamps, and
 200     that this is an official release.
 201
 202   --src
 203     Build a .src.rpm, a full kernel patch, and a patched kernel tarball.
 204
 205   --stage=DIR
 206     Directory used to stage packages for release.  RPMs will be placed
 207     more or less in DIR/<target>-<arch>, and the tarball will be
 208     placed in DIR.
 209
 210   --tag=TAG
 211     A CVS branch/tag name to build from when pulling from CVS.
 212
 213   --target=TARGET
 214     The name of the target to build.  The available targets are listed
 215     below.
 216
 217   --target-archs=TARGET_ARCHS
 218     A (space delimited) list of architectures to build.  By default,
 219     all of the archs supported by the TARGET will be built, in
 220     addition to a .src.rpm.  This option can limit those, for machines
 221     that can only build certain archs or if you only want a certain
 222     arch built (for testing, or a one-off kernel).
 223
 224     Also note that by using a non-"base" arch (eg, i386) only kernels
 225     will be built - there will be no lustre-lite-utils package.
 226
 227   --disable-datestamp
 228     Prevents the datestamp flag (-D) from being passed to cvs for
 229     checkouts. This is a workaround for a problem encountered when
 230     using lbuild with tinderbox.
 231
 232   --xen
 233     Builds a Xen domX kernel.
 234
 235   --enable-mptlinux
 236     Enables the building of MPTLINUX with the same kernel Lustre is
 237     built with.
 238
 239   --enable-rdac
 240     Enables the building of MPTLINUX with the same kernel Lustre is
 241     built with.
 242
 243   --set-value
 244     Set's a variable to a given value.
 245
 246 EOF
 247
 248 #   list_targets
 249
 250     fatal "$1" "$2"
 251 }
 252
 253 # canonicalize a relative path to a file
 254 canon_filepath() {
 255     local PATH="$1"
 256
 257     if [ ! -f "$PATH" ]; then
 258         return 1
 259     fi
 260
 261     local FILE=${PATH##*/}
 262     local DIR=${PATH%/*}
 263
 264     echo $(canon_path "$DIR")/$FILE
 265     return 0
 266 }
 267
 268 # canonicalize a relative path to a dir
 269 canon_path() {
 270     local PATH="$1"
 271
 272     if [ ! -d "$PATH" ]; then
 273         return 1
 274     fi
 275
 276     pushd "$PATH" >/dev/null || return 1
 277     local CANONPATH=$PWD
 278     popd >/dev/null
 279
 280     echo "$CANONPATH"
 281     return 0
 282 }
 283
 284 check_options() {
 285
 286     if [ "$LUSTRE" ]; then
 287         [ -r "$LUSTRE" ] || \
 288             usage 1 "Could not find Lustre source tarball '$LUSTRE'."
 289     else
 290         [ "$CVSROOT" ] || \
 291             usage 1 "Either specify a CVS Root with -d, or a Lustre source tarball with --lustre."
 292         [ "$TAG" ] || \
 293             usage 1 "A branch/tag name must be specified with --tag when not building from a tarball."
 294     fi
 295
 296     [ -z "$DISTRO" ] && DISTRO=$(autodetect_distro)
 297
 298     if [ -z "$LINUX" ]; then
 299         [ "$KERNELDIR" -o "$KERNELTREE" ] || \
 300             usage 1 "A kernel directory must be specified with --kerneldir or --kerneltree."
 301
 302         [ -d "$KERNELDIR" -o -d "$KERNELTREE" ] || \
 303             usage 1 "$KERNELDIR and $KERNELTREE are not a directory."
 304
 305         if ! $RELEASE; then
 306             [ "$TAG" ] || \
 307                 usage 1 "When building a snapshot, a tag name must be used."
 308         fi
 309
 310         [ "$TARGET" ] || TARGET=$(autodetect_target "$DISTRO")
 311 #       TARGET_FILE="$TOPDIR/lustre/kernel_patches/targets/$TARGET.target"
 312 #       [ -r "$TARGET_FILE" ] || \
 313 #               usage 1 "Target '$TARGET' was not found."
 314     fi
 315
 316     case $TARGET in
 317         2.6-rhel6)
 318             CANONICAL_TARGET="rhel6"
 319             ;;
 320         2.6-rhel5)
 321             CANONICAL_TARGET="rhel5"
 322             ;;
 323         2.6-rhel4)
 324             CANONICAL_TARGET="rhel-2.6"
 325             ;;
 326         2.6-suse)
 327             CANONICAL_TARGET="sles-2.6"
 328             ;;
 329         2.6-sles10)
 330             CANONICAL_TARGET="sles10-2.6"
 331             ;;
 332         2.6-sles11)
 333             CANONICAL_TARGET="sles11"
 334             ;;
 335         2.6-oel5)
 336             CANONICAL_TARGET="oel5"
 337             ;;
 338         hp_pnnl-2.4)
 339             CANONICAL_TARGET="hp-pnnl-2.4"
 340             ;;
 341         2.6-vanilla \
 342             | suse-2.4.21-2 \
 343             | rh-2.4 \
 344             | rhel-2.4 \
 345             | sles-2.4 \
 346             | 2.6-patchless)
 347                 CANONICAL_TARGET="$TARGET"
 348                 ;;
 349     esac
 350
 351     local timestampnodig=$(echo $TIMESTAMP | sed -e s/[0-9]*//g)
 352     [ "$timestampnodig" = "" ] || TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")
 353     local timestamplength="${#TIMESTAMP}"
 354     if [ $timestamplength -eq 12 ]; then
 355         TIMESTAMP="${TIMESTAMP}00"
 356     elif [ $timestamplength -ne 14 ]; then
 357         TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")
 358     fi
 359
 360     RPMBUILD=$(which rpmbuild 2>/dev/null | head -1)
 361     if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then
 362         RPMBUILD=$(which rpm 2>/dev/null | head -1)
 363         if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then
 364             usage 1 "Could not find binary for making rpms (tried rpmbuild and rpm)."
 365         fi
 366     fi
 367
 368     if [ -n "$CCACHE" ]; then
 369         which "$DISTCC" &>/dev/null && export DISTCC RPM_BUILD_NCPUS
 370
 371         if which "$CCACHE" &>/dev/null; then
 372             local ccache=$(which "$CCACHE")
 373             local bindir="$TOPDIR/bin"
 374
 375             if [ ! -d $bindir ]; then
 376                 mkdir -p $bindir || fatal 1 "error trying to create $bindir"
 377             else
 378                 rm ${bindir}/* > /dev/null 2>&1 || true
 379             fi
 380             ln -s "$ccache" ${bindir}/ccache
 381             ln -s "$ccache" ${bindir}/cc
 382             ln -s "$ccache" ${bindir}/$CC
 383             export PATH=$bindir:$PATH
 384             export CCACHE && export CC="ccache $CC"
 385             # zero the cache so we can see how effective we are being with it
 386             echo -n "ccache "
 387             ccache -z
 388
 389             # get some ccache stats when we are done
 390             push_exit_trap '[ -n "$CCACHE" ] && ccache -s' "ccache_summary"
 391             # should remove the ccache trap if lbuild is interrupted
 392             trap 'echo "Received an INT TERM or HUP signal, terminating."; delete_exit_trap "ccache_summary"; exit 1' INT TERM HUP
 393         fi
 394     fi
 395
 396     return 0
 397
 398 }
 399
 400 uniqify() {
 401
 402     echo $(echo "$*" | xargs -n 1 | sort -u)
 403
 404 }
 405
 406 fetch_url() {
 407     local url="$1"
 408     local target="$2"
 409
 410     local rc=0
 411     if which wget >/dev/null 2>&1; then
 412         if ! wget -nv "$url" -O "$target"; then
 413             rc=${PIPESTATUS[0]}
 414         fi
 415     elif which curl >/dev/null 2>&1; then
 416         if ! curl -L -s -o "$target" "$url"; then
 417             rc=${PIPESTATUS[0]}
 418         fi
 419     else
 420         fatal 1 "Could not find either wget or curl to fetch URLs."
 421     fi
 422
 423     return $rc
 424
 425 }
 426
 427 download_srpm() {
 428     local target=$1
 429     local srpm=$2
 430     local force="${3:-false}"
 431
 432     if $force || [ ! -r "$KERNELDIR/$srpm" ] ||
 433        [ ! -s "$KERNELDIR/$srpm" ]; then
 434         if $DOWNLOAD; then
 435             local location="http://downloads.lustre.org/public/kernels/$target/old"
 436             # get the location from a distro specific method if it exists
 437             if type -p kernel_srpm_location; then
 438                 location=$(kernel_srpm_location)
 439             fi
 440             echo "Downloading $location/$srpm..."
 441             if ! fetch_url "$location/$srpm" "$KERNELDIR/$srpm" 2>&1 ||
 442                [ ! -s "$KERNELDIR/$srpm" ]; then
 443                 rm -f $KERNELDIR/$srpm
 444                 # punt to a distro specific method if it exists
 445                 if ! type -p download_srpm-$DISTRO; then
 446                     fatal 1 "Could not download target $target's kernel SRPM $srpm from $location."
 447                 else
 448                     if ! download_srpm-$DISTRO "$target" "$srpm" "$force"; then
 449                         fatal 1 "Could not download target $target's kernel SRPM $srpm using download_srpm-$DISTRO."
 450                     fi
 451                 fi
 452             fi
 453         else
 454             fatal 1 "$srpm not found in directory $KERNELDIR."
 455         fi
 456     fi
 457
 458 }
 459
 460 download_file() {
 461     local from="$1"
 462     local to="$2"
 463     local force="$3"
 464
 465     local file=${from##*/}
 466
 467     if [ -d $to ]; then
 468         to="$to/$file"
 469     fi
 470
 471     local semaphore="$to-downloading"
 472
 473     is_downloading() {
 474         if [ ! -f $semaphore ]; then
 475             return 1
 476         fi
 477
 478         # make sure the download has not been aborted
 479         local now=$(date +%s)
 480         local file_mtime=$(stat -c %Y "$to")
 481         local staleness=$((now - file_mtime))
 482         # let's assume an active download will write at least once a minute
 483         if [ $staleness -gt 60 ]; then
 484             return 1
 485         fi
 486
 487         return 0
 488     }
 489
 490     is_downloaded() {
 491         # if the semaphore file exists, the file is either still downloading
 492         # or a download was aborted and we cannot trust the target file
 493         if [ -f $semaphore ]; then
 494             return 1
 495         fi
 496
 497         if ! is_downloading && [ -r "$to" ] && [ -s "$to" ]; then
 498             return 0
 499         fi
 500
 501         return 1
 502     }
 503
 504     if $force || ! is_downloaded; then
 505         if is_downloading; then
 506             echo "Somebody else is downloading $from..."
 507             while is_downloading; do
 508                 echo "Waiting for $to to finish downloading"
 509                 sleep 60
 510             done
 511             if is_downloaded; then
 512                 return 0
 513             else
 514                 echo "The download we were waiting for seems to have been aborted"
 515             fi
 516
 517         fi
 518
 519         if $DOWNLOAD; then
 520             echo "Downloading $from..."
 521             # flag others so they don't try to download also
 522             push_exit_trap "rm -f $to $semaphore" "download"
 523             touch $semaphore
 524             if ! fetch_url "$from" "$to" || [ ! -s "$to" ]; then
 525                 # the trap will remove the files via the fatal below
 526                 fatal 1 "Could not download ${to##*/} from ${from%/*}/."
 527             fi
 528             rm -f $semaphore
 529             delete_exit_trap "download"
 530         else
 531             fatal 1 "${to##*/} not found in directory ${to%/*}."
 532         fi
 533     fi
 534
 535     return 0
 536
 537 }
 538
 539 download_ofed() {
 540     local force="${1:-false}"
 541
 542     if [ -z "$OFED_VERSION" -o "$OFED_VERSION" = "inkernel" ]; then
 543         return 0
 544     fi
 545
 546     local OFED_BASE_VERSION=$OFED_VERSION
 547     if [[ $OFED_VERSION = *.*.*.* ]]; then
 548         OFED_BASE_VERSION=${OFED_VERSION%.*}
 549     fi
 550
 551     local location="http://www.openfabrics.org/downloads/OFED/ofed-${OFED_BASE_VERSION}/"
 552
 553     if [[ $OFED_VERSION = daily-* ]]; then
 554         local Mmv daily
 555         OFED_VERSION=${OFED_VERSION/daily-/}
 556         Mmv=${OFED_VERSION%%-*}
 557         daily=${OFED_VERSION##$Mmv-}
 558         location="http://www.openfabrics.org/downloads/OFED/ofed-${Mmv}-daily/"
 559         # find the filename for the version for the date specified
 560         OFED_VERSION=$(curl -s "$location" | sed -nre "/${daily}-/s/.*href=\"OFED-(${Mmv//./\\.}-${daily}-[0-9]{4,4}).tgz.*$/\1/p" | tail -1)
 561         if [ -z "$OFED_VERSION" ]; then
 562             fatal 1 "Could not determine the filename of the OFED snapshot for ${daily}"
 563         fi
 564     fi
 565
 566     local file="OFED-${OFED_VERSION}.tgz"
 567     download_file "$location/$file" "$KERNELTREE" "$force"
 568
 569 }
 570
 571 load_target() {
 572
 573     EXTRA_VERSION_save="$EXTRA_VERSION"
 574     for patchesdir in "$EXTERNAL_PATCHES" \
 575                       "$TOPDIR/lustre/lustre/kernel_patches"; do
 576         TARGET_FILE="$patchesdir/targets/$TARGET.target"
 577         [ -r "$TARGET_FILE" ] && break
 578     done
 579     [ -r "$TARGET_FILE" ] || fatal 1 "Target $TARGET was not found."
 580
 581     echo "Loading target config file $TARGET.target..."
 582
 583     # if the caller specified an OFED_VERSION it should override whatever
 584     # the target file specifies
 585     local env_OFED_VERSION="$OFED_VERSION"
 586
 587     . "$TARGET_FILE"
 588
 589     if [ -n "$env_OFED_VERSION" ]; then
 590         OFED_VERSION="$env_OFED_VERSION"
 591     fi
 592
 593     # doesn't make any sense to build OFED for xen domX's
 594     if $XEN; then
 595         OFED_VERSION=""
 596     fi
 597
 598     # XXX - set_rpm_smp_type is an ugly undeterministic hack.  it needs to
 599     #       go away and the target just specify the $RPMSMPTYPE
 600     [ -z "$RPMSMPTYPE" ] && set_rpm_smp_type
 601
 602     # CC might have been overwriten in TARGET_FILE
 603     if [[ $CC != ccache\ * ]] && which "$CCACHE" &>/dev/null; then
 604         export CCACHE && export CC="ccache $CC"
 605     fi
 606
 607     if [ ! "$KERNELTREE" = "" ] && [ -d "$KERNELTREE" ]; then
 608         KERNELDIR="$KERNELTREE/${lnxmaj}"
 609         [ -d "$KERNELDIR" ] || mkdir "$KERNELDIR"
 610     fi
 611
 612     # verify the series is available
 613     if [ "$SERIES" ]; then
 614         for series in $SERIES; do
 615             for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do
 616                 [ -r "$patchesdir/series/$series" ] && continue 2
 617             done
 618             fatal 1 "Target $TARGET's series $SERIES could not be found.\nSearched:\n\t$EXTERNAL_PATCHES/series\n\t$TOPDIR/lustre/lustre/kernel_patches/series."
 619         done
 620     fi
 621
 622     # set the location of the .config file
 623     local XENPOSTFIX=""
 624     if $XEN; then
 625         XENPOSTFIX="-xen"
 626     fi
 627
 628     if [ -f $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET-$TARGET_ARCH.config ]; then
 629         CONFIG_FILE="$TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET$XENPOSTFIX-$TARGET_ARCH${RPMSMPTYPE:+-}${RPMSMPTYPE}.config"
 630     fi
 631
 632     local lnxrelnew=${lnxrel//-/_}
 633
 634     # remember the EXTRA_VERSION before we diddle it here
 635     # XXX - we really should not diddle with any values read in from the
 636     #       target file.  if we want to modify a value, we should create
 637     #       a new variable.
 638     PRISTINE_EXTRA_VERSION=$EXTRA_VERSION
 639
 640     if ! $PATCHLESS && [ ! -f "$CONFIG_FILE" ]; then
 641         fatal 1 "Config file for target $TARGET missing from $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/."
 642     fi
 643
 644     if [ "$EXTRA_VERSION_save" ]; then
 645         EXTRA_VERSION="$EXTRA_VERSION_save"
 646     elif ! $RELEASE; then
 647         # if there is no patch series, then this is not a lustre specific
 648         # kernel.  don't make it look like one
 649         if $PATCHLESS || [ -n "$SERIES" ]; then
 650             EXTRA_VERSION=$(echo $EXTRA_VERSION | sed -e "s/\(.*_lustre\)\..*/\1/")
 651 #            EXTRA_VERSION="${EXTRA_VERSION}-${TAG}.${TIMESTAMP}"
 652             if ! $PATCHLESS && [ -n "$BUILDID" ]; then
 653                 EXTRA_VERSION="${EXTRA_VERSION}.${BUILDID}"
 654             fi
 655         fi
 656     fi
 657     # EXTRA_VERSION=${EXTRA_VERSION//-/_}
 658
 659     ALL_ARCHS="$BASE_ARCHS $BIGMEM_ARCHS $BOOT_ARCHS $JENSEN_ARCHS $SMP_ARCHS $BIGSMP_ARCHS $PSERIES64_ARCHS $UP_ARCHS"
 660
 661     BUILD_ARCHS=
 662     for arch in $(uniqify "$ALL_ARCHS"); do
 663         if [ -z "$TARGET_ARCHS" ] ||
 664            [[ \ $TARGET_ARCHS\  = *\ $arch\ * ]]; then
 665             BUILD_ARCHS="$BUILD_ARCHS $arch"
 666         fi
 667     done
 668     [ "$BUILD_ARCHS" ] || usage 1 "No available target archs to build."
 669     echo "Building for: $BUILD_ARCHS"
 670 }
 671
 672 tarflags() {
 673     local file="$1"
 674
 675     case "$file" in
 676         '')
 677             fatal 1 "tarflags(): File name argument missing."
 678             ;;
 679         *.tar.gz | *.tgz)
 680             echo 'zxf'
 681             ;;
 682         *.tar.bz2)
 683             echo 'jxf'
 684             ;;
 685         *.tar)
 686             echo 'xf'
 687             ;;
 688         *)
 689             fatal 1 "tarflags(): Unrecognized tar extension in file: $1"
 690             ;;
 691     esac
 692
 693 }
 694
 695 untar() {
 696     local tarfile="$1"
 697     shift
 698     local extractfile="$@"
 699
 700     echo "Untarring ${tarfile##*/}..."
 701     tar $(tarflags "$tarfile") "$tarfile" $extractfile
 702
 703 }
 704
 705 unpack_ofed() {
 706
 707     if ! untar "$KERNELTREE/OFED-${OFED_VERSION}.tgz"; then
 708         return 1
 709     fi
 710     [ -d OFED ] || ln -sf OFED-[0-9].[0-9]* OFED
 711
 712 }
 713
 714 unpack_rdac() {
 715
 716     if ! untar "$KERNELTREE/rdac-LINUX-${RDAC_VERSION}-source.tar.gz"; then
 717         return 1
 718     fi
 719     [ -d rdac-LINUX ] || ln -sf rdac-LINUX-[0-9][0-9].* rdac-LINUX
 720
 721 }
 722
 723 unpack_mptlinux() {
 724
 725     if ! untar $KERNELTREE/SUN_MPTLINUX_RHEL5_PH16-${MPTLINUX_VERSION}.tar.gz pkg1-rhel5/srpms-1/mptlinux-${MPTLINUX_VERSION}-1.src.rpm; then
 726         return 1
 727     fi
 728     mv pkg1-rhel5/srpms-1/mptlinux-${MPTLINUX_VERSION}-1.src.rpm .
 729
 730 }
 731
 732 unpack_lustre() {
 733
 734     if [ -z "$LUSTRE" ]; then
 735         local DATESTAMP=""
 736
 737         if [ -n "$USE_DATESTAMP" ]; then
 738             DATESTAMP="-D '$DATE'"
 739         fi
 740
 741         local DIRNAME="lustre-$TAG-$TIMESTAMP"
 742
 743         cvs -d "$CVSROOT" -qz3 co $DATESTAMP -d "$DIRNAME" lustre || \
 744             fatal 1 "There was an error checking out toplevel Lustre from CVS."
 745         pushd "$DIRNAME" > /dev/null
 746         ./lustrecvs "$TAG" || \
 747             fatal 1 "There was an error checking out Lustre/Portals/Build from CVS."
 748         echo "Creating lustre tarball..."
 749         sh autogen.sh || fatal 1 "There was an error running autogen.sh."
 750         ./configure --enable-dist \
 751                     --with-downstream-release "$DOWNSTREAM_RELEASE" || \
 752             fatal 1 "There was an error running ./configure to create makefiles."
 753         make dist || fatal 1 "There was an error running 'make dist'."
 754         LUSTRE=$PWD/lustre-*.tar.gz
 755         popd > /dev/null
 756     fi
 757
 758     untar "$LUSTRE" || fatal 1 "Error unpacking Lustre tarball"
 759     [ -d lustre ] || ln -sf lustre-[0-9].[0-9]* lustre
 760
 761 }
 762
 763 do_patch_linux() {
 764
 765     local do_patch=${1:-true}
 766
 767     FULL_PATCH="$PWD/lustre-kernel-${TARGET}-${EXTRA_VERSION}.patch"
 768     [ -f "$FULL_PATCH" ] && rm -f "$FULL_PATCH"
 769     $do_patch && pushd linux >/dev/null
 770     for series in $SERIES; do
 771         echo -n "Applying series $series:"
 772         for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do
 773             [ -r "$patchesdir/series/$series" ] || continue
 774             SERIES_FILE="$patchesdir/series/$series"
 775             for patch in $(<"$SERIES_FILE"); do
 776                 echo -n " $patch"
 777                 PATCH_FILE="$patchesdir/patches/$patch"
 778                 [ -r "$PATCH_FILE" ] || \
 779                     fatal 1 "Patch $patch does not exist in Lustre tree."
 780                 cat "$PATCH_FILE" >> "$FULL_PATCH" || {
 781                     rm -f $FULL_PATCH
 782                     fatal 1 "Error adding patch $patch to full patch."
 783                 }
 784                 if $do_patch; then
 785                     patch -s -p1 < "$PATCH_FILE" 2>&1 || {
 786                         rm -f $FULL_PATCH
 787                         fatal 1 "Error applying patch $patch."
 788                     }
 789                 fi
 790             done
 791             break
 792         done
 793         echo
 794     done
 795     $do_patch && popd >/dev/null
 796     echo "Full patch has been saved in ${FULL_PATCH##*/}."
 797
 798 }
 799
 800 build_lustre() {
 801     local linux="$1"
 802     local linuxobj="$2"
 803
 804     cp "$LUSTRE" SOURCES
 805
 806     pushd lustre >/dev/null
 807
 808     echo "Building Lustre RPMs for: $BUILD_ARCHS..."
 809     local targets arch
 810     for arch in $BUILD_ARCHS; do
 811         targets="--target $arch $targets"
 812     done
 813
 814     local confoptions=""
 815
 816     if $PATCHLESS; then
 817         confoptions="$confoptions --disable-server"
 818     fi
 819
 820     local rpmbuildopt='-tb'
 821     if $NORPM; then
 822         rpmbuildopt='-tc'
 823         echo NORPM mode. Only compiling.
 824     fi
 825
 826     ( $(skeep_ldiskfs_rpm $TAG) ) || {
 827
 828         pushd ldiskfs > /dev/null || return 255
 829
 830         if !  ./configure --enable-dist; then
 831             echo "failed to configure in ldiskfs"
 832             popd >/dev/null # pushd ldiskfs
 833             popd >/dev/null # pushd lustre
 834             return 255
 835         fi
 836
 837         if ! make dist 2>&1; then
 838             popd >/dev/null # pushd ldiskfs
 839             popd >/dev/null # pushd lustre
 840             return 255
 841         fi
 842
 843         #cp lustre-ldiskfs*.tar.gz $TOPDIR/SOURCES || \
 844         #    fatal 1 "Could not copy lustre-ldiskfs*.tar.gz to $TOPDIR/SOURCES"
 845
 846         if ! $RPMBUILD $targets $rpmbuildopt lustre-ldiskfs*.tar.gz \
 847             --define "configure_args $confoptions ${CONFIGURE_FLAGS}" \
 848             --define "kdir $linux" \
 849             ${linuxobj:+--define "kobjdir $linuxobj"} \
 850             --define "_tmppath /var/tmp" \
 851             --define "_topdir $TOPDIR" 2>&1; then
 852             popd >/dev/null # pushd ldiskfs
 853             popd >/dev/null # pushd lustre
 854             return 255
 855         fi
 856
 857         if $DO_SRC; then
 858             if ! $RPMBUILD -ts lustre-ldiskfs*.tar.gz \
 859                 --define "configure_args $confoptions ${CONFIGURE_FLAGS}" \
 860                 --define "kdir $linux" \
 861                 ${linuxobj:+--define "kobjdir $linuxobj"} \
 862                 --define "_tmppath /var/tmp" \
 863                 --define "_topdir $TOPDIR" 2>&1; then
 864                 popd >/dev/null # pushd ldiskfs
 865                 popd >/dev/null # pushd lustre
 866                 return 255
 867             fi
 868         fi
 869         popd >/dev/null # pushd ldiskfs
 870
 871         # tell lustre where ldiskfs is
 872         # XXX - pointing to the RPM BUILD dir is a hack.  we need to flesh
 873         #       out the ldiskfs RPM build so that it builds a
 874         #       lustre-ldiskfs-devel RPM and install that and point lustre
 875         #       to that instead
 876         confoptions="$confoptions --with-ldiskfs=$(ls -d $TOPDIR/BUILD/lustre-ldiskfs-*)"
 877     }
 878
 879     # convert the $PATCHLESS boolean to an empty/not-empty boolean
 880     # as silly as this seems, it makes the syntax of the rpmbuild command
 881     # simpler and not need an eval to deal with the quotes in the quotes
 882     local is_patchless=""
 883     if $PATCHLESS; then
 884         is_patchless="yes"
 885     fi
 886
 887     # ditto for the lustre-tests boolean
 888     local lustre_tests=""
 889     if ! $LUSTRE_TESTS; then
 890         lustre_tests="no"
 891     fi
 892
 893     $RPMBUILD $targets $rpmbuildopt "$LUSTRE" \
 894         ${is_patchless:+--define "lustre_name lustre-client"} \
 895         ${lustre_tests:+--define "build_lustre_tests 0"} \
 896         ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
 897         --define "configure_args $confoptions ${CONFIGURE_FLAGS}" \
 898         --define "kdir $linux" \
 899         ${linuxobj:+--define "kobjdir $linuxobj"} \
 900         --define "_tmppath $TMPDIR" \
 901         --define "_topdir $TOPDIR" 2>&1 || \
 902         fatal 1 "Error building rpms for $BUILD_ARCHS."
 903
 904     popd >/dev/null
 905
 906 }
 907
 908 stage() {
 909
 910     [ "$STAGEDIR" ] || return 0
 911
 912     for arch in $BUILD_ARCHS; do
 913         rpmdir="${STAGEDIR}/${CANONICAL_TARGET}-${arch}"
 914         echo "${0##*/}: Copying RPMs into ${rpmdir}"
 915         mkdir -p "${rpmdir}"
 916         cp -v RPMS/${arch}/*.rpm "${rpmdir}"
 917         if [ -d RPMS/noarch ]; then
 918             cp -v RPMS/noarch/*.rpm "${rpmdir}"
 919         fi
 920     done
 921
 922     cp -v "$LUSTRE" "$STAGEDIR"
 923
 924 }
 925
 926 #check if we need to build separate ldiskfs RPM
 927 skeep_ldiskfs_rpm() {
 928     local tag="$1"
 929
 930     local skip=false
 931
 932     if ! $LDISKFSRPM; then
 933         skip=true
 934     elif $PATCHLESS; then
 935         skip=true
 936     else
 937         for skiptag in $SKIPLDISKFSRPM; do
 938             [[ $tag == $skiptag ]] && skip=true && break
 939         done
 940     fi
 941
 942     echo $skip
 943
 944 }
 945
 946 set_rpm_smp_type() {
 947
 948     local infact_arch="${TARGET_ARCH}"
 949
 950     RPMSMPTYPE=""
 951     [ "$infact_arch" == "i586" ] && infact_arch="i686"
 952
 953     local smp_type
 954     for smp_type in $SMP_ARCHS; do
 955         [ $infact_arch == $smp_type ] && RPMSMPTYPE=smp && break
 956     done
 957
 958     for smp_type in $BIGSMP_ARCHS; do
 959         [ $infact_arch == $smp_type ] && RPMSMPTYPE=bigsmp && break
 960     done
 961
 962     for smp_type in $PPC64_ARCHS; do
 963         [ $infact_arch == $smp_type ] && RPMSMPTYPE=ppc64 && break
 964     done
 965
 966     for smp_type in $DEFAULT_ARCHS; do
 967         [ $infact_arch == $smp_type ] && RPMSMPTYPE=default && break
 968     done
 969
 970 }
 971
 972 # This function takes a linux source pool and digs out the linux release
 973 # from it
 974 find_linux_release() {
 975     local SRCDIR="$1"
 976
 977     local LINUXRELEASEHEADER=$SRCDIR/include/linux/version.h
 978     if [ -s $SRCDIR/include/linux/utsrelease.h ]; then
 979         LINUXRELEASEHEADER=$SRCDIR/include/linux/utsrelease.h
 980     fi
 981
 982     sed -ne 's/#define UTS_RELEASE "\(.*\)"$/\1/p' $LINUXRELEASEHEADER
 983
 984 }
 985
 986 # unpack kernel(/source/devel) RPM
 987 #
 988 # This function and it's setting of $LINUX and $LINUXOBJ is a total hack that
 989 # needs to completely refactored.  It completely ingores that $BUILD_ARCHS may
 990 # contain a list of arches for which rpmbuild commands (including the one for
 991 # lustre itself)
 992 unpack_linux_devel_rpm() {
 993     local kernelrpm="${1}"
 994
 995     [ -f "$kernelrpm" ] || return 255
 996     [ -d $TOPDIR/reused ] || mkdir $TOPDIR/reused || return 255
 997
 998     pushd $TOPDIR/reused &>/dev/null || return 255
 999
1000     if ! rpm2cpio < "$kernelrpm" | cpio -id > /dev/null 2>&1; then
1001         return 255
1002     fi
1003
1004     # call a distro specific hook, if available
1005     if type -p unpack_linux_devel_rpm-$DISTRO; then
1006         if ! unpack_linux_devel_rpm-$DISTRO "$kernelrpm"; then
1007             return 255
1008         fi
1009     fi
1010
1011     popd &>/dev/null
1012
1013     find_linux_devel_paths $TOPDIR/reused
1014
1015     return 0
1016
1017 }
1018
1019 build_kernel_ib() {
1020     local linux="$1"
1021
1022     # build kernel-ib{,-devel}
1023     local K_SRC="K_SRC"
1024     # ofed 1.3 had a bug in the rpm spec
1025     if [ "$OFED_VERSION" = "1.3" ]; then
1026         K_SRC="KSRC"
1027     fi
1028
1029     local OFED_CORE="--with-core-mod --with-ipoib-mod --with-sdp-mod --with-user_mad-mod --with-user_access-mod --with-addr_trans-mod --with-rds-mod --with-qlgc_vnic-mod --with-madeye-mod"
1030     local OFED_HARDWARE="--with-mthca-mod --with-mlx4-mod --with-mlx4_en-mod --with-cxgb3-mod --with-nes-mod"
1031     # some I/B drivers are architecture dependent and kernel-ib's configure
1032     # does not figure it out for us ~sigh~
1033     case "$TARGET_ARCH" in
1034         ppc64)
1035             OFED_HARDWARE="$OFED_HARDWARE --with-ehca-mod"
1036             ;;
1037     esac
1038     # we're no longer shipping the OFED iSCSI
1039     #OFED_ISCSI="--with-srp-mod --with-srp-target-mod"
1040     ## ISER module has no backport support as of OFED 1.5 (i.e. only builds on
1041     ##kernels >= 2.6.30)
1042     #if [[ $OFED_VERSION = 1.[0-4]* ]]; then
1043     #   OFED_ISCSI="$OFED_ISCSI --with-iser-mod"
1044     #fi
1045
1046     # assume we are just rebuilding the SRPM
1047     local BUILD_TYPE=${BUILD_TYPE:-"--rebuild"}
1048     local SOURCE="${TOPDIR}/OFED/SRPMS/ofa_kernel-*.src.rpm"
1049
1050     # but switch to building from the SPEC if we need to apply patches
1051     if ls ${TOPDIR}/lustre/build/patches/ofed/* >/dev/null; then
1052         BUILD_TYPE="-bb"
1053         rpm --define "_topdir ${TOPDIR}" -ivh $SOURCE
1054         SOURCE="${TOPDIR}/SPECS/ofa_kernel.spec"
1055         local file ed_fragment1 ed_fragment2 n=1
1056         for file in $(ls ${TOPDIR}/lustre/build/patches/ofed/*.patch); do
1057             ed_fragment1="$ed_fragment1
1058 Patch$n: ${file%%*/}"
1059             ed_fragment2="$ed_fragment2
1060 %patch$n -p0"
1061             cp $file ${TOPDIR}/SOURCES
1062             let n=$n+1
1063         done
1064         for file in $(ls ${TOPDIR}/lustre/build/patches/ofed/*.ed); do
1065             ed_fragment3="$ed_fragment3
1066 $(cat $file)"
1067             let n=$n+1
1068         done
1069
1070         if [ $n -gt 1 ]; then
1071             ed $SOURCE <<EOF
1072 /^Source: /a
1073 $ed_fragment1
1074 .
1075 /^%setup /a
1076 $ed_fragment2
1077 .
1078 $ed_fragment3
1079 wq
1080 EOF
1081         fi
1082     fi
1083
1084     local linuxrelease=$(find_linux_release "$linux")
1085     if ! $RPMBUILD $BUILD_TYPE --define 'build_kernel_ib 1' --define 'build_kernel_ib_devel 1' \
1086                   ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1087                   --define "_topdir ${TOPDIR}" --target ${TARGET_ARCH} \
1088                   --define "KVERSION ${linuxrelease}" \
1089                   --define "$K_SRC ${linux}" \
1090                   --define "LIB_MOD_DIR /lib/modules/${linuxrelease}/updates" \
1091                   ${OFA_KERNEL_RELEASE:+--define "_release $OFA_KERNEL_RELEASE"} \
1092                   --define "configure_options --without-quilt $OFED_CORE $OFED_HARDWARE $OFED_ISCSI" \
1093                   ${SOURCE} 2>&1; then
1094         fatal 1 "Error building kernel-ib"
1095     fi
1096
1097 }
1098
1099 store_for_reuse() {
1100         local articles="$1"
1101         local module="$2"
1102         local location="$3"
1103         local signature="$4"
1104         local use_links="$5"
1105
1106         local linkflag=""
1107         if $use_links; then
1108             linkflag="l"
1109         fi
1110
1111         location="$location"/"$signature"/"$module"
1112         mkdir -p "$location"
1113         # the cleanup script removes any directory that doesn't have a
1114         # .lastused, so let's try to prevent that as soon as we can
1115         # this solution still slightly racy with the cleanup script
1116         # but the race is a lot tighter now
1117         touch -t 197001010000 "$location/.lastused"
1118         ## use eval/echo here to make sure shell expansions are performed
1119         #if ! cp -a${linkflag} $(eval echo $articles) "$location"; then
1120         local article
1121         for article in $(eval echo $articles); do
1122             if ! cp -a${linkflag} "$article" "$location"; then
1123                 error "Failed to copy \"$article\" to \"$location\" in store_for_reuse()"
1124                 # rename the cache location so that it's not cached
1125                 # product, but is around for analysis
1126                 mv "$location"{,-bad-$(date +%s)} ||
1127                     error "failed to clean up a failed cache attempt" \
1128                           "in \"$location\" -- manual cleanup will be" \
1129                           "necessary"
1130                 return 1
1131             fi
1132         done
1133
1134         # flag the cache as complete (i.e. in case lbuild was previously
1135         # interrupted while caching)
1136         touch "$location/.lastused"
1137
1138         return 0
1139
1140 }
1141
1142 reuse() {
1143     local module="$1"
1144     local dest="$2"
1145     local use_links="${3:-false}"
1146     local signature="$4"
1147
1148     if [ -n "$REUSEBUILD" ] && [ -d "$REUSEBUILD/$signature/$module" ]; then
1149         if [ ! -f "$REUSEBUILD/$signature/$module/.lastused" ]; then
1150             # the .lastused flag is populated at the end of the caching to
1151             # signal that the caching was completed.  if that flag is not
1152             # there, then the cache is invalid (and should be removed in fact)
1153             mv "$REUSEBUILD/$signature/$module"{,-bad-$(date +%s)} ||
1154                 fatal 1 "failed to clean up a bad cache in location $REUSEBUILD/$signature/$module\" -- manual cleanup will be necessary"
1155             return 1
1156         fi
1157
1158         # so that we know how stale this entry is
1159         touch $REUSEBUILD/$signature/$module/.lastused
1160
1161         if $use_links; then
1162             if ls $REUSEBUILD/$signature/$module/* >/dev/null 2>&1; then
1163                 cp -al $REUSEBUILD/$signature/$module/* $dest/
1164             fi
1165         else
1166             # copying is pretty heavy
1167             # cp -a $REUSEBUILD/$signature/$module/* $dest/
1168             # do some creative symlinking instead
1169             local dir
1170             for dir in BUILD SRPMS SPECS; do
1171                 if ls $REUSEBUILD/$signature/$module/$dir/* >/dev/null 2>&1; then
1172                     ln -s $REUSEBUILD/$signature/$module/$dir/* $dest/$dir
1173                 fi
1174             done
1175             # sources have to be copied by file because we need SOURCES to
1176             # be a dir we can write into
1177 # could overrun ls's arg list here
1178             #ls $REUSEBUILD/$signature/$module/SOURCES/* |
1179             find $REUSEBUILD/$signature/$module/SOURCES/ -type f |
1180                 xargs ln -t $dest/SOURCES -s
1181
1182             # same for RPMS/* dirs
1183 # could overrun ls's arg list here
1184             #ls $REUSEBUILD/$signature/$module/RPMS/$TARGET_ARCH/* |
1185             local dir
1186             for dir in $REUSEBUILD/$signature/$module/RPMS/*; do
1187                 mkdir -p $dest/RPMS/${dir##*/}
1188                 find $dir -type f |
1189                   xargs ln -t $dest/RPMS/${dir##*/} -s
1190             done
1191         fi
1192         return 0
1193     else
1194         return 1
1195     fi
1196 }
1197
1198 basearch() {
1199     local arch="$1"
1200
1201     if [[ $arch = i[3456]86 ]]; then
1202         echo "i386"
1203     else
1204         echo "$arch"
1205     fi
1206
1207 }
1208
1209 build_kernel_with_srpm() {
1210     local outfd=$1
1211
1212     if [ -z "$outfd" ] || [ $outfd = 1 ]; then
1213         fatal 1 "You must supply a file descriptor to ${FUNCNAME[0]} and it cannot be 1"
1214     fi
1215
1216     # need to generate the patch for this target
1217     do_patch_linux false >&${outfd}    # sets global $FULL_PATCH (yeah, yuck)
1218
1219     # get an md5sum of the kernel patch + config for reuse check
1220     # XXX really, there needs to be a signature and a CONFIG_FILE per arch
1221     #     in BUILD_ARCHS
1222     local release_str
1223     if $RELEASE; then
1224         local release_str="RELEASE=$RELEASE\n"
1225     fi
1226
1227     if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then
1228         local REUSE_SIGNATURE=$({ echo -en $release_str;
1229                                   echo $BUILD_GEN;
1230                                   cat $CONFIG_FILE $TARGET_FILE $FULL_PATCH; } |
1231                                 md5sum | cut -d" " -f1)
1232         # see if we can link to the reuse pool
1233         # XXX - hrm.  i'm not convinced this doesn't belong in the reuse
1234         #       "library"
1235         local CAN_LINK_FOR_REUSE=false
1236         touch $REUSEBUILD/$$
1237         if cp -al $REUSEBUILD/$$ $TOPDIR/ 2>/dev/null; then
1238             CAN_LINK_FOR_REUSE=true
1239         fi
1240         rm $REUSEBUILD/$$
1241     fi
1242
1243     # the extra version string to use for the kernel (which might be a reused
1244     # kernel, remember)
1245     local kernel_extra_version=""
1246     if ! $USE_BUILD_CACHE || ! reuse kernel "$TOPDIR" "$CAN_LINK_FOR_REUSE" \
1247                                    "$REUSE_SIGNATURE"; then
1248         # nothing cached, build from scratch
1249         if [ ! -r "$KERNELDIR/$KERNEL_SRPM" ]; then
1250             echo "Downloading kernel SRPM" >&${outfd}
1251             download_srpm "$CANONICAL_TARGET" "$KERNEL_SRPM" >&${outfd}
1252         fi
1253
1254         if ! rpm -ivh $KERNELDIR/$KERNEL_SRPM \
1255                   --define "_topdir $TOPDIR" >&${outfd} 2>&1; then
1256             # should we clean this up or leave it for analysis?
1257             #rm -rf $RPMTOPDIR
1258             fatal 1 "Error installing kernel SRPM."
1259         fi
1260
1261         # put the Lustre kernel patch into the RPM build tree
1262         cp $FULL_PATCH $TOPDIR/SOURCES/linux-${lnxmaj}-lustre.patch
1263         prepare_and_build_srpm >&${outfd} ||
1264             fatal 1 "failed to prepare_and_build_srpm"
1265
1266         if [ -z "$REUSE_SIGNATURE" ]; then
1267             echo "No reuse signature was caculated so not storing the built kernel" >&${outfd}
1268         else
1269             # store the resulting kernel RPM build tree for future use
1270             echo "Storing the built kernel for future reuse" >&${outfd}
1271             if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,SRPMS,RPMS}" \
1272                                  "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \
1273                                  "$CAN_LINK_FOR_REUSE"; then
1274                 error "Failed to store kernel RPMS for reuse"
1275                 echo "unknown" >&${outfd}
1276                 return 1
1277             fi
1278         fi
1279     fi  # build reuse
1280
1281     # figure out the EXTRA_VERSION of the kernel we built or are re-using
1282     local KERNEL_RPM
1283     if ! KERNEL_RPM=$(find_rpm "$TOPDIR/RPMS/$TARGET_ARCH/" provides "^kernel ="); then
1284         fatal 1 "Failed to find a kernel RPM in $TOPDIR/RPMS/$TARGET_ARCH/"
1285     fi
1286     kernel_extra_version=$(rpm -q --queryformat "%{RELEASE}" -p $TOPDIR/RPMS/$TARGET_ARCH/$KERNEL_RPM)
1287
1288     # should now have the following RPMs
1289     # $TOPDIR/RPMS/$arch/kernel-lustre-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1290     # $TOPDIR/RPMS/$arch/kernel-lustre-devel-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1291     # $TOPDIR/RPMS/$arch/kernel-lustre-headers-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1292     # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-common-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1293     # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1294
1295     echo $kernel_extra_version
1296     return 0
1297
1298 }
1299
1300 build_mptlinux() {
1301     local linux="$1"
1302     local version="$2"
1303
1304     if ! $BUILD_RDAC || [ -z "$version" -o "$version" = "inkernel" ]; then
1305         return 0
1306     fi
1307
1308     local targets arch
1309     for arch in $BUILD_ARCHS; do
1310         targets="--target $arch $targets"
1311     done
1312
1313     local rpmbuildopt='-bb'
1314     if $NORPM; then
1315         rpmbuildopt='-bc'
1316         echo NORPM mode. Only compiling.
1317     fi
1318
1319     # if only we could just rebuild the src.rpm.  but the included spec
1320     # is a real pig's breakfast.  just check out the patch we need to
1321     # apply to it to make it useful.
1322     #$RPMBUILD --rebuild \
1323     #          --define "_topdir ${TOPDIR}" --target ${TARGET_ARCH} \
1324     #          ${TOPDIR}/mptlinux-*.src.rpm
1325     rpm -ivh --define "_topdir ${TOPDIR}" ${TOPDIR}/mptlinux-*.src.rpm
1326
1327     # now the big honkin' patch to the spec file
1328     pushd ${TOPDIR}/SPECS
1329     # to regen this patch use:
1330     # !!cd ~/rpm/SPECS/ && diff -u mptlinux.spec{.dist,}
1331     patch -p0 < ${TOPDIR}/lustre/build/mptlinux.spec.patch || fatal 1 "failed to patch mptlinux.spec"
1332     popd
1333
1334     local targets arch
1335         for arch in $BUILD_ARCHS; do
1336         targets="--target $arch $targets"
1337     done
1338
1339     local rpmbuildopt='-bb'
1340     if $NORPM; then
1341         rpmbuildopt='-bc'
1342         echo NORPM mode. Only compiling.
1343     fi
1344
1345     if ! $RPMBUILD $targets $rpmbuildopt \
1346                   ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1347                   --define "_tmppath /var/tmp" \
1348                   --define "_topdir ${TOPDIR}" \
1349                   --define "kernel_obj $linux" \
1350                   ${TOPDIR}/SPECS/mptlinux.spec 2>&1; then
1351         return 1
1352     fi
1353     if $DO_SRC; then
1354         if ! $RPMBUILD -bs \
1355                       ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1356                       --define "_tmppath /var/tmp" \
1357                       --define "_topdir ${TOPDIR}" \
1358                       --define "kernel_obj $linux" \
1359                       ${TOPDIR}/SPECS/mptlinux.spec 2>&1; then
1360             return 1
1361         fi
1362     fi
1363
1364     return 0
1365
1366 }
1367
1368 # build RDAC
1369 build_rdac() {
1370     local linux="$1"
1371     local version="$2"
1372
1373     if ! $BUILD_MPTLINUX || [ -z "$version" -o "$version" = "inkernel" ]; then
1374         return 0
1375     fi
1376
1377     # note that we use an _, not a . before the spec on purpose.  we are not
1378     # allowed to have more than one file with a .spec trailer in a tarball
1379     # that is supposed to be usable with rpmbuild
1380     cp lustre/build/rdac_spec ${TOPDIR}/SPECS/rdac.spec || fatal 1 "Could not find rdac.spec in lustre/build"
1381
1382     local targets arch
1383     for arch in $BUILD_ARCHS; do
1384         targets="--target $arch $targets"
1385     done
1386
1387     local rpmbuildopt='-bb'
1388     if $NORPM; then
1389         rpmbuildopt='-bc'
1390         echo NORPM mode. Only compiling.
1391     fi
1392
1393     local distro
1394     case $DISTRO in
1395      rhel5)     distro="REDHAT"
1396                 ;;
1397     sles1*)     distro="SUSE"
1398                 ;;
1399          *)     echo "$DISTRO not supported by RDAC, skipping"
1400                 return 0
1401                 ;;
1402     esac
1403     if ! $RPMBUILD $targets $rpmbuildopt --define "dist $distro" \
1404                   ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1405                   --define "_tmppath /var/tmp" \
1406                   --define "_topdir ${TOPDIR}" \
1407                   --define "kernel_obj $linux" \
1408                   ${TOPDIR}/SPECS/rdac.spec 2>&1; then
1409         return 1
1410     fi
1411     if $DO_SRC; then
1412         if ! $RPMBUILD -bs --define "dist $distro" \
1413                       ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1414                       --define "_tmppath /var/tmp" \
1415                       --define "_topdir ${TOPDIR}" \
1416                       --define "kernel_obj $linux" \
1417                       ${TOPDIR}/SPECS/rdac.spec 2>&1; then
1418             return 1
1419         fi
1420     fi
1421
1422     return 0
1423 }
1424
1425 # build OFED
1426 # globals used:
1427 #    TOPDIR
1428 #    REUSEBUILD, USE_BUILD_CACHE
1429 #    CONFIGURE_FLAGS
1430
1431 build_ofed() {
1432     local linux="$1"
1433     local ofed_version="$2"
1434
1435     # if an ofed version is given, then it means use OFED proper,
1436     # not any vendor specific "inkernel" version
1437     if [ -z "$ofed_version" ]; then
1438         return 0
1439     fi
1440
1441     if [ "$ofed_version" = "inkernel" ]; then
1442         # see if there is a distro specific override for this and use
1443         # that if it exists
1444         # XXX we need to better integrate a distro specific override with
1445         #     the rest of this function so that all of the reuse cache
1446         #     stuff is leveraged given that 80% of this function is reuse
1447         if type -p build_ofed-${DISTRO}; then
1448             local ofed_location
1449             ofed_location=$(build_ofed-${DISTRO} ${STDOUT})
1450             local rc=${PIPESTATUS[0]}
1451             CONFIGURE_FLAGS="--with-o2ib=${ofed_location} ${CONFIGURE_FLAGS}"
1452             return $rc
1453         else
1454             return 0
1455         fi
1456     fi
1457
1458     # build kernel-ib
1459     if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then
1460         local REUSE_SIGNATURE=$({ echo "$ofed_version";
1461                                   echo "$(find_linux_release ${linux})";
1462                                   cat "${linux}/include/linux/autoconf.h"; } |
1463                                 md5sum | cut -d" " -f1)
1464         # see if we can link to the reuse pool
1465         # XXX - hrm.  i'm not convinced this doesn't belong in the reuse
1466         #       "library"
1467         local CAN_LINK_FOR_REUSE=false
1468         touch $REUSEBUILD/$$
1469         if cp -al $REUSEBUILD/$$ $TOPDIR/; then
1470             CAN_LINK_FOR_REUSE=true
1471         fi
1472         rm $REUSEBUILD/$$
1473     fi
1474
1475     if ! $USE_BUILD_CACHE || ! reuse ofed "$TOPDIR" "$CAN_LINK_FOR_REUSE" \
1476                                    "$REUSE_SIGNATURE"; then
1477         if [ -n "$REUSE_SIGNATURE" ]; then
1478             # stash away the existing built articles for a moment
1479             mkdir bak
1480             mv {BUILD,{S,}RPMS,S{OURCE,PEC}S} bak
1481             function mv_back {
1482                 pushd bak
1483                 find . | cpio -pudlm ..
1484                 popd
1485                 rm -rf bak
1486             }
1487             create_rpmbuild_dirs
1488         fi
1489         # build it
1490         build_kernel_ib "${linux}"
1491
1492         if [ -z "$REUSE_SIGNATURE" ]; then
1493             echo "No reuse signature was caculated so not storing the built ofed"
1494         else
1495             # store the resulting RPM build tree for future use
1496             echo "Storing the built ofed for future reuse"
1497             if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,BUILD,SRPMS,RPMS}" \
1498                                  "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \
1499                                  "$CAN_LINK_FOR_REUSE"; then
1500                 error "Failed to store OFED RPMS for reuse"
1501                 mv_back
1502                 return 1
1503             fi
1504             # put the stuff we stashed away back
1505             mv_back
1506         fi
1507     fi
1508
1509     pushd "$TOPDIR" >/dev/null
1510     rm -rf kernel-ib-devel
1511     mkdir kernel-ib-devel
1512     cd kernel-ib-devel
1513     # the actual ofed RPMs don't have the -rc$n or -$date string appened that
1514     # might be present on the file
1515     local linuxrelease=$(find_linux_release "$linux")
1516     ofed_version=$(echo $ofed_version |
1517                    sed -re 's/-(20[0-9]{6,6}-[0-9]{4,4}|rc[0-9]*)$//')
1518     local rpm=$(ls $TOPDIR/RPMS/*/kernel-ib-devel-${ofed_version}-${linuxrelease//-/_}.*.rpm)
1519     if ! rpm2cpio < $rpm | cpio -id; then
1520         fatal 1 "could not unpack the kernel-ib-devel rpm."
1521     fi
1522     CONFIGURE_FLAGS="--with-o2ib=$(pwd)/usr/src/ofa_kernel ${CONFIGURE_FLAGS}"
1523     popd >/dev/null
1524
1525 }
1526
1527 build_with_srpm() {
1528
1529     if ! $PATCHLESS; then
1530         local kernel_extra_version
1531         if ! kernel_extra_version=$(build_kernel_with_srpm ${STDOUT}); then
1532             fatal 1 "Failed to build the kernel from it's SRPM"
1533         fi
1534
1535         for arch in $BUILD_ARCHS; do
1536             local kernel_devel_rpm
1537             if ! kernel_devel_rpm=$(find_rpm "$TOPDIR/RPMS/$arch/" provides "^$(devel_kernel_name $KERNEL_LUSTRE_NAMING) ="); then
1538                 fatal 1 "Failed to find a kernel development RPM in $TOPDIR/RPMS/$arch/"
1539             fi
1540
1541             # install the -devel RPM in preparation for modules builds
1542             if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \
1543                            "$TOPDIR/RPMS/$arch/$kernel_devel_rpm"; then
1544                 fatal 1 "Could not find the Linux tree in $TOPDIR/RPMS/$arch/$kernel_devel_rpm"
1545             fi
1546         done
1547     else
1548         # need to find and unpack the vendor's own kernel-devel for patchless
1549         # client build
1550         local kernelrpm
1551         if ! kernelrpm=$(find_linux_rpm "-$DEVEL_KERNEL_TYPE"); then
1552             fatal 1 "Could not find the kernel-$DEVEL_KERNEL_TYPE RPM in ${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}"
1553         fi
1554         if ! lnxrel="$lnxrel" unpack_linux_devel_rpm "$kernelrpm" "-"; then
1555             fatal 1 "Could not find the Linux tree in $kernelrpm"
1556         fi
1557     fi
1558
1559     # ~sigh~  have to make copies of and modify some of the rpm
1560     # infrastructure files so that find-requires can find our unpacked
1561     # kernel-devel artifacts
1562     cp $RPM_HELPERS_DIR/{symset-table,find-requires{,.ksyms}} .
1563     FIND_REQUIRES="$(pwd)/find-requires"
1564     chmod 755 {symset-table,find-requires{,.ksyms}}
1565     local tmp="$(pwd)"
1566     tmp="${tmp//\//\\/}"
1567     ed find-requires <<EOF
1568 1a
1569 set -x
1570 .
1571 /|.*find-requires.ksyms/s/|/| bash -x/
1572 g/ [^ ]*\/\(find-requires\.ksyms\)/s// $tmp\/\1/g
1573 wq
1574 EOF
1575     ed find-requires.ksyms <<EOF
1576 1a
1577 set -x
1578 .
1579 g/\/.*\/\(symset-table\)/s//$tmp\/\1/g
1580 wq
1581 EOF
1582     ed symset-table <<EOF
1583 1a
1584 set -x
1585 .
1586 g/\(\/boot\/\)/s//$tmp\/reused\1/g
1587 g/\(\/usr\/src\/kernels\/\)/s//$tmp\/reused\1/g
1588 wq
1589 EOF
1590
1591     build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||
1592         fatal 1 "error building OFED"
1593
1594     if ! $PATCHLESS; then
1595         # only need RDAC for the server
1596         build_rdac "${LINUXOBJ:-$LINUX}" "$RDAC_VERSION" ||
1597             fatal 1 "error building RDAC"
1598     fi
1599
1600     build_mptlinux "${LINUXOBJ:-$LINUX}" "$MPTLINUX_VERSION" ||
1601         fatal 1 "error building mptlinux"
1602
1603     # now build Lustre
1604     if build_lustre "$LINUX" "$LINUXOBJ"; then
1605         # the build worked.  resolve any symlinked files (i.e. from reuse)
1606         # in RPMS/$arch to real files so that that that huge mess of
1607         # complication known as LTS can copy them yet somewhere else.
1608         # is it any wonder this whole process is so damn so?  anyone ever
1609         # heard of hardlinks?  it's this cool new thing that allows you save
1610         # tons of time and space by creating... well you can go read about
1611         # them if you have not heard about them yet.
1612         # can i say how much the implemenation of all of this really impedes
1613         # RPM reuse?
1614         local dir
1615         for dir in RPMS/*; do
1616             pushd $dir
1617             for file in $(ls); do
1618                 if [ -h $file ]; then
1619                     cp $file foo
1620                     mv foo $file
1621                 fi
1622             done
1623             popd
1624         done
1625         # also, for i?86, make sure all of the RPMs are in RPMS/$TARGET_ARCH
1626         # as that's where LTS expects to find them
1627         for dir in RPMS/*; do
1628             if [ $dir = RPMS/$TARGET_ARCH ]; then
1629                 continue
1630             fi
1631             pushd $dir
1632             local files=$(ls)
1633             if [ -n "$files" ]; then
1634                 cp -al $files ../$TARGET_ARCH
1635             fi
1636             popd
1637         done
1638     else
1639         return 1
1640     fi
1641
1642 }
1643
1644 create_rpmbuild_dirs() {
1645
1646     [ -d RPMS ] || mkdir RPMS
1647     for arch in $BUILD_ARCHS; do
1648         if [[ $arch = i?86 ]]; then
1649             # some stupidity in the sles11 kernel spec requires an RPMS/i386
1650             # even if the target arch is i686
1651             [ -d RPMS/i386 ] || mkdir RPMS/i386
1652         fi
1653         [ -d RPMS/$arch ] || mkdir RPMS/$arch
1654     done
1655     [ -d BUILD ] || mkdir BUILD
1656     [ -d SOURCES ] || mkdir SOURCES
1657     [ -d SPECS ] || mkdir SPECS
1658     [ -d SRPMS ] || mkdir SRPMS
1659
1660 }
1661
1662 new_list() {
1663
1664     echo ""
1665
1666 }
1667
1668 add_list() {
1669     local list="$1"
1670     local item="$2"
1671
1672     echo "$list $item"
1673
1674 }
1675
1676 is_list_member() {
1677     local list="$1"
1678     local item="$2"
1679
1680     [[ $list\  == *\ $item\ * ]]
1681
1682 }
1683
1684 #########################################################################
1685 # Generate a backtrace through the call stack.
1686 #
1687 # Input: None
1688 # Output: None
1689 #########################################################################
1690 backtrace() {
1691     local strip=${1:-1}
1692
1693     local funcname="" sourcefile="" lineno="" n
1694
1695     echo "Call stack: (most recent first)"
1696     for (( n = $strip ; n < ${#FUNCNAME[@]} ; ++n )) ; do
1697         funcname=${FUNCNAME[$n - 1]}
1698         sourcefile=$(basename ${BASH_SOURCE[$n]})
1699         lineno=${BASH_LINENO[$n - 1]}
1700         if [ $n = 1 ]; then
1701             let lineno-=11
1702         fi
1703         # Display function arguments
1704         if [[ ! -z "${BASH_ARGV[@]}" ]]; then
1705             local args newarg j p=0
1706             for (( j = ${BASH_ARGC[$n - 1]}; j > 0; j-- )); do
1707                 newarg=${BASH_ARGV[$j + $p - 1]}
1708                 args="${args:+${args} }'${newarg}'"
1709             done
1710             let p+=${BASH_ARGC[$n - 1]}
1711         fi
1712         echo "  ${funcname} ${args:+${args} }at ${sourcefile}:${lineno}"
1713     done
1714
1715     echo
1716     echo "BEGIN BACKTRACE"
1717
1718     #echo ${BASH_LINENO[*]}
1719     #echo ${BASH_SOURCE[*]}
1720     #echo ${FUNCNAME[*]}
1721     local i=$((${#FUNCNAME[@]} - 1))
1722     while [ $i -ge 0 ]; do
1723         local lineno=${BASH_LINENO[$i]}
1724         if [ $i = 0 ]; then
1725             let lineno-=11
1726         fi
1727         local SOURCELINE="${BASH_SOURCE[$i + 1]}:${lineno}"
1728         # Can't figure out how to get function args from other frames...
1729         local FUNCTION="${FUNCNAME[$i]}()"
1730         echo "$SOURCELINE:$FUNCTION"
1731         i=$((i - 1))
1732     done
1733
1734     echo "END BACKTRACE"
1735
1736     echo $BACKTRACE
1737
1738 }
1739
1740 seen_list=$(new_list)
1741 trap 'set +x;
1742 echo "An unexpected error has occurred at ${BASH_SOURCE[0]##*/}:$((LINENO-1)).
1743 Unfortunately the above line number in the message may or may not be correct,
1744 but details have been send to the lbuild maintainer.  Attempting to continue."; (echo "Untrapped error"
1745 echo
1746 # have we seen this one
1747 echo "checking seen list for ${BASH_SOURCE[0]}:${BASH_LINENO[0]}"
1748
1749 if is_list_member "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}"; then
1750   echo "seen this one already"
1751 else
1752   seen_list=$(add_list "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}")
1753 fi
1754 backtrace
1755 echo
1756 echo "Environment:"
1757 set
1758 ) | mail -s "Untrapped error at ${BASH_SOURCE[0]##*/}:$((LINENO-15)) on $HOSTNAME" brian@sun.com >&2; set $xtrace' ERR
1759 set -E
1760
1761 [ -r ~/.lbuildrc ] && . ~/.lbuildrc
1762
1763 options=$(getopt -o d:D:h -l kerneltree:,distro:,downstream-release:,kernelrpm:,reusebuild:,patchless,ldiskfs,ccache,reuse:,norpm,disable-datestamp,external-patches:,timestamp:,extraversion:,kerneldir:,linux:,lustre:,nodownload,nosrc,ofed-version:,publish,release,set-value:,src,stage:,tag:,target:,target-archs:,with-linux:,xen,enable-mptlinux,enable-rdac -- "$@")
1764
1765 if [ $? != 0 ]; then
1766     usage 1
1767 fi
1768
1769 eval set -- "$options"
1770
1771 while [ "$1" ]; do
1772     case "$1" in
1773         '')
1774             usage 1
1775             ;;
1776         --ccache)
1777             CCACHE='ccache'
1778             shift
1779             ;;
1780         -d)
1781             CVSROOT=$2
1782             shift 2
1783             ;;
1784         -D)
1785             DATE=$2
1786             shift 2
1787             ;;
1788         --downstream-release)
1789             DOWNSTREAM_RELEASE=$2
1790             shift 2
1791             ;;
1792         --external-patches)
1793             EXTERNAL_PATCHES=$2
1794             shift 2
1795             ;;
1796         --extraversion)
1797             EXTRA_VERSION=$2
1798             shift 2
1799             ;;
1800         --help | -h)
1801             usage 0
1802             ;;
1803         --kerneldir)
1804             KERNELDIR=$2
1805             shift 2
1806             ;;
1807         --kerneltree)
1808             if ! KERNELTREE=$(canon_path "$2"); then
1809                 fatal 1 "Could not determine the canonical location of $2"
1810             fi
1811             shift 2
1812             ;;
1813         --linux | --with-linux)
1814             if ! LINUX=$(canon_path "$2"); then
1815                 fatal 1 "Could not determine the canonical location of $2"
1816             fi
1817             shift 2
1818             ;;
1819         --distro)
1820             DISTRO=$2
1821             shift 2
1822             ;;
1823         --reuserpm)
1824             REUSERPM=$2
1825             shift 2
1826             ;;
1827         --reusebuild)
1828             if ! REUSEBUILD=$(canon_path "$2"); then
1829                 fatal 1 "Could not determine the canonical location of $2"
1830             fi
1831             shift 2
1832             ;;
1833         --norpm)
1834             NORPM=true
1835             shift
1836             ;;
1837         --ldiskfs)
1838             LDISKFSRPM=true
1839             shift
1840             ;;
1841         --patchless)
1842             PATCHLESS=true
1843             shift
1844             ;;
1845         --kernelrpm)
1846             if ! KERNELRPMSBASE=$(canon_path "$2"); then
1847                 fatal 1 "Could not determine the canonical location of $2"
1848             fi
1849             shift 2
1850             ;;
1851         --timestamp)
1852             TIMESTAMP=$2
1853             shift 2
1854             ;;
1855         --lustre)
1856             if ! LUSTRE=$(canon_filepath "$2"); then
1857                 fatal 1 "Could not determine the canonical location of $2"
1858             fi
1859             shift 2
1860             ;;
1861         --nodownload)
1862             DOWNLOAD=false
1863             shift 1
1864             ;;
1865         --nosrc)
1866             DO_SRC=false
1867             shift 1
1868             ;;
1869         --ofed-version)
1870             OFED_VERSION="$2"
1871             shift 2
1872             ;;
1873         --publish)
1874             shift
1875             ;;
1876         --release)
1877             RELEASE=true
1878             shift
1879             ;;
1880         --src)
1881             DO_SRC=true
1882             shift 1
1883             ;;
1884         --stage)
1885             STAGEDIR=$2
1886             shift 2
1887             ;;
1888         --tag)
1889             TAG=$2
1890             shift 2
1891             ;;
1892         --target)
1893             TARGET=$2
1894             shift 2
1895             ;;
1896         --target-archs)
1897             TARGET_ARCHS=$2
1898             shift 2
1899             ;;
1900         --disable-datestamp)
1901             USE_DATESTAMP=
1902             shift
1903             ;;
1904         --xen)
1905             XEN=true
1906             shift
1907             ;;
1908         --set-value)
1909             eval $2
1910             shift 2
1911             ;;
1912         --enable-mptlinux)
1913             BUILD_MPTLINUX=true
1914             shift
1915             ;;
1916         --enable-rdac)
1917             BUILD_RDAC=true
1918             shift
1919             ;;
1920         --)
1921             shift
1922             # there are actually some lustre configure flags that we need to
1923             # handle ourselves (but we still give them to configure)
1924             if [[ \ $@\  == *\ --disable-tests\ * ]]; then
1925                 LUSTRE_TESTS=false
1926             fi
1927             CONFIGURE_FLAGS=$@
1928             CONFIGURE_FLAGS="$CONFIGURE_FLAGS --enable-liblustre --enable-liblustre-tests"
1929             break
1930             ;;
1931         *)
1932             usage 1 "Unrecognized option: $1"
1933             ;;
1934     esac
1935 done
1936
1937 check_options
1938
1939 unpack_lustre
1940
1941 # XXX - should we _always_ get the buildid from the META file?  what are the
1942 # other (i.e. non-lustre-tarball use cases of lbuild)?
1943 BUILDID=$(sed -ne '/^BUILDID =/s/.*= *//p' lustre/META)
1944
1945 load_target
1946
1947 if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
1948     download_ofed
1949     unpack_ofed || fatal 1 "Error unpacking OFED tarball"
1950 fi
1951
1952 if $BUILD_MPTLINUX && [ -n "$MPTLINUX_VERSION" -a "$MPTLINUX_VERSION" != "inkernel" ]; then
1953     unpack_mptlinux || fatal 1 "Error unpacking MPTLINUX distribution"
1954 fi
1955
1956 # make sure the RPM build environment is set up
1957 create_rpmbuild_dirs
1958
1959 if $BUILD_RDAC && [ -n "$RDAC_VERSION" -a "$RDAC_VERSION" != "inkernel" ]; then
1960     # we don't actually need to unpack this.  just put it in the SOURCES dir
1961     #unpack_rdac || fatal 1 "Error unpacking RDAC tarball"
1962     cp "$KERNELTREE/rdac-LINUX-${RDAC_VERSION}-source.tar.gz" ${TOPDIR}/SOURCES/ ||
1963         fatal 1 "Error copying RDAC source tarball to RPM SOURCES dir"
1964 fi
1965
1966 # if an unpacked kernel source tree was given on the command line
1967 # just build lustre with it (nothing distro kernel specific here)
1968 if [ -n "$LINUX" ]; then
1969     build_mptlinux "${LINUXOBJ:-$LINUX}" "$MPTLINUX_VERSION" ||
1970         fatal 1 "error building mptlinux"
1971     build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||
1972         fatal 1 "error building OFED"
1973     if ! $PATCHLESS; then
1974         build_rdac "${LINUXOBJ:-$LINUX}" "$RDAC_VERSION" ||
1975             fatal 1 "error building RDAC"
1976     fi
1977     build_lustre "$LINUX" "$LINUXOBJ"
1978 else
1979     if [ -f "${0%/*}/lbuild-$DISTRO" ]; then
1980         source ${0%/*}/lbuild-$DISTRO
1981
1982         build_with_srpm || fatal 1 "Failed to build_with_srpm"
1983     else
1984         EXTRA_VERSION_DELIMITER=${EXTRA_VERSION_DELIMITER:-"-"}
1985         source ${0%/*}/lbuild.old_school
1986
1987         old_school_download_kernel
1988
1989         build_success=false
1990         if $PATCHLESS; then
1991             patchless_build_sequence && build_success=true
1992         else
1993             [ "$DISTRO" = "sles9" ] && build_sequence_rpm_reuse && build_success=true
1994             if ! $build_success; then
1995                 build_sequence_reuse && build_success=true
1996                 if ! $build_success; then
1997                     build_sequence && build_success=true
1998                     if $build_success; then
1999                         store_for_reuse || echo "Cannot store for future reuse"
2000                     fi
2001                 fi
2002             fi
2003         fi
2004         ( $build_success ) || fatal 1 "Cannot build lustre"
2005     fi
2006 fi
2007
2008 stage