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