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     if [ -z "$DISTRO" ] ; then
 269         DISTRO=$(autodetect_distro)
 270         # remove minor version only for rhel and oel
 271         [[ $DISTRO =~ "el-" ]] && DISTRO=${DISTRO%%.*}
 272         # remove separator
 273         DISTRO=${DISTRO/-/}
 274     fi
 275
 276     if [ -z "$LINUX" ]; then
 277         [ "$KERNELDIR" -o "$KERNELTREE" ] || \
 278             usage 1 "A kernel directory must be specified with --kerneldir or --kerneltree."
 279
 280         [ -d "$KERNELDIR" -o -d "$KERNELTREE" ] || \
 281             usage 1 "$KERNELDIR and $KERNELTREE are not a directory."
 282
 283         [ "$TARGET" ] || TARGET=$(autodetect_target "$DISTRO")
 284 #       TARGET_FILE="$TOPDIR/lustre/kernel_patches/targets/$TARGET.target"
 285 #       [ -r "$TARGET_FILE" ] || \
 286 #               usage 1 "Target '$TARGET' was not found."
 287     fi
 288
 289     case $TARGET in
 290         2.6-rhel6)
 291             CANONICAL_TARGET="rhel6"
 292             ;;
 293         2.6-rhel5)
 294             CANONICAL_TARGET="rhel5"
 295             ;;
 296         2.6-rhel4)
 297             CANONICAL_TARGET="rhel-2.6"
 298             ;;
 299         2.6-suse)
 300             CANONICAL_TARGET="sles-2.6"
 301             ;;
 302         2.6-sles10)
 303             CANONICAL_TARGET="sles10-2.6"
 304             ;;
 305         2.6-sles11 | 3.0-sles11)
 306             CANONICAL_TARGET="sles11"
 307             ;;
 308         2.6-oel5)
 309             CANONICAL_TARGET="oel5"
 310             ;;
 311         hp_pnnl-2.4)
 312             CANONICAL_TARGET="hp-pnnl-2.4"
 313             ;;
 314         2.6-vanilla \
 315             | suse-2.4.21-2 \
 316             | rh-2.4 \
 317             | rhel-2.4 \
 318             | sles-2.4 \
 319             | 2.6-patchless)
 320                 CANONICAL_TARGET="$TARGET"
 321                 ;;
 322     esac
 323
 324     local timestampnodig=$(echo $TIMESTAMP | sed -e s/[0-9]*//g)
 325     [ "$timestampnodig" = "" ] || TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")
 326     local timestamplength="${#TIMESTAMP}"
 327     if [ $timestamplength -eq 12 ]; then
 328         TIMESTAMP="${TIMESTAMP}00"
 329     elif [ $timestamplength -ne 14 ]; then
 330         TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")
 331     fi
 332
 333     RPMBUILD=$(which rpmbuild 2>/dev/null | head -1)
 334     if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then
 335         RPMBUILD=$(which rpm 2>/dev/null | head -1)
 336         if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then
 337             usage 1 "Could not find binary for making rpms (tried rpmbuild and rpm)."
 338         fi
 339     fi
 340
 341     if [ -n "$CCACHE" ]; then
 342         which "$DISTCC" &>/dev/null && export DISTCC RPM_BUILD_NCPUS
 343
 344         if which "$CCACHE" &>/dev/null; then
 345             local ccache=$(which "$CCACHE")
 346             local bindir="$TOPDIR/bin"
 347
 348             if [ ! -d $bindir ]; then
 349                 mkdir -p $bindir || fatal 1 "error trying to create $bindir"
 350             else
 351                 rm ${bindir}/* > /dev/null 2>&1 || true
 352             fi
 353             ln -s "$ccache" ${bindir}/ccache
 354             ln -s "$ccache" ${bindir}/cc
 355             ln -s "$ccache" ${bindir}/$CC
 356             export PATH=$bindir:$PATH
 357             export CCACHE && export CC="ccache $CC"
 358             # zero the cache so we can see how effective we are being with it
 359             echo -n "ccache "
 360             ccache -z
 361
 362             # get some ccache stats when we are done
 363             push_exit_trap '[ -n "$CCACHE" ] && ccache -s' "ccache_summary"
 364             # should remove the ccache trap if lbuild is interrupted
 365             trap 'echo "Received an INT TERM or HUP signal, terminating."; delete_exit_trap "ccache_summary"; exit 1' INT TERM HUP
 366         fi
 367     fi
 368
 369     return 0
 370
 371 }
 372
 373 # compare two versions $1 and $2. if $1 < $2, return 0 otherwise return 1.
 374 compare_version () {
 375     [[ $1 == $2 ]] && return 1
 376     local IFS=.
 377     local i val1=($1) val2=($2)
 378
 379     # padding zero to val1 if it needs
 380     for ((i=${#val1[@]}; i<${#val2[@]}; i++)); do
 381         val1[i]=0
 382     done
 383     for ((i=0; i<${#val1[@]}; i++)); do
 384         [[ -z ${val2[i]} ]] && return 1
 385
 386         if [[ ${val1[i]} < ${val2[i]} ]]; then
 387             return 0
 388         elif [[ ${val1[i]} > ${val2[i]} ]]; then
 389             return 1
 390         fi
 391     done
 392 }
 393
 394 uniqify() {
 395
 396     echo $(echo "$*" | xargs -n 1 | sort -u)
 397
 398 }
 399
 400 fetch_url() {
 401     local url="$1"
 402     local target="$2"
 403
 404     if [ -z "$target" ]; then
 405         fatal 1 "fetch_url() called without a target to fetch to"
 406     fi
 407
 408     if [ -d $target ]; then
 409         target+="/${url##*/}"
 410     fi
 411
 412     local rc=0
 413     if which wget >/dev/null 2>&1; then
 414         if ! wget -nv "$url" -O "$target"; then
 415             rc=${PIPESTATUS[0]}
 416         fi
 417     elif which curl >/dev/null 2>&1; then
 418         if ! curl -n -L -s -o "$target" "$url"; then
 419             rc=${PIPESTATUS[0]}
 420         fi
 421     else
 422         fatal 1 "Could not find either wget or curl to fetch URLs."
 423     fi
 424
 425     return $rc
 426
 427 }
 428
 429 download_srpm() {
 430     local target=$1
 431     local srpm=$2
 432     local force="${3:-false}"
 433
 434     if $force || [ ! -r "$KERNELDIR/$srpm" ] ||
 435        [ ! -s "$KERNELDIR/$srpm" ]; then
 436         if $DOWNLOAD; then
 437             local location="http://downloads.lustre.org/public/kernels/$target/old"
 438             # get the location from a distro specific method if it exists
 439             if type -p kernel_srpm_location; then
 440                 location=$(kernel_srpm_location)
 441             fi
 442             echo "Downloading $location/$srpm..."
 443             if ! fetch_url "$location/$srpm" "$KERNELDIR/$srpm" 2>&1 ||
 444                [ ! -s "$KERNELDIR/$srpm" ]; then
 445                 rm -f $KERNELDIR/$srpm
 446                 # punt to a distro specific method if it exists
 447                 if ! type -p download_srpm-$DISTRO; then
 448                     fatal 1 "Could not download target $target's kernel SRPM $srpm from $location."
 449                 else
 450                     if ! download_srpm-$DISTRO "$target" "$srpm" "$force"; then
 451                         fatal 1 "Could not download target $target's kernel SRPM $srpm using download_srpm-$DISTRO."
 452                     fi
 453                 fi
 454             fi
 455         else
 456             fatal 1 "$srpm not found in directory $KERNELDIR."
 457         fi
 458     fi
 459
 460 }
 461
 462 download_file() {
 463     local from="$1"
 464     local to="$2"
 465     local force="$3"
 466
 467     local file=${from##*/}
 468
 469     if [ -d $to ]; then
 470         to="$to/$file"
 471     fi
 472
 473     local semaphore="$to-downloading"
 474
 475     is_downloading() {
 476         if [ ! -f $semaphore ]; then
 477             return 1
 478         fi
 479
 480         # make sure the download has not been aborted
 481         local now=$(date +%s)
 482         local file_mtime=$(stat -c %Y "$to")
 483         local staleness=$((now - file_mtime))
 484         # let's assume an active download will write at least once a minute
 485         if [ $staleness -gt 60 ]; then
 486             return 1
 487         fi
 488
 489         return 0
 490     }
 491
 492     is_downloaded() {
 493         # if the semaphore file exists, the file is either still downloading
 494         # or a download was aborted and we cannot trust the target file
 495         if [ -f $semaphore ]; then
 496             return 1
 497         fi
 498
 499         if ! is_downloading && [ -r "$to" ] && [ -s "$to" ]; then
 500             return 0
 501         fi
 502
 503         return 1
 504     }
 505
 506     if $force || ! is_downloaded; then
 507         if is_downloading; then
 508             echo "Somebody else is downloading $from..."
 509             while is_downloading; do
 510                 echo "Waiting for $to to finish downloading"
 511                 sleep 60
 512             done
 513             if is_downloaded; then
 514                 return 0
 515             else
 516                 echo "The download we were waiting for seems to have been aborted"
 517             fi
 518
 519         fi
 520
 521         if $DOWNLOAD; then
 522             echo "Downloading $from..."
 523             # flag others so they don't try to download also
 524             push_exit_trap "rm -f $to $semaphore" "download"
 525             touch $semaphore
 526             if ! fetch_url "$from" "$to" || [ ! -s "$to" ]; then
 527                 # the trap will remove the files via the fatal below
 528                 fatal 1 "Could not download ${to##*/} from ${from%/*}/."
 529             fi
 530             rm -f $semaphore
 531             delete_exit_trap "download"
 532         else
 533             fatal 1 "${to##*/} not found in directory ${to%/*}."
 534         fi
 535     fi
 536
 537     return 0
 538
 539 }
 540
 541 download_ofed() {
 542     local force="${1:-false}"
 543
 544     if [ -z "$OFED_VERSION" -o "$OFED_VERSION" = "inkernel" ]; then
 545         return 0
 546     fi
 547
 548     local OFED_BASE_VERSION=$OFED_VERSION
 549     if [[ $OFED_VERSION = *.*.*.* ]]; then
 550         OFED_BASE_VERSION=${OFED_VERSION%.*}
 551     fi
 552
 553     local location="http://www.openfabrics.org/downloads/OFED/ofed-${OFED_BASE_VERSION}/"
 554
 555     if [[ $OFED_VERSION = *-[rR][cC][0-9] ]]; then
 556         local Mmv
 557         Mmv=${OFED_VERSION%%-[rR][cC][0-9]}
 558         location="http://www.openfabrics.org/downloads/OFED/ofed-${Mmv}/"
 559     fi
 560
 561     if [[ $OFED_VERSION = daily-* ]]; then
 562         local Mmv daily
 563         OFED_VERSION=${OFED_VERSION/daily-/}
 564         Mmv=${OFED_VERSION%%-*}
 565         daily=${OFED_VERSION##$Mmv-}
 566         location="http://www.openfabrics.org/downloads/OFED/ofed-${Mmv}-daily/"
 567         # find the filename for the version for the date specified
 568         OFED_VERSION=$(curl -s "$location" | sed -nre "/${daily}-/s/.*href=\"OFED-(${Mmv//./\\.}-${daily}-[0-9]{4,4}).tgz.*$/\1/p" | tail -1)
 569         if [ -z "$OFED_VERSION" ]; then
 570             fatal 1 "Could not determine the filename of the OFED snapshot for ${daily}"
 571         fi
 572     fi
 573
 574     local file="OFED-${OFED_VERSION}.tgz"
 575     download_file "$location/$file" "$KERNELTREE" "$force"
 576
 577 }
 578
 579 parse_mpss_info() {
 580     local file="$1"
 581     local build="$2"
 582     local distro="$3"
 583
 584     [ -r "$file" ] || fatal 1 "Could not find MPSS info file"
 585
 586     # convert to MPSS distro naming
 587     distro=${distro/sles/suse}
 588     distro_name=${distro%%-*}
 589
 590     # extract links from MPSS info file
 591     local urls=$(cat "$file" | \
 592         tr -d '\t\r\n' | sed -e 's?\(</[a-zA-Z]*>\)?\1\n?g' | \
 593         grep '.intel.com/' | \
 594         sed -e 's/^.*[hH][rR][eE][fF]="\([^>"]\+\)".*$/\1/g' | \
 595         grep '.tar')
 596     local res2=""
 597     local res3=""
 598     for url in $urls; do
 599         local ver2=""
 600         local ver3=""
 601         # Try to match with MPSS 3.x or 3.x.x distro package
 602         if [[ $url =~ mpss-[0-9].[0-9](.[0-9]*)?-$distro.tar ]]; then
 603             ver3=${url##*mpss-}
 604             ver3=${ver3%%-$distro.tar}
 605         # Try to match with MPSS 3.x or 3.x.x source package
 606         elif [[ $url =~ mpss-src-[0-9].[0-9](.[0-9]*)?.tar ]]; then
 607             ver3=${url##*mpss-src-}
 608             ver3=${ver3%%.tar}
 609         # Try to match with MPSS 3.x or 3.x.x cross compiler package
 610         elif [[ $url =~ mpss-[0-9].[0-9](.[0-9]*)?-k1om.tar ]]; then
 611             ver3=${url##*mpss-}
 612             ver3=${ver3%%-k1om.tar}
 613         # Try to match with MPSS 2.1.x source package
 614         elif [[ $url =~ _src-[0-9].[0-9].[0-9]*-[0-9]*_$distro_name.tar ]]; then
 615             ver2=${url##*_src-}
 616             ver2=${ver2%%_$distro_name.tar}
 617         fi
 618
 619         if [ -n "$ver3" ]; then
 620             # Check for MPSS 3.x or MPSS 3.x.x
 621             if [[ $ver3 =~ [0-9].[0-9].[0-9]* ]]; then
 622                 ver3="${ver3}-0"
 623             else
 624                 ver3="${ver3}.0-0"
 625             fi
 626             if [ -z "$build" ]; then
 627                 res3="$ver3"
 628             elif [ "$build" = "$ver3" ]; then
 629                 res3="$res3 $url"
 630             fi
 631         elif [ -n "$ver2" ]; then
 632             if [ -z "$build" ]; then
 633                 res2="$ver2"
 634             elif [ "$build" = "$ver2" ]; then
 635                 res2="$res2 $url"
 636             fi
 637         fi
 638
 639     done
 640
 641     if [ -z "$build" ]; then
 642         # return a last version of MPSS
 643         if [ -n "$res3" ]; then
 644             echo "$res3"
 645         else
 646             echo "$res2"
 647         fi
 648     elif [ "${build%%.*}" = "3" ]; then
 649         local ver=${build%%-*}
 650         local bid=${build##*-}
 651         if [ $bid -eq 0 ]; then
 652             # return URLs from MPSS info file
 653             echo "$res3"
 654         else
 655             # Check for MPSS 3.x or MPSS 3.x.x
 656             if [ ${ver##*.} -eq 0 ]; then
 657                 ver=${ver%.*}
 658             fi
 659             # return URLs from internal site with MPSS builds
 660             # kernel sources:
 661             echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-src-$ver.tar"
 662             # kernel configs:
 663             echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-$ver-k1om.tar"
 664             # OFED headers:
 665             echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-$ver-$distro.tar"
 666         fi
 667     else
 668         # return URLs from MPSS info file
 669         echo "$res2"
 670     fi
 671 }
 672
 673 # Get public information about last releases of
 674 # Intel Manycore Platform Software Stack (MPSS)
 675 download_mpss_info() {
 676     local file="$1"
 677     local force="${2:-true}"
 678     local url=${MPSS_URL:-"http://software.intel.com/en-us/articles/intel-manycore-platform-software-stack-mpss"}
 679
 680     download_file "$url" "$file" "$force"
 681 }
 682
 683 download_mpss() {
 684     local file="$1"
 685     local force="${2:-false}"
 686     local urls=$(parse_mpss_info "$file" ${MPSS_VERSION} ${MPSS_DISTRO})
 687
 688     [ -z "$urls" ] && fatal 1 "Could not determine the URLs of MPSS $MPSS_VERSION"
 689
 690     # force re-download if build number is zero
 691     [[ $MPSS_VERSION = [0-9].[0-9].[0-9]*-0 ]] && force=true
 692
 693     local url
 694     local i=0
 695     for url in $urls; do
 696         file="$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part$i.tar"
 697         download_file "$url" "$file" "$force"
 698         i=$((i+1))
 699     done
 700 }
 701
 702 load_target() {
 703
 704     EXTRA_VERSION_save="$EXTRA_VERSION"
 705     for patchesdir in "$EXTERNAL_PATCHES" \
 706                       "$TOPDIR/lustre/lustre/kernel_patches"; do
 707         TARGET_FILE="$patchesdir/targets/$TARGET.target"
 708         [ -r "$TARGET_FILE" ] && break
 709     done
 710     [ -r "$TARGET_FILE" ] || fatal 1 "Target $TARGET was not found."
 711
 712     echo "Loading target config file $TARGET.target..."
 713
 714     # if the caller specified an OFED_VERSION it should override whatever
 715     # the target file specifies
 716     local env_OFED_VERSION="$OFED_VERSION"
 717
 718     . "$TARGET_FILE"
 719
 720     if [ -n "$env_OFED_VERSION" ]; then
 721         OFED_VERSION="$env_OFED_VERSION"
 722     fi
 723
 724     # doesn't make any sense to build OFED for xen domX's
 725     if $XEN; then
 726         OFED_VERSION=""
 727     fi
 728
 729     # XXX - set_rpm_smp_type is an ugly undeterministic hack.  it needs to
 730     #       go away and the target just specify the $RPMSMPTYPE
 731     [ -z "$RPMSMPTYPE" ] && set_rpm_smp_type
 732
 733     # CC might have been overwriten in TARGET_FILE
 734     if [[ $CC != ccache\ * ]] && which "$CCACHE" &>/dev/null; then
 735         export CCACHE && export CC="ccache $CC"
 736     fi
 737
 738     if [ ! "$KERNELTREE" = "" ] && [ -d "$KERNELTREE" ]; then
 739         KERNELDIR="$KERNELTREE/${lnxmaj}"
 740         [ -d "$KERNELDIR" ] || mkdir "$KERNELDIR"
 741     fi
 742
 743     # verify the series is available
 744     if [ "$SERIES" ]; then
 745         for series in $SERIES; do
 746             for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do
 747                 [ -r "$patchesdir/series/$series" ] && continue 2
 748             done
 749             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."
 750         done
 751     fi
 752
 753     # set the location of the .config file
 754     local XENPOSTFIX=""
 755     if $XEN; then
 756         XENPOSTFIX="-xen"
 757     fi
 758
 759     if [ -f $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET-$TARGET_ARCH.config ]; then
 760         CONFIG_FILE="$TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET$XENPOSTFIX-$TARGET_ARCH.config"
 761     fi
 762
 763     local lnxrelnew=${lnxrel//-/_}
 764
 765     # remember the EXTRA_VERSION before we diddle it here
 766     # XXX - we really should not diddle with any values read in from the
 767     #       target file.  if we want to modify a value, we should create
 768     #       a new variable.
 769     PRISTINE_EXTRA_VERSION=$EXTRA_VERSION
 770
 771     if ! $PATCHLESS && [ ! -f "$CONFIG_FILE" ]; then
 772         fatal 1 "Config file for target $TARGET missing from $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/."
 773     fi
 774
 775     if [ "$EXTRA_VERSION_save" ]; then
 776         EXTRA_VERSION="$EXTRA_VERSION_save"
 777     elif ! $RELEASE; then
 778         # if there is no patch series, then this is not a lustre specific
 779         # kernel.  don't make it look like one
 780         if $PATCHLESS || [ -n "$SERIES" ]; then
 781             EXTRA_VERSION=$(echo $EXTRA_VERSION | sed -e "s/\(.*_lustre\)\..*/\1/")
 782             if ! $PATCHLESS && [ -n "$BUILDID" ]; then
 783                 EXTRA_VERSION="${EXTRA_VERSION}.${BUILDID}"
 784             fi
 785         fi
 786     fi
 787     # EXTRA_VERSION=${EXTRA_VERSION//-/_}
 788
 789     ALL_ARCHS="$BASE_ARCHS $BIGMEM_ARCHS $BOOT_ARCHS $JENSEN_ARCHS $SMP_ARCHS $BIGSMP_ARCHS $PSERIES64_ARCHS $UP_ARCHS"
 790
 791     BUILD_ARCHS=
 792     for arch in $(uniqify "$ALL_ARCHS"); do
 793         if [ -z "$TARGET_ARCHS" ] ||
 794            [[ \ $TARGET_ARCHS\  = *\ $arch\ * ]]; then
 795             BUILD_ARCHS="$BUILD_ARCHS $arch"
 796         fi
 797     done
 798     [ "$BUILD_ARCHS" ] || usage 1 "No available target archs to build."
 799     echo "Building for: $BUILD_ARCHS"
 800 }
 801
 802 tarflags() {
 803     local file="$1"
 804
 805     case "$file" in
 806         '')
 807             fatal 1 "tarflags(): File name argument missing."
 808             ;;
 809         *.tar.gz | *.tgz)
 810             echo 'zxf'
 811             ;;
 812         *.tar.bz2)
 813             echo 'jxf'
 814             ;;
 815         *.tar)
 816             echo 'xf'
 817             ;;
 818         *)
 819             fatal 1 "tarflags(): Unrecognized tar extension in file: $1"
 820             ;;
 821     esac
 822
 823 }
 824
 825 untar() {
 826     local tarfile="$1"
 827     shift
 828     local extractfile="$@"
 829
 830     echo "Untarring ${tarfile##*/}..."
 831     tar $(tarflags "$tarfile") "$tarfile" $extractfile
 832
 833 }
 834
 835 unpack_ofed() {
 836
 837     if ! untar "$KERNELTREE/OFED-${OFED_VERSION}.tgz"; then
 838         return 1
 839     fi
 840     [ -d OFED ] || ln -sf OFED-[0-9].[0-9]* OFED
 841
 842 }
 843
 844 unpack_lustre() {
 845
 846     untar "$LUSTRE" || fatal 1 "Error unpacking Lustre tarball"
 847     [ -d lustre ] || ln -sf lustre-[0-9].[0-9]* lustre
 848
 849 }
 850
 851 unpack_mpss() {
 852
 853     [ -d mpss ] && return 0
 854
 855     if [ "${MPSS_VERSION%%.*}" = "3" ]; then
 856         local ver=${MPSS_VERSION%%-*}
 857         local file
 858         local i
 859         # Check for MPSS 3.x or MPSS 3.x.x
 860         if [ ${ver##*.} -eq 0 ]; then
 861             ver=${ver%.*}
 862         fi
 863         for i in $(seq 0 9); do
 864             file="$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part$i.tar"
 865             if [ -r "$file" ]; then
 866                 untar "$file" \
 867                     "mpss-$ver/*/linux-*.tar.bz2" \
 868                     "mpss-$ver/*/kernel-dev-*.rpm" \
 869                     "mpss-$ver/*/ofed-driver-*-devel-*.rpm"
 870             fi
 871         done
 872         # Extract kernel configs
 873         file=$(find mpss-$ver -type f -path "*/kernel-dev-*.rpm")
 874         if ! rpm2cpio "$file" | cpio -idm; then
 875             echo "Error extracting MPSS kernel configs"
 876             return 1
 877         fi
 878         # Unpack kernel sources
 879         file=$(find mpss-$ver -type f -path "*/linux-*.tar.bz2")
 880         if ! untar "$file"; then
 881             echo "Error unpacking MPSS kernel sources"
 882             return 1
 883         fi
 884         # Extract OFED headers
 885         file=$(find mpss-$ver -type f -path "*/ofed-driver-*-devel-*.rpm")
 886         if ! rpm2cpio "$file" | cpio -idm; then
 887             echo "Error extracting MPSS OFED headers"
 888             return 1
 889         fi
 890         # Remove unpacked archives to save space
 891         rm -rf mpss-$ver
 892         # Make link to MPSS kernel sources
 893         ln -sf linux-* mpss
 894     else
 895         local dir="mpss-${MPSS_VERSION}-${MPSS_DISTRO%%-*}"
 896
 897         mkdir $dir || return 255
 898         pushd $dir >/dev/null || return 255
 899         if ! untar "$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part0.tar" "*/gpl/*full_src*"; then
 900             popd >/dev/null
 901             rm -rf $dir
 902             echo "Error unpacking MPSS tarball 1"
 903             return 1
 904         fi
 905         local file=$(find . -type f -path "*/gpl/*full_src*")
 906         if ! untar "$file"; then
 907             popd >/dev/null
 908             rm -rf $dir
 909             echo "Error unpacking MPSS tarball 2"
 910             return 1
 911         fi
 912         popd >/dev/null
 913         ln -sf $dir mpss
 914     fi
 915
 916 }
 917
 918 do_patch_linux() {
 919
 920     local do_patch=${1:-true}
 921
 922     FULL_PATCH="$PWD/lustre-kernel-${TARGET}-${EXTRA_VERSION}.patch"
 923     [ -f "$FULL_PATCH" ] && rm -f "$FULL_PATCH"
 924     $do_patch && pushd linux >/dev/null
 925     for series in $SERIES; do
 926         echo -n "Applying series $series:"
 927         for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do
 928             [ -r "$patchesdir/series/$series" ] || continue
 929             SERIES_FILE="$patchesdir/series/$series"
 930             for patch in $(<"$SERIES_FILE"); do
 931                 echo -n " $patch"
 932                 PATCH_FILE="$patchesdir/patches/$patch"
 933                 [ -r "$PATCH_FILE" ] || \
 934                     fatal 1 "Patch $patch does not exist in Lustre tree."
 935                 cat "$PATCH_FILE" >> "$FULL_PATCH" || {
 936                     rm -f $FULL_PATCH
 937                     fatal 1 "Error adding patch $patch to full patch."
 938                 }
 939                 if $do_patch; then
 940                     patch -s -p1 < "$PATCH_FILE" 2>&1 || {
 941                         rm -f $FULL_PATCH
 942                         fatal 1 "Error applying patch $patch."
 943                     }
 944                 fi
 945             done
 946             break
 947         done
 948         echo
 949     done
 950     $do_patch && popd >/dev/null
 951     echo "Full patch has been saved in ${FULL_PATCH##*/}."
 952
 953 }
 954
 955 build_lustre() {
 956     local linux="$1"
 957     local linuxobj="$2"
 958
 959     cp "$LUSTRE" SOURCES
 960
 961     pushd lustre >/dev/null
 962
 963     echo "Building Lustre RPMs for: $BUILD_ARCHS..."
 964     local targets arch
 965     for arch in $BUILD_ARCHS; do
 966         targets="--target $arch $targets"
 967     done
 968
 969     local confoptions=""
 970
 971     if $PATCHLESS; then
 972         confoptions="$confoptions --disable-server"
 973     fi
 974
 975     local rpmbuildopt='-tb'
 976     if $NORPM; then
 977         rpmbuildopt='-tc'
 978         echo NORPM mode. Only compiling.
 979     fi
 980
 981     # If server we now build the spl and zfs modules against the lustre kernel.
 982     # These are required prior to the building of lustre server. Client does
 983     # not require spl/zfs. Use !PATCHLESS to indicate server which follows the
 984     # line above so is at least consistant.
 985     if [ $PATCHLESS == false ] && [ "x$ZFSNOTSUPPORTED" == "x" ]; then
 986         if ! build_spl_zfs; then
 987             popd >/dev/null # pushd lustre
 988             return 255
 989         fi
 990     fi
 991
 992     if $PATCHLESS; then
 993         RPMBUILD_DEFS="$RPMBUILD_DEFS --without servers"
 994         if [ -n "$CROSS_SUFFIX" ]; then
 995             RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"lustre_name lustre-client$CROSS_SUFFIX\""
 996         fi
 997     fi
 998
 999     # ditto for the lustre-tests boolean
1000     if ! $LUSTRE_TESTS; then
1001         RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_tests"
1002     fi
1003
1004     if ! $IOKITRPM; then
1005         RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_iokit"
1006     fi
1007
1008     local osd_zfs=""
1009     if $OSDZFSRPM; then
1010         osd_zfs="yes"
1011     fi
1012
1013     local osd_ldiskfs=""
1014     if $OSDLDISKFSRPM; then
1015         osd_ldiskfs="yes"
1016     fi
1017
1018     RPMBUILD_DEFS="$RPMBUILD_DEFS ${FIND_REQUIRES:+--define \"__find_requires $FIND_REQUIRES\"}"
1019     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"configure_args $confoptions ${CONFIGURE_FLAGS}\""
1020     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"kdir $linux\""
1021     RPMBUILD_DEFS="$RPMBUILD_DEFS ${linuxobj:+--define \"kobjdir $linuxobj\"}"
1022     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_tmppath $TMPDIR\""
1023     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_topdir $TOPDIR\""
1024
1025     eval $RPMBUILD $targets $rpmbuildopt "$LUSTRE" $RPMBUILD_DEFS \
1026         ${osd_zfs:+--with zfs} \
1027         ${osd_ldiskfs:+--with ldiskfs} 2>&1 || \
1028         fatal 1 "Error building rpms for $BUILD_ARCHS."
1029
1030     if $DO_SRC; then
1031         if ! eval $RPMBUILD -ts "$LUSTRE" $RPMBUILD_DEFS 2>&1; then
1032             popd >/dev/null
1033             return 255
1034         fi
1035     fi
1036     popd >/dev/null
1037
1038 }
1039
1040 ###
1041 # build_spl_zfs
1042 #
1043 # Fetch spl/zfs from the git repo and prepare for lustre build
1044 #
1045 # Overrides:
1046 #   SPLZFSGITREPO - URI of directory where spl.git and zfs.git are located
1047 #   SPLZFSTAG     - Tag to checkout of clone repositories
1048 #   SPLZFSVER     - Version to checkout of both (format zfs/spl-$SPLZFSVER)
1049 #
1050 # return 0 if successful, else 255
1051 build_spl_zfs() {
1052     # make sure the RPM build environment is set up
1053     pushd $TOPDIR
1054     create_rpmbuild_dirs
1055     popd
1056
1057     # The spl/zfs spec files expect RPM_BUILD_ROOT to point to the root of the
1058     # destination for the rpms
1059     export RPM_BUILD_ROOT=$TOPDIR
1060     SPLZFSVER=${SPLZFSVER:-0.6.2}
1061     SPLZFSTAG=${SPLZFSTAG:-upstream-master}
1062
1063     # The files expect a kver to be set to the kernel version .
1064     local kver=$(find_linux_release)
1065
1066     # build and install the spl and zfs (and -devel) RPMs for lustre to use
1067     local pkg
1068     for pkg in spl zfs; do
1069
1070         local rpmpkg
1071
1072         [ "$pkg" == "zfs" ] && spldir="$(ls -d $TOPDIR/usr/src/spl-*/|tail -1)"
1073
1074         # need to fetch the repo in order to build it.
1075         # default to github but allow override
1076         git clone ${SPLZFSGITREPO:-"https://github.com/zfsonlinux"}/$pkg.git $pkg 2>&1
1077
1078         pushd $pkg || return 255
1079         if [ -n "$SPLZFSTAG" ]; then
1080             git checkout $SPLZFSTAG
1081         else
1082             git checkout -b lbuild $pkg-$SPLZFSVER
1083         fi
1084
1085         # This differentiates between older zfs versions
1086         if [ -f $pkg-modules.spec.in ]; then
1087             rpmpkg=$pkg-modules
1088             specdir=.
1089             speclist="$pkg.spec $rpmpkg.spec"
1090         else
1091             rpmpkg=kmod-$pkg-devel
1092             specdir=rpm/generic
1093             speclist="$pkg.spec $pkg-kmod.spec $pkg-dkms.spec"
1094         fi
1095
1096         sh autogen.sh || return 255
1097
1098         if  ! ./configure --with-linux=${LINUX} --with-linux-obj=${LINUXOBJ:-$LINUX} \
1099                           ${spldir:+--with-spl="${spldir}"} 2>&1 ||
1100             ! make dist 2>&1; then
1101             popd
1102             return 255
1103         fi
1104         popd
1105
1106         ln -f $pkg/$pkg-*.tar.gz $TOPDIR/SOURCES ||
1107            error "failed to link $pkg/$pkg-*.tar.gz into $TOPDIR/SOURCES"
1108         if [ -f $pkg/scripts/kmodtool ]; then
1109             ln -f $pkg/scripts/kmodtool $TOPDIR/SOURCES/
1110         fi
1111
1112         local rpmb
1113         if $DO_SRC; then
1114             rpmb=-ba
1115         else
1116             rpmb=-bb
1117         fi
1118
1119         # set search dir for our own kmodtool to find correct
1120         # directories
1121         export KERNELSOURCE=$(dirname ${LINUX})
1122         # Manually build rpms
1123         for spec in $speclist; do
1124             echo "Building RPMs from $pkg/$specdir/$spec"
1125             if ! $RPMBUILD $rpmb $pkg/$specdir/$spec \
1126                 --nodeps -v \
1127                 --define "require_kdir ${LINUX}" \
1128                 ${LINUXOBJ:+--define "require_kobj ${LINUXOBJ}"} \
1129                 ${spldir:+--define "require_spldir ${spldir}"} \
1130                 --define "kver $kver" \
1131                 --define "kernels $kver" \
1132                 --define "_tmppath /var/tmp" \
1133                 --define "kernelbuildroot $TOPDIR/reused" \
1134                 --define "_topdir $TOPDIR" 2>&1; then
1135                 return 255
1136             fi
1137         done
1138
1139         # We have built the rpms for the package. Now we need to extract the
1140         # contained files so we can build further things against them
1141         local rpms=$(ls -1 $TOPDIR/RPMS/*/$rpmpkg-*.rpm)
1142
1143         # cpio only extract to pwd so we need to go there.
1144         pushd $TOPDIR
1145         local rpm
1146         for rpm in $rpms; do
1147             rpm2cpio $rpm | cpio -id
1148         done
1149
1150         if [ "$pkg" == "zfs" ]; then
1151             # We also need to extract both the zfs and zfs-devel rpms
1152             # the zfs rpm is needed because it has the actual libraries in
1153             # it and the zfs-devel rpm only has unversioned symlinks to the
1154             # libraries in the zfs rpm
1155             # this will all change one day when we have a libzfs rpm per
1156             # https://github.com/zfsonlinux/zfs/issues/2329
1157             # and it looks like it could be one day soon:
1158             # https://github.com/zfsonlinux/zfs/pull/2341
1159             local devel_rpms=$(ls -1 $TOPDIR/RPMS/*/{$pkg-devel,$pkg-$SPLZFSVER}-*.rpm)
1160             for rpm in $devel_rpms; do
1161                 rpm2cpio $rpm | cpio -id
1162             done
1163             CONFIGURE_FLAGS="--with-$pkg-devel=$TOPDIR ${CONFIGURE_FLAGS}"
1164         fi
1165         popd
1166
1167         CONFIGURE_FLAGS="--with-$pkg=$(ls -d $TOPDIR/usr/src/$pkg-*/|tail -1) ${CONFIGURE_FLAGS}"
1168         CONFIGURE_FLAGS="--with-$pkg-obj=$(ls -d $TOPDIR/usr/src/$pkg-*/$kver*|tail -1) ${CONFIGURE_FLAGS}"
1169     done
1170
1171     OSDZFSRPM=true
1172
1173     return 0
1174 }
1175
1176 prepare_mpss() {
1177
1178     pushd mpss >/dev/null || return 255
1179     if [ "${MPSS_VERSION%%.*}" = "3" ]; then
1180         cp -f ../boot/config-* .config
1181         if ! make ARCH=k1om silentoldconfig ; then
1182             popd >/dev/null
1183             return 1
1184         fi
1185         if ! make ARCH=k1om modules_prepare ; then
1186             popd >/dev/null
1187             return 1
1188         fi
1189         cp -f ../boot/Module.symvers-* Module.symvers
1190     else
1191         if ! make defconfig-miclinux; then
1192             popd >/dev/null
1193             return 1
1194         fi
1195         if ! make -C card/kernel ARCH=k1om modules_prepare ; then
1196             popd >/dev/null
1197             return 1
1198         fi
1199     fi
1200     popd >/dev/null
1201
1202 }
1203
1204 stage() {
1205
1206     [ "$STAGEDIR" ] || return 0
1207
1208     for arch in $BUILD_ARCHS; do
1209         rpmdir="${STAGEDIR}/${CANONICAL_TARGET}-${arch}"
1210         echo "${0##*/}: Copying RPMs into ${rpmdir}"
1211         mkdir -p "${rpmdir}"
1212         cp -v RPMS/${arch}/*.rpm "${rpmdir}"
1213         if [ -d RPMS/noarch ]; then
1214             cp -v RPMS/noarch/*.rpm "${rpmdir}"
1215         fi
1216     done
1217
1218     cp -v "$LUSTRE" "$STAGEDIR"
1219
1220 }
1221
1222 set_rpm_smp_type() {
1223
1224     local infact_arch="${TARGET_ARCH}"
1225
1226     RPMSMPTYPE=""
1227     [ "$infact_arch" == "i586" ] && infact_arch="i686"
1228
1229     local smp_type
1230     for smp_type in $SMP_ARCHS; do
1231         [ $infact_arch == $smp_type ] && RPMSMPTYPE=smp && break
1232     done
1233
1234     for smp_type in $BIGSMP_ARCHS; do
1235         [ $infact_arch == $smp_type ] && RPMSMPTYPE=bigsmp && break
1236     done
1237
1238     for smp_type in $PPC64_ARCHS; do
1239         [ $infact_arch == $smp_type ] && RPMSMPTYPE=ppc64 && break
1240     done
1241
1242     for smp_type in $DEFAULT_ARCHS; do
1243         [ $infact_arch == $smp_type ] && RPMSMPTYPE=default && break
1244     done
1245
1246 }
1247
1248 # This function takes a linux include tree and digs out the linux release
1249 # from it. It is never called directly, only called from the distro
1250 # specific function find_linux_release() in lbuild-{rhel,sles}.
1251 _find_linux_release() {
1252     local SRC="$1"
1253     local LINUXRELEASEHEADER=""
1254
1255     LINUXRELEASEHEADER=$SRC/include/linux/version.h
1256     if [ -s $SRC/include/generated/utsrelease.h ]; then
1257         LINUXRELEASEHEADER=$SRC/include/generated/utsrelease.h
1258     elif [ -s $SRC/include/linux/utsrelease.h ]; then
1259         LINUXRELEASEHEADER=$SRC/include/linux/utsrelease.h
1260     fi
1261
1262     if [ ! -s $LINUXRELEASEHEADER ]; then
1263         fatal 1 "could not find UTS_RELEASE"
1264     fi
1265
1266     sed -ne 's/#define UTS_RELEASE "\(.*\)"$/\1/p' $LINUXRELEASEHEADER
1267 }
1268
1269 # unpack kernel(/source/devel) RPM
1270 #
1271 # This function and it's setting of $LINUX and $LINUXOBJ is a total hack that
1272 # needs to completely refactored.  It completely ingores that $BUILD_ARCHS may
1273 # contain a list of arches for which rpmbuild commands (including the one for
1274 # lustre itself)
1275 unpack_linux_devel_rpm() {
1276     local kernelrpm="${1}"
1277
1278     [ -f "$kernelrpm" ] || return 255
1279     [ -d $TOPDIR/reused ] || mkdir $TOPDIR/reused || return 255
1280
1281     pushd $TOPDIR/reused &>/dev/null || return 255
1282
1283     if ! rpm2cpio < "$kernelrpm" | cpio -id > /dev/null 2>&1; then
1284         return 255
1285     fi
1286
1287     # call a distro specific hook, if available
1288     if type -p unpack_linux_devel_rpm-$DISTRO; then
1289         if ! unpack_linux_devel_rpm-$DISTRO "$kernelrpm"; then
1290             return 255
1291         fi
1292     fi
1293
1294     popd &>/dev/null
1295
1296     find_linux_devel_paths $TOPDIR/reused
1297
1298     return 0
1299
1300 }
1301
1302 build_kernel_ib() {
1303     local linux="$1"
1304     local kib_prefix="$2"
1305     local kib_rpm="$3"
1306
1307     # build kernel-ib{,-devel}/compat-rdma{,-devel}
1308     local K_SRC="K_SRC"
1309     # ofed 1.3 had a bug in the rpm spec
1310     if [ "$OFED_VERSION" = "1.3" ]; then
1311         K_SRC="KSRC"
1312     fi
1313
1314     local OFED_CORE="--with-core-mod --with-ipoib-mod --with-sdp-mod --with-user_mad-mod --with-user_access-mod --with-addr_trans-mod"
1315     local OFED_HARDWARE="--with-mthca-mod --with-mlx4-mod --with-mlx4_en-mod --with-cxgb3-mod --with-nes-mod"
1316
1317     if compare_version $OFED_VERSION 3.0; then
1318         OFED_CORE="$OFED_CORE --with-madeye-mod --with-rds-mod"
1319     else
1320         OFED_HARDWARE="$OFED_HARDWARE --with-cxgb4-mod"
1321     fi
1322
1323     # some I/B drivers are architecture dependent and kernel-ib's configure
1324     # does not figure it out for us ~sigh~
1325     case "$TARGET_ARCH" in
1326         ppc64)
1327             OFED_HARDWARE="$OFED_HARDWARE --with-ehca-mod"
1328             ;;
1329     esac
1330     # we're no longer shipping the OFED iSCSI target
1331     #OFED_ISCSI="--with-srp-mod --with-srp-target-mod"
1332     OFED_ISCSI="--with-srp-mod"
1333     ## ISER module has no backport support as of OFED 1.5 (i.e. only builds on
1334     ##kernels >= 2.6.30)
1335     #if [[ $OFED_VERSION = 1.[0-4]* ]]; then
1336     #   OFED_ISCSI="$OFED_ISCSI --with-iser-mod"
1337     #fi
1338
1339     # assume we are just rebuilding the SRPM
1340     local BUILD_TYPE=${BUILD_TYPE:-"--rebuild"}
1341     local SOURCE="${TOPDIR}/OFED/SRPMS/${kib_prefix}-*.src.rpm"
1342
1343     # but switch to building from the SPEC if we need to apply patches
1344     if ls ${TOPDIR}/lustre/contrib/patches/ofed/* >/dev/null; then
1345         BUILD_TYPE="-bb"
1346         rpm --define "_topdir ${TOPDIR}" -ivh $SOURCE
1347         SOURCE="${TOPDIR}/SPECS/${kib_prefix}.spec"
1348         local file ed_fragment1 ed_fragment2 n=1
1349         for file in $(ls ${TOPDIR}/lustre/contrib/patches/ofed/*.patch); do
1350             ed_fragment1="$ed_fragment1
1351 Patch$n: ${file%%*/}"
1352             ed_fragment2="$ed_fragment2
1353 %patch$n -p0"
1354             cp $file ${TOPDIR}/SOURCES
1355             let n=$n+1
1356         done
1357         for file in $(ls ${TOPDIR}/lustre/contrib/patches/ofed/*.ed); do
1358             # Only apply the ed-scripts that should be used for the canonical target
1359             # ed-files in ${TOPDIR}/lustre/contrib/patches/ofed/ have to follow the naming
1360             # convention
1361             # <two-digits>-<descriptive-name>:<canonical_target_1>: ...:<canonical_target_N>.ed
1362             # To apply the same change to multiple canonical target simply specify
1363             # a list of colon separated canoncial target names in the file name.
1364             echo "$file" | grep -q -e ":${CANONICAL_TARGET}:" \
1365                                    -e ":${CANONICAL_TARGET}.ed$"
1366             if [ $? -eq 0 ] ; then
1367                 ed_fragment3="$ed_fragment3
1368 $(cat $file)"
1369                 let n=$n+1
1370             fi
1371         done
1372
1373         if [ $n -gt 1 ]; then
1374             ed $SOURCE <<EOF
1375 /^Source: /a
1376 $ed_fragment1
1377 .
1378 /^%setup /a
1379 $ed_fragment2
1380 .
1381 $ed_fragment3
1382 wq
1383 EOF
1384         fi
1385     fi
1386
1387     local linuxrelease=$(find_linux_release)
1388     if compare_version $OFED_VERSION 3.0; then
1389         local OFA_KERNEL_RELEASE=$(echo -n ${linuxrelease} | sed -e 's/-/_/g')
1390     fi
1391     if ! $RPMBUILD $BUILD_TYPE --define 'build_kernel_ib 1' --define 'build_kernel_ib_devel 1' \
1392                   ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \
1393                   --define "_topdir ${TOPDIR}" --target ${TARGET_ARCH} \
1394                   --define "KVERSION ${linuxrelease}" \
1395                   --define "$K_SRC ${linux}" \
1396                   --define "LIB_MOD_DIR /lib/modules/${linuxrelease}/updates" \
1397                   ${OFA_KERNEL_RELEASE:+--define "_release $OFA_KERNEL_RELEASE"} \
1398                   --define "configure_options --without-quilt $OFED_CORE $OFED_HARDWARE $OFED_ISCSI" \
1399                   ${SOURCE} 2>&1; then
1400         fatal 1 "Error building ${kib_rpm}"
1401     fi
1402
1403 }
1404
1405 store_for_reuse() {
1406     local articles="$1"
1407     local module="$2"
1408     local location="$3"
1409     local signature="$4"
1410     local use_links="$5"
1411
1412     local linkflag=""
1413     if $use_links; then
1414         linkflag="l"
1415     fi
1416
1417     local default_iface=$(/sbin/ip route get 192.1.1.1 | sed -ne 's/.* dev \(.*\)  * src .*/\1/p')
1418     if [ -z "$default_iface" ]; then
1419         fatal 1 "Failed to determine the default route interface"
1420     fi
1421     local unique_id=$(/sbin/ip addr show dev $default_iface | sed -ne '/ inet /s/ *inet \(.*\)\/.*/\1/p' | head -1)
1422     if [ -z "$unique_id" ]; then
1423         fatal 1 "Failed to determine a unique id from interface $default_interface"
1424     fi
1425
1426     local finallocation="$location"/"$signature"/"$module"
1427     location="$location"/"$signature-${unique_id}"/"$module"
1428     mkdir -p "$location"
1429     # the cleanup script removes any directory that doesn't have a
1430     # .lastused, so let's try to prevent that as soon as we can
1431     # this solution still slightly racy with the cleanup script
1432     # but the race is a lot tighter now
1433     touch -t 197001010000 "$location/.lastused"
1434     ## use eval/echo here to make sure shell expansions are performed
1435     #if ! cp -a${linkflag} $(eval echo $articles) "$location"; then
1436     local article
1437     for article in $(eval echo $articles); do
1438         if ! cp -a${linkflag} "$article" "$location"; then
1439             error "Failed to copy \"$article\" to \"$location\" in store_for_reuse()"
1440             # rename the cache location so that it's not cached
1441             # product, but is around for analysis
1442             mv "$location"{,-bad-$(date +%s)} ||
1443                 error "failed to clean up a failed cache attempt" \
1444                       "in \"$location\" -- manual cleanup will be" \
1445                       "necessary"
1446             return 1
1447         fi
1448     done
1449
1450     # flag the cache as complete (i.e. in case lbuild was previously
1451     # interrupted while caching)
1452     touch "$location/.lastused"
1453
1454     # put the temporary location into the final location
1455     # (last one wins)
1456     mkdir -p "${finallocation%/*}"
1457     mv "$location" "$finallocation"
1458     rmdir "${location%/*}"
1459     return 0
1460
1461 }
1462
1463 reuse() {
1464     local module="$1"
1465     local dest="$2"
1466     local use_links="${3:-false}"
1467     local signature="$4"
1468
1469     if [ -n "$REUSEBUILD" ] && [ -d "$REUSEBUILD/$signature/$module" ]; then
1470         if [ ! -f "$REUSEBUILD/$signature/$module/.lastused" ]; then
1471             # the .lastused flag is populated at the end of the caching to
1472             # signal that the caching was completed.  if that flag is not
1473             # there, then the cache is invalid (and should be removed in fact)
1474             mv "$REUSEBUILD/$signature/$module"{,-bad-$(date +%s)} ||
1475                 fatal 1 "failed to clean up a bad cache in location $REUSEBUILD/$signature/$module\" -- manual cleanup will be necessary"
1476             return 1
1477         fi
1478
1479         # so that we know how stale this entry is
1480         touch $REUSEBUILD/$signature/$module/.lastused
1481
1482         if $use_links; then
1483             if ls $REUSEBUILD/$signature/$module/* >/dev/null 2>&1; then
1484                 cp -al $REUSEBUILD/$signature/$module/* $dest/
1485             fi
1486         else
1487             # copying is pretty heavy
1488             # cp -a $REUSEBUILD/$signature/$module/* $dest/
1489             # do some creative symlinking instead
1490             local dir
1491             for dir in BUILD SRPMS SPECS; do
1492                 if ls $REUSEBUILD/$signature/$module/$dir/* >/dev/null 2>&1; then
1493                     ln -s $REUSEBUILD/$signature/$module/$dir/* $dest/$dir
1494                 fi
1495             done
1496             # sources have to be copied by file because we need SOURCES to
1497             # be a dir we can write into
1498 # could overrun ls's arg list here
1499             #ls $REUSEBUILD/$signature/$module/SOURCES/* |
1500             find $REUSEBUILD/$signature/$module/SOURCES/ -type f |
1501                 xargs ln -t $dest/SOURCES -s
1502
1503             # same for RPMS/* dirs
1504 # could overrun ls's arg list here
1505             #ls $REUSEBUILD/$signature/$module/RPMS/$TARGET_ARCH/* |
1506             local dir
1507             for dir in $REUSEBUILD/$signature/$module/RPMS/*; do
1508                 mkdir -p $dest/RPMS/${dir##*/}
1509                 find $dir -type f |
1510                   xargs ln -t $dest/RPMS/${dir##*/} -s
1511             done
1512         fi
1513         return 0
1514     else
1515         return 1
1516     fi
1517 }
1518
1519 basearch() {
1520     local arch="$1"
1521
1522     if [[ $arch = i[3456]86 ]]; then
1523         echo "i386"
1524     else
1525         echo "$arch"
1526     fi
1527
1528 }
1529
1530 build_kernel_with_srpm() {
1531     local outfd=$1
1532
1533     if [ -z "$outfd" ] || [ $outfd = 1 ]; then
1534         fatal 1 "You must supply a file descriptor to ${FUNCNAME[0]} and it cannot be 1"
1535     fi
1536
1537     # need to generate the patch for this target
1538     do_patch_linux false >&${outfd}    # sets global $FULL_PATCH (yeah, yuck)
1539
1540     # get an md5sum of the kernel patch + config for reuse check
1541     # XXX really, there needs to be a signature and a CONFIG_FILE per arch
1542     #     in BUILD_ARCHS
1543     local release_str
1544     if $RELEASE; then
1545         local release_str="RELEASE=$RELEASE\n"
1546     fi
1547
1548     if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then
1549         local REUSE_SIGNATURE=$({ echo -en $release_str;
1550                                   echo $BUILD_GEN;
1551                                   cat $CONFIG_FILE $TARGET_FILE $FULL_PATCH;
1552                                   cat $LBUILD_DIR/lbuild $LBUILD_DIR/lbuild-${DISTRO}; } |
1553                                 md5sum | cut -d" " -f1)
1554         # see if we can link to the reuse pool
1555         # XXX - hrm.  i'm not convinced this doesn't belong in the reuse
1556         #       "library"
1557         local CAN_LINK_FOR_REUSE=false
1558         touch $REUSEBUILD/$$
1559         if cp -al $REUSEBUILD/$$ $TOPDIR/ 2>/dev/null; then
1560             CAN_LINK_FOR_REUSE=true
1561         fi
1562         rm $REUSEBUILD/$$
1563     fi
1564
1565     # the extra version string to use for the kernel (which might be a reused
1566     # kernel, remember)
1567     local kernel_extra_version=""
1568     if ! $USE_BUILD_CACHE || ! reuse kernel "$TOPDIR" "$CAN_LINK_FOR_REUSE" \
1569                                    "$REUSE_SIGNATURE"; then
1570         # nothing cached, build from scratch
1571         if [ ! -r "$KERNELDIR/$KERNEL_SRPM" ]; then
1572             echo "Downloading kernel SRPM" >&${outfd}
1573             download_srpm "$CANONICAL_TARGET" "$KERNEL_SRPM" >&${outfd}
1574         fi
1575
1576         if ! rpm -ivh $KERNELDIR/$KERNEL_SRPM \
1577                   --define "_topdir $TOPDIR" >&${outfd} 2>&1; then
1578             # should we clean this up or leave it for analysis?
1579             #rm -rf $RPMTOPDIR
1580             fatal 1 "Error installing kernel SRPM."
1581         fi
1582
1583         # put the Lustre kernel patch into the RPM build tree
1584         cp $FULL_PATCH $TOPDIR/SOURCES/linux-${lnxmaj}-lustre.patch
1585         prepare_and_build_srpm >&${outfd} ||
1586             fatal 1 "failed to prepare_and_build_srpm"
1587
1588         if [ -z "$REUSE_SIGNATURE" ]; then
1589             echo "No reuse signature was caculated so not storing the built kernel" >&${outfd}
1590         else
1591             # store the resulting kernel RPM build tree for future use
1592             echo "Storing the built kernel for future reuse" >&${outfd}
1593             if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,SRPMS,RPMS}" \
1594                                  "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \
1595                                  "$CAN_LINK_FOR_REUSE"; then
1596                 error "Failed to store kernel RPMS for reuse"
1597                 echo "unknown" >&${outfd}
1598                 return 1
1599             fi
1600         fi
1601     fi  # build reuse
1602
1603     # figure out the EXTRA_VERSION of the kernel we built or are re-using
1604     local KERNEL_RPM
1605     if ! KERNEL_RPM=$(find_rpm "$TOPDIR/RPMS/$TARGET_ARCH/" provides "^kernel(-default)? ="); then
1606         fatal 1 "Failed to find a kernel RPM in $TOPDIR/RPMS/$TARGET_ARCH/"
1607     fi
1608     kernel_extra_version=$(rpm -q --queryformat "%{RELEASE}" -p $TOPDIR/RPMS/$TARGET_ARCH/$KERNEL_RPM)
1609
1610     # should now have the following RPMs
1611     # $TOPDIR/RPMS/$arch/kernel-lustre-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1612     # $TOPDIR/RPMS/$arch/kernel-lustre-devel-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1613     # $TOPDIR/RPMS/$arch/kernel-lustre-headers-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1614     # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-common-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1615     # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm
1616
1617     echo $kernel_extra_version
1618     return 0
1619
1620 }
1621
1622 # build OFED
1623 # globals used:
1624 #    TOPDIR
1625 #    REUSEBUILD, USE_BUILD_CACHE
1626 #    CONFIGURE_FLAGS
1627
1628 build_ofed() {
1629     local linux="$1"
1630     local ofed_version="$2"
1631     local kib_prefix
1632     local kib_rpm
1633
1634     # if an ofed version is given, then it means use OFED proper,
1635     # not any vendor specific "inkernel" version
1636     if [ -z "$ofed_version" ]; then
1637         return 0
1638     fi
1639
1640     if [ "$ofed_version" = "inkernel" ]; then
1641         # see if there is a distro specific override for this and use
1642         # that if it exists
1643         # XXX we need to better integrate a distro specific override with
1644         #     the rest of this function so that all of the reuse cache
1645         #     stuff is leveraged given that 80% of this function is reuse
1646         if type -p build_ofed-${DISTRO}; then
1647             local ofed_location
1648             ofed_location=$(build_ofed-${DISTRO} ${STDOUT})
1649             local rc=${PIPESTATUS[0]}
1650             CONFIGURE_FLAGS="--with-o2ib=${ofed_location} ${CONFIGURE_FLAGS}"
1651             return $rc
1652         else
1653             return 0
1654         fi
1655     elif compare_version $OFED_VERSION 3.0; then
1656         kib_prefix="ofa_kernel"
1657         kib_rpm="kernel-ib"
1658     else
1659         kib_prefix="compat-rdma"
1660         kib_rpm="compat-rdma"
1661     fi
1662
1663     # build kernel-ib/compat-rdma
1664     if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then
1665         local REUSE_SIGNATURE=$({ echo "$ofed_version";
1666                                   echo "$(find_linux_release;
1667                                   echo "$BUILD_GEN")";
1668                                   cat "${linux}/include/linux/autoconf.h";
1669                                   cat "$LBUILD_DIR/lbuild" ;
1670                                   cat "$LBUILD_DIR/lbuild-${DISTRO}"; } |
1671                                 md5sum | cut -d" " -f1)
1672         # see if we can link to the reuse pool
1673         # XXX - hrm.  i'm not convinced this doesn't belong in the reuse
1674         #       "library"
1675         local CAN_LINK_FOR_REUSE=false
1676         touch $REUSEBUILD/$$
1677         if cp -al $REUSEBUILD/$$ $TOPDIR/; then
1678             CAN_LINK_FOR_REUSE=true
1679         fi
1680         rm $REUSEBUILD/$$
1681     fi
1682
1683     if ! $USE_BUILD_CACHE || ! reuse ofed "$TOPDIR" "$CAN_LINK_FOR_REUSE" \
1684                                    "$REUSE_SIGNATURE"; then
1685         if [ -n "$REUSE_SIGNATURE" ]; then
1686             # stash away the existing built articles for a moment
1687             mkdir bak
1688             mv {BUILD,{S,}RPMS,S{OURCE,PEC}S} bak
1689             function mv_back {
1690                 pushd bak
1691                 find . | cpio -pudlm ..
1692                 popd
1693                 rm -rf bak
1694             }
1695             create_rpmbuild_dirs
1696         fi
1697         # build it
1698         build_kernel_ib "${linux}" "${kib_prefix}" "${kib_rpm}"
1699
1700         if [ -z "$REUSE_SIGNATURE" ]; then
1701             echo "No reuse signature was caculated so not storing the built ofed"
1702         else
1703             # store the resulting RPM build tree for future use
1704             echo "Storing the built ofed for future reuse"
1705             if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,BUILD,SRPMS,RPMS}" \
1706                                  "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \
1707                                  "$CAN_LINK_FOR_REUSE"; then
1708                 error "Failed to store OFED RPMS for reuse"
1709                 mv_back
1710                 return 1
1711             fi
1712             # put the stuff we stashed away back
1713             mv_back
1714         fi
1715     fi
1716
1717     pushd "$TOPDIR" >/dev/null
1718     rm -rf ${kib_rpm}-devel
1719     mkdir ${kib_rpm}-devel
1720     cd ${kib_rpm}-devel
1721     # the actual ofed RPMs don't have the -rc$n or -$date string appened that
1722     # might be present on the file
1723     #local linuxrelease=$(find_linux_release)
1724     #ofed_version=$(echo $ofed_version |
1725     #               sed -re 's/-(20[0-9]{6,6}-[0-9]{4,4}|rc[0-9]*)$//')
1726     # FIXME
1727     # OFED version will have 'hyphen' for minor release. (e.g. 3.5-1, instead
1728     # of 3.5.1) compat-rdma and compat-rdma-devel could have same version
1729     # number, but currectly not. Once OFED fix this in the future release, we
1730     # can remove following filter.
1731     #ofed_version=$(echo $ofed_version |
1732     #               sed -re 's/-([0-9]*-[rR][cC][0-9]*)$//')
1733     #local rpm=$(ls $TOPDIR/RPMS/*/${kib_rpm}-devel-${ofed_version}-${linuxrelease//-/_}.*.rpm)
1734     # I dont' know why we have gone through the trouble to filter out the name
1735     # of the rpm there should only be one ${kib_rpm}-devel built
1736     local rpm=$(ls $TOPDIR/RPMS/*/${kib_rpm}-devel-*.rpm)
1737     if ! rpm2cpio < $rpm | cpio -id; then
1738         fatal 1 "could not unpack the ${kib_rpm}-devel rpm."
1739     fi
1740     CONFIGURE_FLAGS="--with-o2ib=$(pwd)/usr/src/${kib_prefix} ${CONFIGURE_FLAGS}"
1741     popd >/dev/null
1742
1743 }
1744
1745 build_with_srpm() {
1746
1747     if ! $PATCHLESS; then
1748         local kernel_extra_version
1749         if ! kernel_extra_version=$(build_kernel_with_srpm ${STDOUT}); then
1750             fatal 1 "Failed to build the kernel from it's SRPM"
1751         fi
1752
1753         for arch in $BUILD_ARCHS; do
1754             local kernel_devel_rpm
1755             if ! kernel_devel_rpm=$(find_rpm "$TOPDIR/RPMS/$arch/" provides "^$(devel_kernel_name $KERNEL_LUSTRE_NAMING) ="); then
1756                 fatal 1 "Failed to find a kernel development RPM in $TOPDIR/RPMS/$arch/"
1757             fi
1758
1759             # install the -devel RPM in preparation for modules builds
1760             if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \
1761                            "$TOPDIR/RPMS/$arch/$kernel_devel_rpm"; then
1762                 fatal 1 "Could not find the Linux tree in $TOPDIR/RPMS/$arch/$kernel_devel_rpm"
1763             fi
1764         done
1765     else
1766         # need to find and unpack the vendor's own kernel-devel for patchless
1767         # client build
1768         local kernelrpm
1769         if ! kernelrpm=$(find_linux_rpm "-$DEVEL_KERNEL_TYPE"); then
1770             fatal 1 "Could not find the kernel-$DEVEL_KERNEL_TYPE RPM in ${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}"
1771         fi
1772         if ! lnxrel="$lnxrel" unpack_linux_devel_rpm "$kernelrpm" "-"; then
1773             fatal 1 "Could not find the Linux tree in $kernelrpm"
1774         fi
1775     fi
1776
1777     # ~sigh~  have to make copies of and modify some of the rpm
1778     # infrastructure files so that find-requires can find our unpacked
1779     # kernel-devel artifacts
1780     cp $RPM_HELPERS_DIR/{symset-table,find-requires{,.ksyms}} .
1781     FIND_REQUIRES="$(pwd)/find-requires"
1782     chmod 755 {symset-table,find-requires{,.ksyms}}
1783     local tmp="$(pwd)"
1784     tmp="${tmp//\//\\/}"
1785     ed find-requires <<EOF
1786 1a
1787 set -x
1788 .
1789 /|.*find-requires.ksyms/s/|/| bash -x/
1790 g/ [^ ]*\/\(find-requires\.ksyms\)/s// $tmp\/\1/g
1791 wq
1792 EOF
1793     ed find-requires.ksyms <<EOF
1794 1a
1795 set -x
1796 .
1797 g/\/.*\/\(symset-table\)/s//$tmp\/\1/g
1798 wq
1799 EOF
1800     ed symset-table <<EOF
1801 1a
1802 set -x
1803 .
1804 g/\(\/boot\/\)/s//$tmp\/reused\1/g
1805 g/\(\/usr\/src\/kernels\/\)/s//$tmp\/reused\1/g
1806 wq
1807 EOF
1808
1809     build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||
1810         fatal 1 "error building OFED"
1811
1812     # now build Lustre
1813     if build_lustre "$LINUX" "$LINUXOBJ"; then
1814         # the build worked.  resolve any symlinked files (i.e. from reuse)
1815         # in RPMS/$arch to real files so that that that huge mess of
1816         # complication known as LTS can copy them yet somewhere else.
1817         # is it any wonder this whole process is so damn so?  anyone ever
1818         # heard of hardlinks?  it's this cool new thing that allows you save
1819         # tons of time and space by creating... well you can go read about
1820         # them if you have not heard about them yet.
1821         # can i say how much the implemenation of all of this really impedes
1822         # RPM reuse?
1823         local dir
1824         for dir in RPMS/*; do
1825             pushd $dir
1826             for file in $(ls); do
1827                 if [ -h $file ]; then
1828                     cp $file foo
1829                     mv foo $file
1830                 fi
1831             done
1832             popd
1833         done
1834         # also, for i?86, make sure all of the RPMs are in RPMS/$TARGET_ARCH
1835         # as that's where LTS expects to find them
1836         for dir in RPMS/*; do
1837             if [ $dir = RPMS/$TARGET_ARCH ]; then
1838                 continue
1839             fi
1840             pushd $dir
1841             local files=$(ls)
1842             if [ -n "$files" ]; then
1843                 cp -al $files ../$TARGET_ARCH
1844             fi
1845             popd
1846         done
1847     else
1848         return 1
1849     fi
1850
1851 }
1852
1853 create_rpmbuild_dirs() {
1854
1855     [ -d RPMS ] || mkdir RPMS
1856     for arch in $BUILD_ARCHS; do
1857         if [[ $arch = i?86 ]]; then
1858             # some stupidity in the sles11 kernel spec requires an RPMS/i386
1859             # even if the target arch is i686
1860             [ -d RPMS/i386 ] || mkdir RPMS/i386
1861         fi
1862         [ -d RPMS/$arch ] || mkdir RPMS/$arch
1863     done
1864     [ -d RPMS/noarch ] || mkdir RPMS/noarch
1865     [ -d BUILD ] || mkdir BUILD
1866     [ -d SOURCES ] || mkdir SOURCES
1867     [ -d SPECS ] || mkdir SPECS
1868     [ -d SRPMS ] || mkdir SRPMS
1869
1870 }
1871
1872 new_list() {
1873
1874     echo ""
1875
1876 }
1877
1878 add_list() {
1879     local list="$1"
1880     local item="$2"
1881
1882     echo "$list $item"
1883
1884 }
1885
1886 is_list_member() {
1887     local list="$1"
1888     local item="$2"
1889
1890     [[ $list\  == *\ $item\ * ]]
1891
1892 }
1893
1894 #########################################################################
1895 # Generate a backtrace through the call stack.
1896 #
1897 # Input: None
1898 # Output: None
1899 #########################################################################
1900 backtrace() {
1901     local strip=${1:-1}
1902
1903     local funcname="" sourcefile="" lineno="" n
1904
1905     echo "Call stack: (most recent first)"
1906     for (( n = $strip ; n < ${#FUNCNAME[@]} ; ++n )) ; do
1907         funcname=${FUNCNAME[$n - 1]}
1908         sourcefile=$(basename ${BASH_SOURCE[$n]})
1909         lineno=${BASH_LINENO[$n - 1]}
1910         if [ $n = 1 ]; then
1911             let lineno-=11
1912         fi
1913         # Display function arguments
1914         if [[ ! -z "${BASH_ARGV[@]}" ]]; then
1915             local args newarg j p=0
1916             for (( j = ${BASH_ARGC[$n - 1]}; j > 0; j-- )); do
1917                 newarg=${BASH_ARGV[$j + $p - 1]}
1918                 args="${args:+${args} }'${newarg}'"
1919             done
1920             let p+=${BASH_ARGC[$n - 1]}
1921         fi
1922         echo "  ${funcname} ${args:+${args} }at ${sourcefile}:${lineno}"
1923     done
1924
1925     echo
1926     echo "BEGIN BACKTRACE"
1927
1928     #echo ${BASH_LINENO[*]}
1929     #echo ${BASH_SOURCE[*]}
1930     #echo ${FUNCNAME[*]}
1931     local i=$((${#FUNCNAME[@]} - 1))
1932     while [ $i -ge 0 ]; do
1933         local lineno=${BASH_LINENO[$i]}
1934         if [ $i = 0 ]; then
1935             let lineno-=11
1936         fi
1937         local SOURCELINE="${BASH_SOURCE[$i + 1]}:${lineno}"
1938         # Can't figure out how to get function args from other frames...
1939         local FUNCTION="${FUNCNAME[$i]}()"
1940         echo "$SOURCELINE:$FUNCTION"
1941         i=$((i - 1))
1942     done
1943
1944     echo "END BACKTRACE"
1945
1946     echo $BACKTRACE
1947
1948 }
1949
1950 seen_list=$(new_list)
1951 trap 'set +x;
1952 echo "An unexpected error has occurred at ${BASH_SOURCE[0]##*/}:$((LINENO-1)).
1953 Unfortunately the above line number in the message may or may not be correct,
1954 but details have been send to the lbuild maintainer.  Attempting to continue."; (echo "Untrapped error"
1955 echo
1956 # have we seen this one
1957 echo "checking seen list for ${BASH_SOURCE[0]}:${BASH_LINENO[0]}"
1958
1959 if is_list_member "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}"; then
1960   echo "seen this one already"
1961 else
1962   seen_list=$(add_list "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}")
1963 fi
1964 backtrace
1965 ) ; set $xtrace' ERR
1966 set -E
1967
1968 [ -r ~/.lbuildrc ] && . ~/.lbuildrc
1969
1970 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:,mpss-version:,publish,release,set-value:,src,stage:,tag:,target:,target-archs:,with-linux:,xen -- "$@")
1971
1972 if [ $? != 0 ]; then
1973     usage 1
1974 fi
1975
1976 eval set -- "$options"
1977
1978 while [ "$1" ]; do
1979     case "$1" in
1980         '')
1981             usage 1
1982             ;;
1983         --ccache)
1984             CCACHE='ccache'
1985             shift
1986             ;;
1987         -D)
1988             DATE=$2
1989             shift 2
1990             ;;
1991         --external-patches)
1992             EXTERNAL_PATCHES=$2
1993             shift 2
1994             ;;
1995         --extraversion)
1996             EXTRA_VERSION=$2
1997             shift 2
1998             ;;
1999         --help | -h)
2000             usage 0
2001             ;;
2002         --kerneldir)
2003             KERNELDIR=$2
2004             shift 2
2005             ;;
2006         --kerneltree)
2007             if ! KERNELTREE=$(canon_path "$2"); then
2008                 fatal 1 "Could not determine the canonical location of $2"
2009             fi
2010             shift 2
2011             ;;
2012         --linux | --with-linux)
2013             if ! LINUX=$(canon_path "$2"); then
2014                 fatal 1 "Could not determine the canonical location of $2"
2015             fi
2016             shift 2
2017             ;;
2018         --distro)
2019             DISTRO=$2
2020             shift 2
2021             ;;
2022         --reuserpm)
2023             REUSERPM=$2
2024             shift 2
2025             ;;
2026         --reusebuild)
2027             if ! REUSEBUILD=$(canon_path "$2"); then
2028                 fatal 1 "Could not determine the canonical location of $2"
2029             fi
2030             shift 2
2031             ;;
2032         --norpm)
2033             NORPM=true
2034             shift
2035             ;;
2036         --ldiskfs)
2037             echo "WARNING: \"--ldiskfs\" is deprecated" > 2
2038             shift
2039             ;;
2040         --noiokit)
2041             IOKITRPM=false
2042             shift
2043             ;;
2044         --patchless)
2045             PATCHLESS=true
2046             shift
2047             ;;
2048         --kernelrpm)
2049             if ! KERNELRPMSBASE=$(canon_path "$2"); then
2050                 fatal 1 "Could not determine the canonical location of $2"
2051             fi
2052             shift 2
2053             ;;
2054         --timestamp)
2055             TIMESTAMP=$2
2056             shift 2
2057             ;;
2058         --lustre)
2059             if ! LUSTRE=$(canon_filepath "$2"); then
2060                 fatal 1 "Could not determine the canonical location of $2"
2061             fi
2062             shift 2
2063             ;;
2064         --nodownload)
2065             DOWNLOAD=false
2066             shift 1
2067             ;;
2068         --nosrc)
2069             DO_SRC=false
2070             shift 1
2071             ;;
2072         --ofed-version)
2073             OFED_VERSION="$2"
2074             shift 2
2075             ;;
2076         --mpss-version)
2077             MPSS_VERSION="$2"
2078             shift 2
2079             ;;
2080         --publish)
2081             shift
2082             ;;
2083         --release)
2084             RELEASE=true
2085             shift
2086             ;;
2087         --src)
2088             DO_SRC=true
2089             shift 1
2090             ;;
2091         --stage)
2092             STAGEDIR=$2
2093             shift 2
2094             ;;
2095         --tag)
2096             shift 2
2097             echo "WARNING: \"--tag\" is deprecated" > 2
2098             ;;
2099         --target)
2100             TARGET=$2
2101             shift 2
2102             ;;
2103         --target-archs)
2104             TARGET_ARCHS=$2
2105             shift 2
2106             ;;
2107         --xen)
2108             XEN=true
2109             shift
2110             ;;
2111         --set-value)
2112             eval $2
2113             shift 2
2114             ;;
2115         --)
2116             shift
2117             # there are actually some lustre configure flags that we need to
2118             # handle ourselves (but we still give them to configure)
2119             if [[ \ $@\  == *\ --disable-tests\ * ]]; then
2120                 LUSTRE_TESTS=false
2121             fi
2122             CONFIGURE_FLAGS=$@
2123             CONFIGURE_FLAGS="$CONFIGURE_FLAGS --enable-liblustre --enable-liblustre-tests"
2124             break
2125             ;;
2126         *)
2127             usage 1 "Unrecognized option: $1"
2128             ;;
2129     esac
2130 done
2131
2132 check_options
2133
2134 unpack_lustre
2135
2136 # XXX - should we _always_ get the buildid from the META file?  what are the
2137 # other (i.e. non-lustre-tarball use cases of lbuild)?
2138 BUILDID=$(sed -ne '/^BUILDID =/s/.*= *//p' lustre/META)
2139 VERSION=$(sed -ne '/^VERSION =/s/.*= *//p' lustre/META)
2140
2141 load_target
2142
2143 if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
2144     download_ofed
2145     unpack_ofed || fatal 1 "Error unpacking OFED tarball"
2146 fi
2147
2148 if [ -n "$MPSS_VERSION" ]; then
2149     [ -z "$MPSS_DISTRO" ] && MPSS_DISTRO=$(autodetect_distro)
2150
2151     MPSS_INFO=$(mktemp -u mpss-info-XXXXXXXXXX.html)
2152     download_mpss_info "$MPSS_INFO"
2153
2154     if [ "$MPSS_VERSION" = "last" ]; then
2155         MPSS_VERSION=$(parse_mpss_info "$MPSS_INFO" "" ${MPSS_DISTRO})
2156         [ -z "$MPSS_VERSION" ] && fatal 1 "Could not determine the last MPSS version"
2157     elif [[ $MPSS_VERSION != [0-9].[0-9].[0-9]*-[0-9]* ]]; then
2158         fatal 1 "Incorrect MPSS version $MPSS_VERSION"
2159     fi
2160
2161     download_mpss "$MPSS_INFO"
2162     [ -r "$MPSS_INFO" ] && rm -f "$MPSS_INFO"
2163     echo "Building with MPSS $MPSS_VERSION"
2164     unpack_mpss  || fatal 1 "Error unpacking MPSS tarballs"
2165     prepare_mpss || fatal 1 "Error preparing MPSS for kernel modules build"
2166
2167     if [ -z "$MPSS_OFED" ]; then
2168         MPSS_OFED=$(find $PWD -type f -path "*/ofed-driver-*/Module.symvers")
2169         if [ -n "$MPSS_OFED" ]; then
2170             MPSS_OFED="--with-o2ib=$(dirname $MPSS_OFED)"
2171         else
2172             MPSS_OFED="--without-o2ib"
2173         fi
2174     fi
2175
2176     # disable unsupported parts:
2177     PATCHLESS=true
2178     IOKITRPM=false
2179     LDISKFSRPM=false
2180     ZFSNOTSUPPORTED="yes"
2181
2182     # define variables for cross compilation:
2183     CROSS_SUFFIX="-mic"
2184     if [ "${MPSS_VERSION%%.*}" = "3" ]; then
2185         CC_TARGET_ARCH=k1om-mpss-linux
2186         LINUX="$TOPDIR/mpss"
2187     else
2188         CC_TARGET_ARCH=x86_64-k1om-linux
2189         LINUX="$TOPDIR/mpss/card/kernel"
2190         RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_requires intel-mic-gpl = ${MPSS_VERSION%%-*}\""
2191     fi
2192     CONFIGURE_FLAGS="$CONFIGURE_FLAGS $MPSS_OFED --host=$CC_TARGET_ARCH --build=x86_64-pc-linux"
2193     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"post_script build/gen_filelist.sh\""
2194     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"make_args ARCH=k1om CROSS_COMPILE=${CC_TARGET_ARCH}-\""
2195     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_path ${CROSS_PATH:=/opt/lustre/${VERSION}/${CC_TARGET_ARCH}}\""
2196     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"rootdir %{cross_path}\""
2197     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_prefix %{cross_path}/usr\""
2198     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_mandir %{_prefix}/share/man\""
2199     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_sysconfdir %{cross_path}/etc\""
2200     RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"kmoddir extra\""
2201
2202     # redefine CC for proper ./configure during rpmbuild
2203     export CC=${CC_TARGET_ARCH}-gcc
2204 fi
2205
2206 # make sure the RPM build environment is set up
2207 create_rpmbuild_dirs
2208
2209 # if an unpacked kernel source tree was given on the command line
2210 # just build lustre with it (nothing distro kernel specific here)
2211 if [ -n "$LINUX" ]; then
2212     build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||
2213         fatal 1 "error building OFED"
2214     build_lustre "$LINUX" "$LINUXOBJ"
2215 else
2216     if [ ! -f "${LBUILD_DIR}/lbuild-$DISTRO" ]; then
2217         fatal 1 "${LBUILD_DIR}/lbuild-$DISTRO not found"
2218     fi
2219     source ${LBUILD_DIR}/lbuild-$DISTRO
2220     build_with_srpm || fatal 1 "Failed to build_with_srpm"
2221 fi
2222
2223 stage