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