git://git.whamcloud.com - fs/lustre-release.git/blob

1 #!/bin/bash

3 # vim:expandtab:shiftwidth=4:softtabstop=4:tabstop=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

11 #set -x

12 xtrace="+x"

13 if [[ $SHELLOPTS = *xtrace* ]]; then

14 xtrace="-x"

15 fi

16 shopt -s extdebug

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})}

23 # include the exit_traps library

24 . ${LBUILD_DIR}/exit_traps.sh

25 . ${LBUILD_DIR}/funcs.sh

27 # our children should die when we do

28 push_exit_trap "kill -INT -$$ || true" kill_children

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

39 TOPDIR=$PWD

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

86 # patchless build

87 KERNELRPMSBASE=

88 RPMSMPTYPE=

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 [ -z "$TARGET" ] && TARGET=$(autodetect_target "$DISTRO")

277

278 if [ -z "$LINUX" ]; then

279 [ "$KERNELDIR" -o "$KERNELTREE" ] || \

280 usage 1 "A kernel directory must be specified with --kerneldir or --kerneltree."

281

282 [ -d "$KERNELDIR" -o -d "$KERNELTREE" ] || \

283 usage 1 "$KERNELDIR and $KERNELTREE are not a directory."

284

285 # TARGET_FILE="$TOPDIR/lustre/kernel_patches/targets/$TARGET.target"

286 # [ -r "$TARGET_FILE" ] || \

287 # usage 1 "Target '$TARGET' was not found."

288 fi

289

290 case $TARGET in

291 2.6-rhel6)

292 CANONICAL_TARGET="rhel6"

293 ;;

294 2.6-rhel5)

295 CANONICAL_TARGET="rhel5"

296 ;;

297 2.6-rhel4)

298 CANONICAL_TARGET="rhel-2.6"

299 ;;

300 2.6-suse)

301 CANONICAL_TARGET="sles-2.6"

302 ;;

303 2.6-sles10)

304 CANONICAL_TARGET="sles10-2.6"

305 ;;

306 2.6-sles11 | 3.0-sles11)

307 CANONICAL_TARGET="sles11"

308 ;;

309 2.6-oel5)

310 CANONICAL_TARGET="oel5"

311 ;;

312 hp_pnnl-2.4)

313 CANONICAL_TARGET="hp-pnnl-2.4"

314 ;;

315 2.6-vanilla \

316 | suse-2.4.21-2 \

317 | rh-2.4 \

318 | rhel-2.4 \

319 | sles-2.4 \

320 | 2.6-patchless)

321 CANONICAL_TARGET="$TARGET"

322 ;;

323 esac

324

325 local timestampnodig=$(echo $TIMESTAMP | sed -e s/[0-9]*//g)

326 [ "$timestampnodig" = "" ] || TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")

327 local timestamplength="${#TIMESTAMP}"

328 if [ $timestamplength -eq 12 ]; then

329 TIMESTAMP="${TIMESTAMP}00"

330 elif [ $timestamplength -ne 14 ]; then

331 TIMESTAMP=$(date -d "$DATE" "+%Y%m%d%H%M%S")

332 fi

333

334 RPMBUILD=$(which rpmbuild 2>/dev/null | head -1)

335 if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then

336 RPMBUILD=$(which rpm 2>/dev/null | head -1)

337 if [ ! "$RPMBUILD" -o "$RPMBUILD" == "" ]; then

338 usage 1 "Could not find binary for making rpms (tried rpmbuild and rpm)."

339 fi

340 fi

341

342 if [ -n "$CCACHE" ]; then

343 which "$DISTCC" &>/dev/null && export DISTCC RPM_BUILD_NCPUS

344

345 if which "$CCACHE" &>/dev/null; then

346 local ccache=$(which "$CCACHE")

347 local bindir="$TOPDIR/bin"

348

349 if [ ! -d $bindir ]; then

350 mkdir -p $bindir || fatal 1 "error trying to create $bindir"

351 else

352 rm ${bindir}/* > /dev/null 2>&1 || true

353 fi

354 ln -s "$ccache" ${bindir}/ccache

355 ln -s "$ccache" ${bindir}/cc

356 ln -s "$ccache" ${bindir}/$CC

357 export PATH=$bindir:$PATH

358 export CCACHE && export CC="ccache $CC"

359 # zero the cache so we can see how effective we are being with it

360 echo -n "ccache "

361 ccache -z

362

363 # get some ccache stats when we are done

364 push_exit_trap '[ -n "$CCACHE" ] && ccache -s' "ccache_summary"

365 # should remove the ccache trap if lbuild is interrupted

366 trap 'echo "Received an INT TERM or HUP signal, terminating."; delete_exit_trap "ccache_summary"; exit 1' INT TERM HUP

367 fi

368 fi

369

370 return 0

371

372 }

373

374 # compare two versions $1 and $2. if $1 < $2, return 0 otherwise return 1.

375 compare_version () {

376 [[ $1 == $2 ]] && return 1

377 local IFS=.

378 local i val1=($1) val2=($2)

379

380 # padding zero to val1 if it needs

381 for ((i=${#val1[@]}; i<${#val2[@]}; i++)); do

382 val1[i]=0

383 done

384 for ((i=0; i<${#val1[@]}; i++)); do

385 [[ -z ${val2[i]} ]] && return 1

386

387 if [[ ${val1[i]} < ${val2[i]} ]]; then

388 return 0

389 elif [[ ${val1[i]} > ${val2[i]} ]]; then

390 return 1

391 fi

392 done

393 }

394

395 uniqify() {

396

397 echo $(echo "$*" | xargs -n 1 | sort -u)

398

399 }

400

401 fetch_url() {

402 local url="$1"

403 local target="$2"

404

405 local rc=0

406 if which wget >/dev/null 2>&1; then

407 if ! wget -nv "$url" -O "$target"; then

408 rc=${PIPESTATUS[0]}

409 fi

410 elif which curl >/dev/null 2>&1; then

411 if ! curl -L -s -o "$target" "$url"; then

412 rc=${PIPESTATUS[0]}

413 fi

414 else

415 fatal 1 "Could not find either wget or curl to fetch URLs."

416 fi

417

418 return $rc

419

420 }

421

422 download_srpm() {

423 local target=$1

424 local srpm=$2

425 local force="${3:-false}"

426

427 if $force || [ ! -r "$KERNELDIR/$srpm" ] ||

428 [ ! -s "$KERNELDIR/$srpm" ]; then

429 if $DOWNLOAD; then

430 local location="http://downloads.lustre.org/public/kernels/$target/old"

431 # get the location from a distro specific method if it exists

432 if type -p kernel_srpm_location; then

433 location=$(kernel_srpm_location)

434 fi

435 echo "Downloading $location/$srpm..."

436 if ! fetch_url "$location/$srpm" "$KERNELDIR/$srpm" 2>&1 ||

437 [ ! -s "$KERNELDIR/$srpm" ]; then

438 rm -f $KERNELDIR/$srpm

439 # punt to a distro specific method if it exists

440 if ! type -p download_srpm-$DISTRO; then

441 fatal 1 "Could not download target $target's kernel SRPM $srpm from $location."

442 else

443 if ! download_srpm-$DISTRO "$target" "$srpm" "$force"; then

444 fatal 1 "Could not download target $target's kernel SRPM $srpm using download_srpm-$DISTRO."

445 fi

446 fi

447 fi

448 else

449 fatal 1 "$srpm not found in directory $KERNELDIR."

450 fi

451 fi

452

453 }

454

455 download_file() {

456 local from="$1"

457 local to="$2"

458 local force="$3"

459

460 local file=${from##*/}

461

462 if [ -d $to ]; then

463 to="$to/$file"

464 fi

465

466 local semaphore="$to-downloading"

467

468 is_downloading() {

469 if [ ! -f $semaphore ]; then

470 return 1

471 fi

472

473 # make sure the download has not been aborted

474 local now=$(date +%s)

475 local file_mtime=$(stat -c %Y "$to")

476 local staleness=$((now - file_mtime))

477 # let's assume an active download will write at least once a minute

478 if [ $staleness -gt 60 ]; then

479 return 1

480 fi

481

482 return 0

483 }

484

485 is_downloaded() {

486 # if the semaphore file exists, the file is either still downloading

487 # or a download was aborted and we cannot trust the target file

488 if [ -f $semaphore ]; then

489 return 1

490 fi

491

492 if ! is_downloading && [ -r "$to" ] && [ -s "$to" ]; then

493 return 0

494 fi

495

496 return 1

497 }

498

499 if $force || ! is_downloaded; then

500 if is_downloading; then

501 echo "Somebody else is downloading $from..."

502 while is_downloading; do

503 echo "Waiting for $to to finish downloading"

504 sleep 60

505 done

506 if is_downloaded; then

507 return 0

508 else

509 echo "The download we were waiting for seems to have been aborted"

510 fi

511

512 fi

513

514 if $DOWNLOAD; then

515 echo "Downloading $from..."

516 # flag others so they don't try to download also

517 push_exit_trap "rm -f $to $semaphore" "download"

518 touch $semaphore

519 if ! fetch_url "$from" "$to" || [ ! -s "$to" ]; then

520 # the trap will remove the files via the fatal below

521 fatal 1 "Could not download ${to##*/} from ${from%/*}/."

522 fi

523 rm -f $semaphore

524 delete_exit_trap "download"

525 else

526 fatal 1 "${to##*/} not found in directory ${to%/*}."

527 fi

528 fi

529

530 return 0

531

532 }

533

534 download_ofed() {

535 local force="${1:-false}"

536

537 if [ -z "$OFED_VERSION" -o "$OFED_VERSION" = "inkernel" ]; then

538 return 0

539 fi

540

541 local OFED_BASE_VERSION=$OFED_VERSION

542 if [[ $OFED_VERSION = *.*.*.* ]]; then

543 OFED_BASE_VERSION=${OFED_VERSION%.*}

544 fi

545

546 local location="http://www.openfabrics.org/downloads/OFED/ofed-${OFED_BASE_VERSION}/"

547

548 if [[ $OFED_VERSION = *-[rR][cC][0-9] ]]; then

549 local Mmv

550 Mmv=${OFED_VERSION%%-[rR][cC][0-9]}

551 location="http://www.openfabrics.org/downloads/OFED/ofed-${Mmv}/"

552 fi

553

554 if [[ $OFED_VERSION = daily-* ]]; then

555 local Mmv daily

556 OFED_VERSION=${OFED_VERSION/daily-/}

557 Mmv=${OFED_VERSION%%-*}

558 daily=${OFED_VERSION##$Mmv-}

559 location="http://www.openfabrics.org/downloads/OFED/ofed-${Mmv}-daily/"

560 # find the filename for the version for the date specified

561 OFED_VERSION=$(curl -s "$location" | sed -nre "/${daily}-/s/.*href=\"OFED-(${Mmv//./\\.}-${daily}-[0-9]{4,4}).tgz.*$/\1/p" | tail -1)

562 if [ -z "$OFED_VERSION" ]; then

563 fatal 1 "Could not determine the filename of the OFED snapshot for ${daily}"

564 fi

565 fi

566

567 local file="OFED-${OFED_VERSION}.tgz"

568 download_file "$location/$file" "$KERNELTREE" "$force"

569

570 }

571

572 parse_mpss_info() {

573 local file="$1"

574 local build="$2"

575 local distro="$3"

576

577 [ -r "$file" ] || fatal 1 "Could not find MPSS info file"

578

579 # convert to MPSS distro naming

580 distro=${distro/sles/suse}

581 distro_name=${distro%%-*}

582

583 # extract links from MPSS info file

584 local urls=$(cat "$file" | \

585 tr -d '\t\r\n' | sed -e 's?$</[a-zA-Z]*>$?\1\n?g' | \

586 grep '.intel.com/' | \

587 sed -e 's/^.*[hH][rR][eE][fF]="$[^>"]\+$".*$/\1/g' | \

588 grep '.tar')

589 local res2=""

590 local res3=""

591 for url in $urls; do

592 local ver2=""

593 local ver3=""

594 # Try to match with MPSS 3.x or 3.x.x distro package

595 if [[ $url =~ mpss-[0-9].[0-9](.[0-9]*)?-$distro.tar ]]; then

596 ver3=${url##*mpss-}

597 ver3=${ver3%%-$distro.tar}

598 # Try to match with MPSS 3.x or 3.x.x source package

599 elif [[ $url =~ mpss-src-[0-9].[0-9](.[0-9]*)?.tar ]]; then

600 ver3=${url##*mpss-src-}

601 ver3=${ver3%%.tar}

602 # Try to match with MPSS 3.x or 3.x.x cross compiler package

603 elif [[ $url =~ mpss-[0-9].[0-9](.[0-9]*)?-k1om.tar ]]; then

604 ver3=${url##*mpss-}

605 ver3=${ver3%%-k1om.tar}

606 # Try to match with MPSS 2.1.x source package

607 elif [[ $url =~ _src-[0-9].[0-9].[0-9]*-[0-9]*_$distro_name.tar ]]; then

608 ver2=${url##*_src-}

609 ver2=${ver2%%_$distro_name.tar}

610 fi

611

612 if [ -n "$ver3" ]; then

613 # Check for MPSS 3.x or MPSS 3.x.x

614 if [[ $ver3 =~ [0-9].[0-9].[0-9]* ]]; then

615 ver3="${ver3}-0"

616 else

617 ver3="${ver3}.0-0"

618 fi

619 if [ -z "$build" ]; then

620 res3="$ver3"

621 elif [ "$build" = "$ver3" ]; then

622 res3="$res3 $url"

623 fi

624 elif [ -n "$ver2" ]; then

625 if [ -z "$build" ]; then

626 res2="$ver2"

627 elif [ "$build" = "$ver2" ]; then

628 res2="$res2 $url"

629 fi

630 fi

631

632 done

633

634 if [ -z "$build" ]; then

635 # return a last version of MPSS

636 if [ -n "$res3" ]; then

637 echo "$res3"

638 else

639 echo "$res2"

640 fi

641 elif [ "${build%%.*}" = "3" ]; then

642 local ver=${build%%-*}

643 local bid=${build##*-}

644 if [ $bid -eq 0 ]; then

645 # return URLs from MPSS info file

646 echo "$res3"

647 else

648 # Check for MPSS 3.x or MPSS 3.x.x

649 if [ ${ver##*.} -eq 0 ]; then

650 ver=${ver%.*}

651 fi

652 # return URLs from internal site with MPSS builds

653 # kernel sources:

654 echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-src-$ver.tar"

655 # kernel configs:

656 echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-$ver-k1om.tar"

657 # OFED headers:

658 echo "${MPSS_BUILDS:-"http://mic-bld.pdx.intel.com/release"}/$ver/$bid/release/knightscorner/package/mpss-$ver-$distro.tar"

659 fi

660 else

661 # return URLs from MPSS info file

662 echo "$res2"

663 fi

664 }

665

666 # Get public information about last releases of

667 # Intel Manycore Platform Software Stack (MPSS)

668 download_mpss_info() {

669 local file="$1"

670 local force="${2:-true}"

671 local url=${MPSS_URL:-"http://software.intel.com/en-us/articles/intel-manycore-platform-software-stack-mpss"}

672

673 download_file "$url" "$file" "$force"

674 }

675

676 download_mpss() {

677 local file="$1"

678 local force="${2:-false}"

679 local urls=$(parse_mpss_info "$file" ${MPSS_VERSION} ${MPSS_DISTRO})

680

681 [ -z "$urls" ] && fatal 1 "Could not determine the URLs of MPSS $MPSS_VERSION"

682

683 # force re-download if build number is zero

684 [[ $MPSS_VERSION = [0-9].[0-9].[0-9]*-0 ]] && force=true

685

686 local url

687 local i=0

688 for url in $urls; do

689 file="$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part$i.tar"

690 download_file "$url" "$file" "$force"

691 i=$((i+1))

692 done

693 }

694

695 load_target() {

696

697 EXTRA_VERSION_save="$EXTRA_VERSION"

698 for patchesdir in "$EXTERNAL_PATCHES" \

699 "$TOPDIR/lustre/lustre/kernel_patches"; do

700 TARGET_FILE="$patchesdir/targets/$TARGET.target"

701 [ -r "$TARGET_FILE" ] && break

702 done

703 [ -r "$TARGET_FILE" ] || fatal 1 "Target $TARGET was not found."

704

705 echo "Loading target config file $TARGET.target..."

706

707 # if the caller specified an OFED_VERSION it should override whatever

708 # the target file specifies

709 local env_OFED_VERSION="$OFED_VERSION"

710

711 . "$TARGET_FILE"

712

713 if [ -n "$env_OFED_VERSION" ]; then

714 OFED_VERSION="$env_OFED_VERSION"

715 fi

716

717 # doesn't make any sense to build OFED for xen domX's

718 if $XEN; then

719 OFED_VERSION=""

720 fi

721

722 # XXX - set_rpm_smp_type is an ugly undeterministic hack. it needs to

723 # go away and the target just specify the $RPMSMPTYPE

724 [ -z "$RPMSMPTYPE" ] && set_rpm_smp_type

725

726 # CC might have been overwriten in TARGET_FILE

727 if [[ $CC != ccache\ * ]] && which "$CCACHE" &>/dev/null; then

728 export CCACHE && export CC="ccache $CC"

729 fi

730

731 if [ ! "$KERNELTREE" = "" ] && [ -d "$KERNELTREE" ]; then

732 KERNELDIR="$KERNELTREE/${lnxmaj}"

733 [ -d "$KERNELDIR" ] || mkdir "$KERNELDIR"

734 fi

735

736 # verify the series is available

737 if [ "$SERIES" ]; then

738 for series in $SERIES; do

739 for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do

740 [ -r "$patchesdir/series/$series" ] && continue 2

741 done

742 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."

743 done

744 fi

745

746 # set the location of the .config file

747 local XENPOSTFIX=""

748 if $XEN; then

749 XENPOSTFIX="-xen"

750 fi

751

752 if [ -f $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET-$TARGET_ARCH.config ]; then

753 CONFIG_FILE="$TOPDIR/lustre/lustre/kernel_patches/kernel_configs/kernel-$lnxmaj-$TARGET$XENPOSTFIX-$TARGET_ARCH.config"

754 fi

755

756 local lnxrelnew=${lnxrel//-/_}

757

758 # remember the EXTRA_VERSION before we diddle it here

759 # XXX - we really should not diddle with any values read in from the

760 # target file. if we want to modify a value, we should create

761 # a new variable.

762 PRISTINE_EXTRA_VERSION=$EXTRA_VERSION

763

764 if ! $PATCHLESS && [ ! -f "$CONFIG_FILE" ]; then

765 fatal 1 "Config file for target $TARGET missing from $TOPDIR/lustre/lustre/kernel_patches/kernel_configs/."

766 fi

767

768 if [ "$EXTRA_VERSION_save" ]; then

769 EXTRA_VERSION="$EXTRA_VERSION_save"

770 elif ! $RELEASE; then

771 # if there is no patch series, then this is not a lustre specific

772 # kernel. don't make it look like one

773 if $PATCHLESS || [ -n "$SERIES" ]; then

774 EXTRA_VERSION=$(echo $EXTRA_VERSION | sed -e "s/$.*_lustre$\..*/\1/")

775 if ! $PATCHLESS && [ -n "$BUILDID" ]; then

776 EXTRA_VERSION="${EXTRA_VERSION}.${BUILDID}"

777 fi

778 fi

779 fi

780 # EXTRA_VERSION=${EXTRA_VERSION//-/_}

781

782 ALL_ARCHS="$BASE_ARCHS $BIGMEM_ARCHS $BOOT_ARCHS $JENSEN_ARCHS $SMP_ARCHS $BIGSMP_ARCHS $PSERIES64_ARCHS $UP_ARCHS"

783

784 BUILD_ARCHS=

785 for arch in $(uniqify "$ALL_ARCHS"); do

786 if [ -z "$TARGET_ARCHS" ] ||

787 [[ \ $TARGET_ARCHS\ = *\ $arch\ * ]]; then

788 BUILD_ARCHS="$BUILD_ARCHS $arch"

789 fi

790 done

791 [ "$BUILD_ARCHS" ] || usage 1 "No available target archs to build."

792 echo "Building for: $BUILD_ARCHS"

793 }

794

795 tarflags() {

796 local file="$1"

797

798 case "$file" in

799 '')

800 fatal 1 "tarflags(): File name argument missing."

801 ;;

802 *.tar.gz | *.tgz)

803 echo 'zxf'

804 ;;

805 *.tar.bz2)

806 echo 'jxf'

807 ;;

808 *.tar)

809 echo 'xf'

810 ;;

811 *)

812 fatal 1 "tarflags(): Unrecognized tar extension in file: $1"

813 ;;

814 esac

815

816 }

817

818 untar() {

819 local tarfile="$1"

820 shift

821 local extractfile="$@"

822

823 echo "Untarring ${tarfile##*/}..."

824 tar $(tarflags "$tarfile") "$tarfile" $extractfile

825

826 }

827

828 unpack_ofed() {

829

830 if ! untar "$KERNELTREE/OFED-${OFED_VERSION}.tgz"; then

831 return 1

832 fi

833 [ -d OFED ] || ln -sf OFED-[0-9].[0-9]* OFED

834

835 }

836

837 unpack_lustre() {

838

839 untar "$LUSTRE" || fatal 1 "Error unpacking Lustre tarball"

840 [ -d lustre ] || ln -sf lustre-[0-9].[0-9]* lustre

841

842 }

843

844 unpack_mpss() {

845

846 [ -d mpss ] && return 0

847

848 if [ "${MPSS_VERSION%%.*}" = "3" ]; then

849 local ver=${MPSS_VERSION%%-*}

850 local file

851 local i

852 # Check for MPSS 3.x or MPSS 3.x.x

853 if [ ${ver##*.} -eq 0 ]; then

854 ver=${ver%.*}

855 fi

856 for i in $(seq 0 9); do

857 file="$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part$i.tar"

858 if [ -r "$file" ]; then

859 untar "$file" \

860 "mpss-$ver/*/linux-*.tar.bz2" \

861 "mpss-$ver/*/kernel-dev-*.rpm" \

862 "mpss-$ver/*/ofed-driver-*-devel-*.rpm"

863 fi

864 done

865 # Extract kernel configs

866 file=$(find mpss-$ver -type f -path "*/kernel-dev-*.rpm")

867 if ! rpm2cpio "$file" | cpio -idm; then

868 echo "Error extracting MPSS kernel configs"

869 return 1

870 fi

871 # Unpack kernel sources

872 file=$(find mpss-$ver -type f -path "*/linux-*.tar.bz2")

873 if ! untar "$file"; then

874 echo "Error unpacking MPSS kernel sources"

875 return 1

876 fi

877 # Extract OFED headers

878 file=$(find mpss-$ver -type f -path "*/ofed-driver-*-devel-*.rpm")

879 if ! rpm2cpio "$file" | cpio -idm; then

880 echo "Error extracting MPSS OFED headers"

881 return 1

882 fi

883 # Remove unpacked archives to save space

884 rm -rf mpss-$ver

885 # Make link to MPSS kernel sources

886 ln -sf linux-* mpss

887 else

888 local dir="mpss-${MPSS_VERSION}-${MPSS_DISTRO%%-*}"

889

890 mkdir $dir || return 255

891 pushd $dir >/dev/null || return 255

892 if ! untar "$KERNELTREE/mpss_src-${MPSS_VERSION}-${MPSS_DISTRO}-part0.tar" "*/gpl/*full_src*"; then

893 popd >/dev/null

894 rm -rf $dir

895 echo "Error unpacking MPSS tarball 1"

896 return 1

897 fi

898 local file=$(find . -type f -path "*/gpl/*full_src*")

899 if ! untar "$file"; then

900 popd >/dev/null

901 rm -rf $dir

902 echo "Error unpacking MPSS tarball 2"

903 return 1

904 fi

905 popd >/dev/null

906 ln -sf $dir mpss

907 fi

908

909 }

910

911 do_patch_linux() {

912

913 local do_patch=${1:-true}

914

915 FULL_PATCH="$PWD/lustre-kernel-${TARGET}-${EXTRA_VERSION}.patch"

916 [ -f "$FULL_PATCH" ] && rm -f "$FULL_PATCH"

917 $do_patch && pushd linux >/dev/null

918 for series in $SERIES; do

919 echo -n "Applying series $series:"

920 for patchesdir in "$EXTERNAL_PATCHES" "$TOPDIR/lustre/lustre/kernel_patches"; do

921 [ -r "$patchesdir/series/$series" ] || continue

922 SERIES_FILE="$patchesdir/series/$series"

923 for patch in $(<"$SERIES_FILE"); do

924 echo -n " $patch"

925 PATCH_FILE="$patchesdir/patches/$patch"

926 [ -r "$PATCH_FILE" ] || \

927 fatal 1 "Patch $patch does not exist in Lustre tree."

928 cat "$PATCH_FILE" >> "$FULL_PATCH" || {

929 rm -f $FULL_PATCH

930 fatal 1 "Error adding patch $patch to full patch."

931 }

932 if $do_patch; then

933 patch -s -p1 < "$PATCH_FILE" 2>&1 || {

934 rm -f $FULL_PATCH

935 fatal 1 "Error applying patch $patch."

936 }

937 fi

938 done

939 break

940 done

941 echo

942 done

943 $do_patch && popd >/dev/null

944 echo "Full patch has been saved in ${FULL_PATCH##*/}."

945

946 }

947

948 build_lustre() {

949 local linux="$1"

950 local linuxobj="$2"

951

952 cp "$LUSTRE" SOURCES

953

954 pushd lustre >/dev/null

955

956 echo "Building Lustre RPMs for: $BUILD_ARCHS..."

957 local targets arch

958 for arch in $BUILD_ARCHS; do

959 targets="--target $arch $targets"

960 done

961

962 local confoptions=""

963

964 if $PATCHLESS; then

965 confoptions="$confoptions --disable-server"

966 fi

967

968 local rpmbuildopt='-tb'

969 if $NORPM; then

970 rpmbuildopt='-tc'

971 echo NORPM mode. Only compiling.

972 fi

973

974 # If server we now build the spl and zfs modules against the lustre kernel.

975 # These are required prior to the building of lustre server. Client does

976 # not require spl/zfs. Use !PATCHLESS to indicate server which follows the

977 # line above so is at least consistant.

978 if [ $PATCHLESS == false ] && [ "x$ZFSNOTSUPPORTED" == "x" ]; then

979 if ! build_spl_zfs; then

980 popd >/dev/null # pushd lustre

981 return 255

982 fi

983 fi

984

985 if $PATCHLESS; then

986 RPMBUILD_DEFS="$RPMBUILD_DEFS --without servers"

987 if [ -n "$CROSS_SUFFIX" ]; then

988 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"lustre_name lustre-client$CROSS_SUFFIX\""

989 fi

990 fi

991

992 # ditto for the lustre-tests boolean

993 if ! $LUSTRE_TESTS; then

994 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_tests"

995 fi

996

997 if ! $IOKITRPM; then

998 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_iokit"

999 fi

1000

1001 local osd_zfs=""

1002 if $OSDZFSRPM; then

1003 osd_zfs="yes"

1004 fi

1005

1006 local osd_ldiskfs=""

1007 if $OSDLDISKFSRPM; then

1008 osd_ldiskfs="yes"

1009 fi

1010

1011 RPMBUILD_DEFS="$RPMBUILD_DEFS ${FIND_REQUIRES:+--define \"__find_requires $FIND_REQUIRES\"}"

1012 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"configure_args $confoptions ${CONFIGURE_FLAGS}\""

1013 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"kdir $linux\""

1014 RPMBUILD_DEFS="$RPMBUILD_DEFS ${linuxobj:+--define \"kobjdir $linuxobj\"}"

1015 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_tmppath $TMPDIR\""

1016 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_topdir $TOPDIR\""

1017

1018 eval $RPMBUILD $targets $rpmbuildopt "$LUSTRE" $RPMBUILD_DEFS \

1019 ${osd_zfs:+--with zfs} \

1020 ${osd_ldiskfs:+--with ldiskfs} 2>&1 || \

1021 fatal 1 "Error building rpms for $BUILD_ARCHS."

1022

1023 if $DO_SRC; then

1024 if ! eval $RPMBUILD -ts "$LUSTRE" $RPMBUILD_DEFS 2>&1; then

1025 popd >/dev/null

1026 return 255

1027 fi

1028 fi

1029 popd >/dev/null

1030

1031 }

1032

1033 ###

1034 # build_spl_zfs

1035 #

1036 # Fetch spl/zfs from the git repo and prepare for lustre build

1037 #

1038 # Overrides:

1039 # SPLZFSGITREPO - URI of directory where spl.git and zfs.git are located

1040 # SPLZFSTAG - Tag to checkout of clone repositories

1041 # SPLZFSVER - Version to checkout of both (format zfs/spl-$SPLZFSVER)

1042 #

1043 # return 0 if successful, else 255

1044 build_spl_zfs() {

1045 # make sure the RPM build environment is set up

1046 pushd $TOPDIR

1047 create_rpmbuild_dirs

1048 popd

1049

1050 # The spl/zfs spec files expect RPM_BUILD_ROOT to point to the root of the

1051 # destination for the rpms

1052 export RPM_BUILD_ROOT=$TOPDIR

1053 SPLZFSVER=${SPLZFSVER:-0.6.2}

1054 SPLZFSTAG=${SPLZFSTAG:-upstream-master}

1055

1056 # The files expect a kver to be set to the kernel version .

1057 local kver=$(find_linux_release)

1058

1059 # build and install the spl and zfs (and -devel) RPMs for lustre to use

1060 local pkg

1061 for pkg in spl zfs; do

1062

1063 local rpmpkg

1064

1065 [ "$pkg" == "zfs" ] && spldir="$(ls -d $TOPDIR/usr/src/spl-*/|tail -1)"

1066

1067 # need to fetch the repo in order to build it.

1068 # default to github but allow override

1069 git clone ${SPLZFSGITREPO:-"https://github.com/zfsonlinux"}/$pkg.git $pkg 2>&1

1070

1071 pushd $pkg || return 255

1072 if [ -n "$SPLZFSTAG" ]; then

1073 git checkout $SPLZFSTAG

1074 else

1075 git checkout -b lbuild $pkg-$SPLZFSVER

1076 fi

1077

1078 # This differentiates between older zfs versions

1079 if [ -f $pkg-modules.spec.in ]; then

1080 rpmpkg=$pkg-modules

1081 specdir=.

1082 speclist="$pkg.spec $rpmpkg.spec"

1083 else

1084 rpmpkg=kmod-$pkg-devel

1085 specdir=rpm/generic

1086 speclist="$pkg.spec $pkg-kmod.spec $pkg-dkms.spec"

1087 fi

1088

1089 sh autogen.sh || return 255

1090

1091 if ! ./configure --with-linux=${LINUX} --with-linux-obj=${LINUXOBJ:-$LINUX} \

1092 ${spldir:+--with-spl="${spldir}"} 2>&1 ||

1093 ! make dist 2>&1; then

1094 popd

1095 return 255

1096 fi

1097 popd

1098

1099 ln -f $pkg/$pkg-*.tar.gz $TOPDIR/SOURCES ||

1100 error "failed to link $pkg/$pkg-*.tar.gz into $TOPDIR/SOURCES"

1101 if [ -f $pkg/scripts/kmodtool ]; then

1102 ln -f $pkg/scripts/kmodtool $TOPDIR/SOURCES/

1103 fi

1104

1105 local rpmb

1106 if $DO_SRC; then

1107 rpmb=-ba

1108 else

1109 rpmb=-bb

1110 fi

1111

1112 # set search dir for our own kmodtool to find correct

1113 # directories

1114 export KERNELSOURCE=$(dirname ${LINUX})

1115 # Manually build rpms

1116 for spec in $speclist; do

1117 echo "Building RPMs from $pkg/$specdir/$spec"

1118 if ! $RPMBUILD $rpmb $pkg/$specdir/$spec \

1119 --nodeps -v \

1120 --define "require_kdir ${LINUX}" \

1121 ${LINUXOBJ:+--define "require_kobj ${LINUXOBJ}"} \

1122 ${spldir:+--define "require_spldir ${spldir}"} \

1123 --define "kver $kver" \

1124 --define "kernels $kver" \

1125 --define "_tmppath /var/tmp" \

1126 --define "kernelbuildroot $TOPDIR/reused" \

1127 --define "_topdir $TOPDIR" 2>&1; then

1128 return 255

1129 fi

1130 done

1131

1132 # $DO_SRC && mv $pkg*.src.rpm $TOPDIR/SRPMS/

1133 # mv $pkg*.noarch.rpm $TOPDIR/RPMS/noarch/

1134 # mv *$pkg*.$TARGET_ARCH.rpm $TOPDIR/RPMS/$(basearch $TARGET_ARCH)/

1135

1136 # We have built the rpms for the package. Now we need to extract the

1137 # contained files so we can build further things against them

1138 local rpms=$(ls -1 $TOPDIR/RPMS/*/$rpmpkg-*.rpm)

1139

1140 # cpio only extract to pwd so we need to go there.

1141 pushd $TOPDIR

1142 local rpm

1143 for rpm in $rpms; do

1144 rpm2cpio $rpm | cpio -id

1145 done

1146

1147 if [ "$pkg" == "zfs" ]; then

1148 mkdir -p $TOPDIR/zfsdevel

1149 pushd $TOPDIR/zfsdevel

1150 # We also need to extract zfs-devel rpm

1151 local devel_rpm=$(ls -1 $TOPDIR/RPMS/*/$pkg-devel-*.rpm)

1152 rpm2cpio $devel_rpm | cpio -id

1153 popd

1154 CONFIGURE_FLAGS="--with-$pkg-devel=$TOPDIR/zfsdevel ${CONFIGURE_FLAGS}"

1155 fi

1156 popd

1157

1158 CONFIGURE_FLAGS="--with-$pkg=$(ls -d $TOPDIR/usr/src/$pkg-*/|tail -1) ${CONFIGURE_FLAGS}"

1159 CONFIGURE_FLAGS="--with-$pkg-obj=$(ls -d $TOPDIR/usr/src/$pkg-*/$kver*|tail -1) ${CONFIGURE_FLAGS}"

1160 done

1161

1162 OSDZFSRPM=true

1163

1164 return 0

1165 }

1166

1167 prepare_mpss() {

1168

1169 pushd mpss >/dev/null || return 255

1170 if [ "${MPSS_VERSION%%.*}" = "3" ]; then

1171 cp -f ../boot/config-* .config

1172 if ! make ARCH=k1om silentoldconfig ; then

1173 popd >/dev/null

1174 return 1

1175 fi

1176 if ! make ARCH=k1om modules_prepare ; then

1177 popd >/dev/null

1178 return 1

1179 fi

1180 cp -f ../boot/Module.symvers-* Module.symvers

1181 else

1182 if ! make defconfig-miclinux; then

1183 popd >/dev/null

1184 return 1

1185 fi

1186 if ! make -C card/kernel ARCH=k1om modules_prepare ; then

1187 popd >/dev/null

1188 return 1

1189 fi

1190 fi

1191 popd >/dev/null

1192

1193 }

1194

1195 stage() {

1196

1197 [ "$STAGEDIR" ] || return 0

1198

1199 for arch in $BUILD_ARCHS; do

1200 rpmdir="${STAGEDIR}/${CANONICAL_TARGET}-${arch}"

1201 echo "${0##*/}: Copying RPMs into ${rpmdir}"

1202 mkdir -p "${rpmdir}"

1203 cp -v RPMS/${arch}/*.rpm "${rpmdir}"

1204 if [ -d RPMS/noarch ]; then

1205 cp -v RPMS/noarch/*.rpm "${rpmdir}"

1206 fi

1207 done

1208

1209 cp -v "$LUSTRE" "$STAGEDIR"

1210

1211 }

1212

1213 set_rpm_smp_type() {

1214

1215 local infact_arch="${TARGET_ARCH}"

1216

1217 RPMSMPTYPE=""

1218 [ "$infact_arch" == "i586" ] && infact_arch="i686"

1219

1220 local smp_type

1221 for smp_type in $SMP_ARCHS; do

1222 [ $infact_arch == $smp_type ] && RPMSMPTYPE=smp && break

1223 done

1224

1225 for smp_type in $BIGSMP_ARCHS; do

1226 [ $infact_arch == $smp_type ] && RPMSMPTYPE=bigsmp && break

1227 done

1228

1229 for smp_type in $PPC64_ARCHS; do

1230 [ $infact_arch == $smp_type ] && RPMSMPTYPE=ppc64 && break

1231 done

1232

1233 for smp_type in $DEFAULT_ARCHS; do

1234 [ $infact_arch == $smp_type ] && RPMSMPTYPE=default && break

1235 done

1236

1237 }

1238

1239 # This function takes a linux include tree and digs out the linux release

1240 # from it. It is never called directly, only called from the distro

1241 # specific function find_linux_release() in lbuild-{rhel,sles}.

1242 _find_linux_release() {

1243 local SRC="$1"

1244 local LINUXRELEASEHEADER=""

1245

1246 LINUXRELEASEHEADER=$SRC/include/linux/version.h

1247 if [ -s $SRC/include/generated/utsrelease.h ]; then

1248 LINUXRELEASEHEADER=$SRC/include/generated/utsrelease.h

1249 elif [ -s $SRC/include/linux/utsrelease.h ]; then

1250 LINUXRELEASEHEADER=$SRC/include/linux/utsrelease.h

1251 fi

1252

1253 if [ ! -s $LINUXRELEASEHEADER ]; then

1254 fatal 1 "could not find UTS_RELEASE"

1255 fi

1256

1257 sed -ne 's/#define UTS_RELEASE "$.*$"$/\1/p' $LINUXRELEASEHEADER

1258 }

1259

1260 # unpack kernel(/source/devel) RPM

1261 #

1262 # This function and it's setting of $LINUX and $LINUXOBJ is a total hack that

1263 # needs to completely refactored. It completely ingores that $BUILD_ARCHS may

1264 # contain a list of arches for which rpmbuild commands (including the one for

1265 # lustre itself)

1266 unpack_linux_devel_rpm() {

1267 local kernelrpm="${1}"

1268

1269 [ -f "$kernelrpm" ] || return 255

1270 [ -d $TOPDIR/reused ] || mkdir $TOPDIR/reused || return 255

1271

1272 pushd $TOPDIR/reused &>/dev/null || return 255

1273

1274 if ! rpm2cpio < "$kernelrpm" | cpio -id > /dev/null 2>&1; then

1275 return 255

1276 fi

1277

1278 # call a distro specific hook, if available

1279 if type -p unpack_linux_devel_rpm-$DISTRO; then

1280 if ! unpack_linux_devel_rpm-$DISTRO "$kernelrpm"; then

1281 return 255

1282 fi

1283 fi

1284

1285 popd &>/dev/null

1286

1287 find_linux_devel_paths $TOPDIR/reused

1288

1289 return 0

1290

1291 }

1292

1293 build_kernel_ib() {

1294 local linux="$1"

1295 local kib_prefix="$2"

1296 local kib_rpm="$3"

1297

1298 # build kernel-ib{,-devel}/compat-rdma{,-devel}

1299 local K_SRC="K_SRC"

1300 # ofed 1.3 had a bug in the rpm spec

1301 if [ "$OFED_VERSION" = "1.3" ]; then

1302 K_SRC="KSRC"

1303 fi

1304

1305 local OFED_CORE="--with-core-mod --with-ipoib-mod --with-sdp-mod --with-user_mad-mod --with-user_access-mod --with-addr_trans-mod"

1306 local OFED_HARDWARE="--with-mthca-mod --with-mlx4-mod --with-mlx4_en-mod --with-cxgb3-mod --with-nes-mod"

1307

1308 if compare_version $OFED_VERSION 3.0; then

1309 OFED_CORE="$OFED_CORE --with-madeye-mod --with-rds-mod"

1310 else

1311 OFED_HARDWARE="$OFED_HARDWARE --with-cxgb4-mod"

1312 fi

1313

1314 # some I/B drivers are architecture dependent and kernel-ib's configure

1315 # does not figure it out for us ~sigh~

1316 case "$TARGET_ARCH" in

1317 ppc64)

1318 OFED_HARDWARE="$OFED_HARDWARE --with-ehca-mod"

1319 ;;

1320 esac

1321 # we're no longer shipping the OFED iSCSI target

1322 #OFED_ISCSI="--with-srp-mod --with-srp-target-mod"

1323 OFED_ISCSI="--with-srp-mod"

1324 ## ISER module has no backport support as of OFED 1.5 (i.e. only builds on

1325 ##kernels >= 2.6.30)

1326 #if [[ $OFED_VERSION = 1.[0-4]* ]]; then

1327 # OFED_ISCSI="$OFED_ISCSI --with-iser-mod"

1328 #fi

1329

1330 # assume we are just rebuilding the SRPM

1331 local BUILD_TYPE=${BUILD_TYPE:-"--rebuild"}

1332 local SOURCE="${TOPDIR}/OFED/SRPMS/${kib_prefix}-*.src.rpm"

1333

1334 # but switch to building from the SPEC if we need to apply patches

1335 if ls ${TOPDIR}/lustre/contrib/patches/ofed/* >/dev/null; then

1336 BUILD_TYPE="-bb"

1337 rpm --define "_topdir ${TOPDIR}" -ivh $SOURCE

1338 SOURCE="${TOPDIR}/SPECS/${kib_prefix}.spec"

1339 local file ed_fragment1 ed_fragment2 n=1

1340 for file in $(ls ${TOPDIR}/lustre/contrib/patches/ofed/*.patch); do

1341 ed_fragment1="$ed_fragment1

1342 Patch$n: ${file%%*/}"

1343 ed_fragment2="$ed_fragment2

1344 %patch$n -p0"

1345 cp $file ${TOPDIR}/SOURCES

1346 let n=$n+1

1347 done

1348 for file in $(ls ${TOPDIR}/lustre/contrib/patches/ofed/*.ed); do

1349 # Only apply the ed-scripts that should be used for the canonical target

1350 # ed-files in ${TOPDIR}/lustre/contrib/patches/ofed/ have to follow the naming

1351 # convention

1352 # <two-digits>-<descriptive-name>:<canonical_target_1>: ...:<canonical_target_N>.ed

1353 # To apply the same change to multiple canonical target simply specify

1354 # a list of colon separated canoncial target names in the file name.

1355 echo "$file" | grep -q -e ":${CANONICAL_TARGET}:" \

1356 -e ":${CANONICAL_TARGET}.ed$"

1357 if [ $? -eq 0 ] ; then

1358 ed_fragment3="$ed_fragment3

1359 $(cat $file)"

1360 let n=$n+1

1361 fi

1362 done

1363

1364 if [ $n -gt 1 ]; then

1365 ed $SOURCE <<EOF

1366 /^Source: /a

1367 $ed_fragment1

1368 .

1369 /^%setup /a

1370 $ed_fragment2

1371 .

1372 $ed_fragment3

1373 wq

1374 EOF

1375 fi

1376 fi

1377

1378 local linuxrelease=$(find_linux_release)

1379 if compare_version $OFED_VERSION 3.0; then

1380 local OFA_KERNEL_RELEASE=$(echo -n ${linuxrelease} | sed -e 's/-/_/g')

1381 fi

1382 if ! $RPMBUILD $BUILD_TYPE --define 'build_kernel_ib 1' --define 'build_kernel_ib_devel 1' \

1383 ${FIND_REQUIRES:+--define "__find_requires $FIND_REQUIRES"} \

1384 --define "_topdir ${TOPDIR}" --target ${TARGET_ARCH} \

1385 --define "KVERSION ${linuxrelease}" \

1386 --define "$K_SRC ${linux}" \

1387 --define "LIB_MOD_DIR /lib/modules/${linuxrelease}/updates" \

1388 ${OFA_KERNEL_RELEASE:+--define "_release $OFA_KERNEL_RELEASE"} \

1389 --define "configure_options --without-quilt $OFED_CORE $OFED_HARDWARE $OFED_ISCSI" \

1390 ${SOURCE} 2>&1; then

1391 fatal 1 "Error building ${kib_rpm}"

1392 fi

1393

1394 }

1395

1396 store_for_reuse() {

1397 local articles="$1"

1398 local module="$2"

1399 local location="$3"

1400 local signature="$4"

1401 local use_links="$5"

1402

1403 local linkflag=""

1404 if $use_links; then

1405 linkflag="l"

1406 fi

1407

1408 local default_iface=$(/sbin/ip route get 192.1.1.1 | sed -ne 's/.* dev $.*$ * src .*/\1/p')

1409 if [ -z "$default_iface" ]; then

1410 fatal 1 "Failed to determine the default route interface"

1411 fi

1412 local unique_id=$(/sbin/ip addr show dev $default_iface | sed -ne '/ inet /s/ *inet $.*$\/.*/\1/p' | head -1)

1413 if [ -z "$unique_id" ]; then

1414 fatal 1 "Failed to determine a unique id from interface $default_interface"

1415 fi

1416

1417 local finallocation="$location"/"$signature"/"$module"

1418 location="$location"/"$signature-${unique_id}"/"$module"

1419 mkdir -p "$location"

1420 # the cleanup script removes any directory that doesn't have a

1421 # .lastused, so let's try to prevent that as soon as we can

1422 # this solution still slightly racy with the cleanup script

1423 # but the race is a lot tighter now

1424 touch -t 197001010000 "$location/.lastused"

1425 ## use eval/echo here to make sure shell expansions are performed

1426 #if ! cp -a${linkflag} $(eval echo $articles) "$location"; then

1427 local article

1428 for article in $(eval echo $articles); do

1429 if ! cp -a${linkflag} "$article" "$location"; then

1430 error "Failed to copy \"$article\" to \"$location\" in store_for_reuse()"

1431 # rename the cache location so that it's not cached

1432 # product, but is around for analysis

1433 mv "$location"{,-bad-$(date +%s)} ||

1434 error "failed to clean up a failed cache attempt" \

1435 "in \"$location\" -- manual cleanup will be" \

1436 "necessary"

1437 return 1

1438 fi

1439 done

1440

1441 # flag the cache as complete (i.e. in case lbuild was previously

1442 # interrupted while caching)

1443 touch "$location/.lastused"

1444

1445 # put the temporary location into the final location

1446 # (last one wins)

1447 mkdir -p "${finallocation%/*}"

1448 mv "$location" "$finallocation"

1449 rmdir "${location%/*}"

1450 return 0

1451

1452 }

1453

1454 reuse() {

1455 local module="$1"

1456 local dest="$2"

1457 local use_links="${3:-false}"

1458 local signature="$4"

1459

1460 if [ -n "$REUSEBUILD" ] && [ -d "$REUSEBUILD/$signature/$module" ]; then

1461 if [ ! -f "$REUSEBUILD/$signature/$module/.lastused" ]; then

1462 # the .lastused flag is populated at the end of the caching to

1463 # signal that the caching was completed. if that flag is not

1464 # there, then the cache is invalid (and should be removed in fact)

1465 mv "$REUSEBUILD/$signature/$module"{,-bad-$(date +%s)} ||

1466 fatal 1 "failed to clean up a bad cache in location $REUSEBUILD/$signature/$module\" -- manual cleanup will be necessary"

1467 return 1

1468 fi

1469

1470 # so that we know how stale this entry is

1471 touch $REUSEBUILD/$signature/$module/.lastused

1472

1473 if $use_links; then

1474 if ls $REUSEBUILD/$signature/$module/* >/dev/null 2>&1; then

1475 cp -al $REUSEBUILD/$signature/$module/* $dest/

1476 fi

1477 else

1478 # copying is pretty heavy

1479 # cp -a $REUSEBUILD/$signature/$module/* $dest/

1480 # do some creative symlinking instead

1481 local dir

1482 for dir in BUILD SRPMS SPECS; do

1483 if ls $REUSEBUILD/$signature/$module/$dir/* >/dev/null 2>&1; then

1484 ln -s $REUSEBUILD/$signature/$module/$dir/* $dest/$dir

1485 fi

1486 done

1487 # sources have to be copied by file because we need SOURCES to

1488 # be a dir we can write into

1489 # could overrun ls's arg list here

1490 #ls $REUSEBUILD/$signature/$module/SOURCES/* |

1491 find $REUSEBUILD/$signature/$module/SOURCES/ -type f |

1492 xargs ln -t $dest/SOURCES -s

1493

1494 # same for RPMS/* dirs

1495 # could overrun ls's arg list here

1496 #ls $REUSEBUILD/$signature/$module/RPMS/$TARGET_ARCH/* |

1497 local dir

1498 for dir in $REUSEBUILD/$signature/$module/RPMS/*; do

1499 mkdir -p $dest/RPMS/${dir##*/}

1500 find $dir -type f |

1501 xargs ln -t $dest/RPMS/${dir##*/} -s

1502 done

1503 fi

1504 return 0

1505 else

1506 return 1

1507 fi

1508 }

1509

1510 basearch() {

1511 local arch="$1"

1512

1513 if [[ $arch = i[3456]86 ]]; then

1514 echo "i386"

1515 else

1516 echo "$arch"

1517 fi

1518

1519 }

1520

1521 build_kernel_with_srpm() {

1522 local outfd=$1

1523

1524 if [ -z "$outfd" ] || [ $outfd = 1 ]; then

1525 fatal 1 "You must supply a file descriptor to ${FUNCNAME[0]} and it cannot be 1"

1526 fi

1527

1528 # need to generate the patch for this target

1529 do_patch_linux false >&${outfd} # sets global $FULL_PATCH (yeah, yuck)

1530

1531 # get an md5sum of the kernel patch + config for reuse check

1532 # XXX really, there needs to be a signature and a CONFIG_FILE per arch

1533 # in BUILD_ARCHS

1534 local release_str

1535 if $RELEASE; then

1536 local release_str="RELEASE=$RELEASE\n"

1537 fi

1538

1539 if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then

1540 local REUSE_SIGNATURE=$({ echo -en $release_str;

1541 echo $BUILD_GEN;

1542 cat $CONFIG_FILE $TARGET_FILE $FULL_PATCH;

1543 cat $LBUILD_DIR/lbuild $LBUILD_DIR/lbuild-${DISTRO}; } |

1544 md5sum | cut -d" " -f1)

1545 # see if we can link to the reuse pool

1546 # XXX - hrm. i'm not convinced this doesn't belong in the reuse

1547 # "library"

1548 local CAN_LINK_FOR_REUSE=false

1549 touch $REUSEBUILD/$$

1550 if cp -al $REUSEBUILD/$$ $TOPDIR/ 2>/dev/null; then

1551 CAN_LINK_FOR_REUSE=true

1552 fi

1553 rm $REUSEBUILD/$$

1554 fi

1555

1556 # the extra version string to use for the kernel (which might be a reused

1557 # kernel, remember)

1558 local kernel_extra_version=""

1559 if ! $USE_BUILD_CACHE || ! reuse kernel "$TOPDIR" "$CAN_LINK_FOR_REUSE" \

1560 "$REUSE_SIGNATURE"; then

1561 # nothing cached, build from scratch

1562 if [ ! -r "$KERNELDIR/$KERNEL_SRPM" ]; then

1563 echo "Downloading kernel SRPM" >&${outfd}

1564 download_srpm "$CANONICAL_TARGET" "$KERNEL_SRPM" >&${outfd}

1565 fi

1566

1567 if ! rpm -ivh $KERNELDIR/$KERNEL_SRPM \

1568 --define "_topdir $TOPDIR" >&${outfd} 2>&1; then

1569 # should we clean this up or leave it for analysis?

1570 #rm -rf $RPMTOPDIR

1571 fatal 1 "Error installing kernel SRPM."

1572 fi

1573

1574 # put the Lustre kernel patch into the RPM build tree

1575 cp $FULL_PATCH $TOPDIR/SOURCES/linux-${lnxmaj}-lustre.patch

1576 prepare_and_build_srpm >&${outfd} ||

1577 fatal 1 "failed to prepare_and_build_srpm"

1578

1579 if [ -z "$REUSE_SIGNATURE" ]; then

1580 echo "No reuse signature was caculated so not storing the built kernel" >&${outfd}

1581 else

1582 # store the resulting kernel RPM build tree for future use

1583 echo "Storing the built kernel for future reuse" >&${outfd}

1584 if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,SRPMS,RPMS}" \

1585 "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1586 "$CAN_LINK_FOR_REUSE"; then

1587 error "Failed to store kernel RPMS for reuse"

1588 echo "unknown" >&${outfd}

1589 return 1

1590 fi

1591 fi

1592 fi # build reuse

1593

1594 # figure out the EXTRA_VERSION of the kernel we built or are re-using

1595 local KERNEL_RPM

1596 if ! KERNEL_RPM=$(find_rpm "$TOPDIR/RPMS/$TARGET_ARCH/" provides "^kernel(-default)? ="); then

1597 fatal 1 "Failed to find a kernel RPM in $TOPDIR/RPMS/$TARGET_ARCH/"

1598 fi

1599 kernel_extra_version=$(rpm -q --queryformat "%{RELEASE}" -p $TOPDIR/RPMS/$TARGET_ARCH/$KERNEL_RPM)

1600

1601 # should now have the following RPMs

1602 # $TOPDIR/RPMS/$arch/kernel-lustre-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm

1603 # $TOPDIR/RPMS/$arch/kernel-lustre-devel-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm

1604 # $TOPDIR/RPMS/$arch/kernel-lustre-headers-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm

1605 # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-common-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm

1606 # $TOPDIR/RPMS/$arch/kernel-lustre-debuginfo-2.6.18-53.1.21.el5_lustre.1.6.5.1.$arch.rpm

1607

1608 echo $kernel_extra_version

1609 return 0

1610

1611 }

1612

1613 # build OFED

1614 # globals used:

1615 # TOPDIR

1616 # REUSEBUILD, USE_BUILD_CACHE

1617 # CONFIGURE_FLAGS

1618

1619 build_ofed() {

1620 local linux="$1"

1621 local ofed_version="$2"

1622 local kib_prefix

1623 local kib_rpm

1624

1625 # if an ofed version is given, then it means use OFED proper,

1626 # not any vendor specific "inkernel" version

1627 if [ -z "$ofed_version" ]; then

1628 return 0

1629 fi

1630

1631 if [ "$ofed_version" = "inkernel" ]; then

1632 # see if there is a distro specific override for this and use

1633 # that if it exists

1634 # XXX we need to better integrate a distro specific override with

1635 # the rest of this function so that all of the reuse cache

1636 # stuff is leveraged given that 80% of this function is reuse

1637 if type -p build_ofed-${DISTRO}; then

1638 local ofed_location

1639 ofed_location=$(build_ofed-${DISTRO} ${STDOUT})

1640 local rc=${PIPESTATUS[0]}

1641 CONFIGURE_FLAGS="--with-o2ib=${ofed_location} ${CONFIGURE_FLAGS}"

1642 return $rc

1643 else

1644 return 0

1645 fi

1646 elif compare_version $OFED_VERSION 3.0; then

1647 kib_prefix="ofa_kernel"

1648 kib_rpm="kernel-ib"

1649 else

1650 kib_prefix="compat-rdma"

1651 kib_rpm="compat-rdma"

1652 fi

1653

1654 # build kernel-ib/compat-rdma

1655 if $USE_BUILD_CACHE && [ -n "$REUSEBUILD" ]; then

1656 local REUSE_SIGNATURE=$({ echo "$ofed_version";

1657 echo "$(find_linux_release;

1658 echo "$BUILD_GEN")";

1659 cat "${linux}/include/linux/autoconf.h";

1660 cat "$LBUILD_DIR/lbuild" ;

1661 cat "$LBUILD_DIR/lbuild-${DISTRO}"; } |

1662 md5sum | cut -d" " -f1)

1663 # see if we can link to the reuse pool

1664 # XXX - hrm. i'm not convinced this doesn't belong in the reuse

1665 # "library"

1666 local CAN_LINK_FOR_REUSE=false

1667 touch $REUSEBUILD/$$

1668 if cp -al $REUSEBUILD/$$ $TOPDIR/; then

1669 CAN_LINK_FOR_REUSE=true

1670 fi

1671 rm $REUSEBUILD/$$

1672 fi

1673

1674 if ! $USE_BUILD_CACHE || ! reuse ofed "$TOPDIR" "$CAN_LINK_FOR_REUSE" \

1675 "$REUSE_SIGNATURE"; then

1676 if [ -n "$REUSE_SIGNATURE" ]; then

1677 # stash away the existing built articles for a moment

1678 mkdir bak

1679 mv {BUILD,{S,}RPMS,S{OURCE,PEC}S} bak

1680 function mv_back {

1681 pushd bak

1682 find . | cpio -pudlm ..

1683 popd

1684 rm -rf bak

1685 }

1686 create_rpmbuild_dirs

1687 fi

1688 # build it

1689 build_kernel_ib "${linux}" "${kib_prefix}" "${kib_rpm}"

1690

1691 if [ -z "$REUSE_SIGNATURE" ]; then

1692 echo "No reuse signature was caculated so not storing the built ofed"

1693 else

1694 # store the resulting RPM build tree for future use

1695 echo "Storing the built ofed for future reuse"

1696 if ! store_for_reuse "$TOPDIR/{SPECS,SOURCES,BUILD,SRPMS,RPMS}" \

1697 "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1698 "$CAN_LINK_FOR_REUSE"; then

1699 error "Failed to store OFED RPMS for reuse"

1700 mv_back

1701 return 1

1702 fi

1703 # put the stuff we stashed away back

1704 mv_back

1705 fi

1706 fi

1707

1708 pushd "$TOPDIR" >/dev/null

1709 rm -rf ${kib_rpm}-devel

1710 mkdir ${kib_rpm}-devel

1711 cd ${kib_rpm}-devel

1712 # the actual ofed RPMs don't have the -rc$n or -$date string appened that

1713 # might be present on the file

1714 #local linuxrelease=$(find_linux_release)

1715 #ofed_version=$(echo $ofed_version |

1716 # sed -re 's/-(20[0-9]{6,6}-[0-9]{4,4}|rc[0-9]*)$//')

1717 # FIXME

1718 # OFED version will have 'hyphen' for minor release. (e.g. 3.5-1, instead

1719 # of 3.5.1) compat-rdma and compat-rdma-devel could have same version

1720 # number, but currectly not. Once OFED fix this in the future release, we

1721 # can remove following filter.

1722 #ofed_version=$(echo $ofed_version |

1723 # sed -re 's/-([0-9]*-[rR][cC][0-9]*)$//')

1724 #local rpm=$(ls $TOPDIR/RPMS/*/${kib_rpm}-devel-${ofed_version}-${linuxrelease//-/_}.*.rpm)

1725 # I dont' know why we have gone through the trouble to filter out the name

1726 # of the rpm there should only be one ${kib_rpm}-devel built

1727 local rpm=$(ls $TOPDIR/RPMS/*/${kib_rpm}-devel-*.rpm)

1728 if ! rpm2cpio < $rpm | cpio -id; then

1729 fatal 1 "could not unpack the ${kib_rpm}-devel rpm."

1730 fi

1731 CONFIGURE_FLAGS="--with-o2ib=$(pwd)/usr/src/${kib_prefix} ${CONFIGURE_FLAGS}"

1732 popd >/dev/null

1733

1734 }

1735

1736 build_with_srpm() {

1737

1738 if ! $PATCHLESS; then

1739 local kernel_extra_version

1740 if ! kernel_extra_version=$(build_kernel_with_srpm ${STDOUT}); then

1741 fatal 1 "Failed to build the kernel from it's SRPM"

1742 fi

1743

1744 for arch in $BUILD_ARCHS; do

1745 local kernel_devel_rpm

1746 if ! kernel_devel_rpm=$(find_rpm "$TOPDIR/RPMS/$arch/" provides "^$(devel_kernel_name $KERNEL_LUSTRE_NAMING) ="); then

1747 fatal 1 "Failed to find a kernel development RPM in $TOPDIR/RPMS/$arch/"

1748 fi

1749

1750 # install the -devel RPM in preparation for modules builds

1751 if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \

1752 "$TOPDIR/RPMS/$arch/$kernel_devel_rpm"; then

1753 fatal 1 "Could not find the Linux tree in $TOPDIR/RPMS/$arch/$kernel_devel_rpm"

1754 fi

1755 done

1756 else

1757 # need to find and unpack the vendor's own kernel-devel for patchless

1758 # client build

1759 local kernelrpm

1760 if ! kernelrpm=$(find_linux_rpm "-$DEVEL_KERNEL_TYPE"); then

1761 fatal 1 "Could not find the kernel-$DEVEL_KERNEL_TYPE RPM in ${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}"

1762 fi

1763 if ! lnxrel="$lnxrel" unpack_linux_devel_rpm "$kernelrpm" "-"; then

1764 fatal 1 "Could not find the Linux tree in $kernelrpm"

1765 fi

1766 fi

1767

1768 # ~sigh~ have to make copies of and modify some of the rpm

1769 # infrastructure files so that find-requires can find our unpacked

1770 # kernel-devel artifacts

1771 cp $RPM_HELPERS_DIR/{symset-table,find-requires{,.ksyms}} .

1772 FIND_REQUIRES="$(pwd)/find-requires"

1773 chmod 755 {symset-table,find-requires{,.ksyms}}

1774 local tmp="$(pwd)"

1775 tmp="${tmp//\//\\/}"

1776 ed find-requires <<EOF

1777 1a

1778 set -x

1779 .

1780 /|.*find-requires.ksyms/s/|/| bash -x/

1781 g/ [^ ]*\/$find-requires\.ksyms$/s// $tmp\/\1/g

1782 wq

1783 EOF

1784 ed find-requires.ksyms <<EOF

1785 1a

1786 set -x

1787 .

1788 g/\/.*\/$symset-table$/s//$tmp\/\1/g

1789 wq

1790 EOF

1791 ed symset-table <<EOF

1792 1a

1793 set -x

1794 .

1795 g/$\/boot\/$/s//$tmp\/reused\1/g

1796 g/$\/usr\/src\/kernels\/$/s//$tmp\/reused\1/g

1797 wq

1798 EOF

1799

1800 build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||

1801 fatal 1 "error building OFED"

1802

1803 # now build Lustre

1804 if build_lustre "$LINUX" "$LINUXOBJ"; then

1805 # the build worked. resolve any symlinked files (i.e. from reuse)

1806 # in RPMS/$arch to real files so that that that huge mess of

1807 # complication known as LTS can copy them yet somewhere else.

1808 # is it any wonder this whole process is so damn so? anyone ever

1809 # heard of hardlinks? it's this cool new thing that allows you save

1810 # tons of time and space by creating... well you can go read about

1811 # them if you have not heard about them yet.

1812 # can i say how much the implemenation of all of this really impedes

1813 # RPM reuse?

1814 local dir

1815 for dir in RPMS/*; do

1816 pushd $dir

1817 for file in $(ls); do

1818 if [ -h $file ]; then

1819 cp $file foo

1820 mv foo $file

1821 fi

1822 done

1823 popd

1824 done

1825 # also, for i?86, make sure all of the RPMs are in RPMS/$TARGET_ARCH

1826 # as that's where LTS expects to find them

1827 for dir in RPMS/*; do

1828 if [ $dir = RPMS/$TARGET_ARCH ]; then

1829 continue

1830 fi

1831 pushd $dir

1832 local files=$(ls)

1833 if [ -n "$files" ]; then

1834 cp -al $files ../$TARGET_ARCH

1835 fi

1836 popd

1837 done

1838 else

1839 return 1

1840 fi

1841

1842 }

1843

1844 create_rpmbuild_dirs() {

1845

1846 [ -d RPMS ] || mkdir RPMS

1847 for arch in $BUILD_ARCHS; do

1848 if [[ $arch = i?86 ]]; then

1849 # some stupidity in the sles11 kernel spec requires an RPMS/i386

1850 # even if the target arch is i686

1851 [ -d RPMS/i386 ] || mkdir RPMS/i386

1852 fi

1853 [ -d RPMS/$arch ] || mkdir RPMS/$arch

1854 done

1855 [ -d RPMS/noarch ] || mkdir RPMS/noarch

1856 [ -d BUILD ] || mkdir BUILD

1857 [ -d SOURCES ] || mkdir SOURCES

1858 [ -d SPECS ] || mkdir SPECS

1859 [ -d SRPMS ] || mkdir SRPMS

1861 }

1863 new_list() {

1865 echo ""

1867 }

1869 add_list() {

1870 local list="$1"

1871 local item="$2"

1872

1873 echo "$list $item"

1874

1875 }

1876

1877 is_list_member() {

1878 local list="$1"

1879 local item="$2"

1880

1881 [[ $list\ == *\ $item\ * ]]

1882

1883 }

1884

1885 #########################################################################

1886 # Generate a backtrace through the call stack.

1887 #

1888 # Input: None

1889 # Output: None

1890 #########################################################################

1891 backtrace() {

1892 local strip=${1:-1}

1893

1894 local funcname="" sourcefile="" lineno="" n

1895

1896 echo "Call stack: (most recent first)"

1897 for (( n = $strip ; n < ${#FUNCNAME[@]} ; ++n )) ; do

1898 funcname=${FUNCNAME[$n - 1]}

1899 sourcefile=$(basename ${BASH_SOURCE[$n]})

1900 lineno=${BASH_LINENO[$n - 1]}

1901 if [ $n = 1 ]; then

1902 let lineno-=11

1903 fi

1904 # Display function arguments

1905 if [[ ! -z "${BASH_ARGV[@]}" ]]; then

1906 local args newarg j p=0

1907 for (( j = ${BASH_ARGC[$n - 1]}; j > 0; j-- )); do

1908 newarg=${BASH_ARGV[$j + $p - 1]}

1909 args="${args:+${args} }'${newarg}'"

1910 done

1911 let p+=${BASH_ARGC[$n - 1]}

1912 fi

1913 echo " ${funcname} ${args:+${args} }at ${sourcefile}:${lineno}"

1914 done

1915

1916 echo

1917 echo "BEGIN BACKTRACE"

1918

1919 #echo ${BASH_LINENO[*]}

1920 #echo ${BASH_SOURCE[*]}

1921 #echo ${FUNCNAME[*]}

1922 local i=$((${#FUNCNAME[@]} - 1))

1923 while [ $i -ge 0 ]; do

1924 local lineno=${BASH_LINENO[$i]}

1925 if [ $i = 0 ]; then

1926 let lineno-=11

1927 fi

1928 local SOURCELINE="${BASH_SOURCE[$i + 1]}:${lineno}"

1929 # Can't figure out how to get function args from other frames...

1930 local FUNCTION="${FUNCNAME[$i]}()"

1931 echo "$SOURCELINE:$FUNCTION"

1932 i=$((i - 1))

1933 done

1934

1935 echo "END BACKTRACE"

1936

1937 echo $BACKTRACE

1938

1939 }

1940

1941 seen_list=$(new_list)

1942 trap 'set +x;

1943 echo "An unexpected error has occurred at ${BASH_SOURCE[0]##*/}:$((LINENO-1)).

1944 Unfortunately the above line number in the message may or may not be correct,

1945 but details have been send to the lbuild maintainer. Attempting to continue."; (echo "Untrapped error"

1946 echo

1947 # have we seen this one

1948 echo "checking seen list for ${BASH_SOURCE[0]}:${BASH_LINENO[0]}"

1949

1950 if is_list_member "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}"; then

1951 echo "seen this one already"

1952 else

1953 seen_list=$(add_list "$seen_list" "${BASH_SOURCE[0]}:${BASH_LINENO[0]}")

1954 fi

1955 backtrace

1956 ) ; set $xtrace' ERR

1957 set -E

1958

1959 [ -r ~/.lbuildrc ] && . ~/.lbuildrc

1960

1961 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 -- "$@")

1962

1963 if [ $? != 0 ]; then

1964 usage 1

1965 fi

1966

1967 eval set -- "$options"

1968

1969 while [ "$1" ]; do

1970 case "$1" in

1971 '')

1972 usage 1

1973 ;;

1974 --ccache)

1975 CCACHE='ccache'

1976 shift

1977 ;;

1978 -D)

1979 DATE=$2

1980 shift 2

1981 ;;

1982 --external-patches)

1983 EXTERNAL_PATCHES=$2

1984 shift 2

1985 ;;

1986 --extraversion)

1987 EXTRA_VERSION=$2

1988 shift 2

1989 ;;

1990 --help | -h)

1991 usage 0

1992 ;;

1993 --kerneldir)

1994 KERNELDIR=$2

1995 shift 2

1996 ;;

1997 --kerneltree)

1998 if ! KERNELTREE=$(canon_path "$2"); then

1999 fatal 1 "Could not determine the canonical location of $2"

2000 fi

2001 shift 2

2002 ;;

2003 --linux | --with-linux)

2004 if ! LINUX=$(canon_path "$2"); then

2005 fatal 1 "Could not determine the canonical location of $2"

2006 fi

2007 shift 2

2008 ;;

2009 --distro)

2010 DISTRO=$2

2011 shift 2

2012 ;;

2013 --reuserpm)

2014 REUSERPM=$2

2015 shift 2

2016 ;;

2017 --reusebuild)

2018 if ! REUSEBUILD=$(canon_path "$2"); then

2019 fatal 1 "Could not determine the canonical location of $2"

2020 fi

2021 shift 2

2022 ;;

2023 --norpm)

2024 NORPM=true

2025 shift

2026 ;;

2027 --ldiskfs)

2028 echo "WARNING: \"--ldiskfs\" is deprecated" > 2

2029 shift

2030 ;;

2031 --noiokit)

2032 IOKITRPM=false

2033 shift

2034 ;;

2035 --patchless)

2036 PATCHLESS=true

2037 shift

2038 ;;

2039 --kernelrpm)

2040 if ! KERNELRPMSBASE=$(canon_path "$2"); then

2041 fatal 1 "Could not determine the canonical location of $2"

2042 fi

2043 shift 2

2044 ;;

2045 --timestamp)

2046 TIMESTAMP=$2

2047 shift 2

2048 ;;

2049 --lustre)

2050 if ! LUSTRE=$(canon_filepath "$2"); then

2051 fatal 1 "Could not determine the canonical location of $2"

2052 fi

2053 shift 2

2054 ;;

2055 --nodownload)

2056 DOWNLOAD=false

2057 shift 1

2058 ;;

2059 --nosrc)

2060 DO_SRC=false

2061 shift 1

2062 ;;

2063 --ofed-version)

2064 OFED_VERSION="$2"

2065 shift 2

2066 ;;

2067 --mpss-version)

2068 MPSS_VERSION="$2"

2069 shift 2

2070 ;;

2071 --publish)

2072 shift

2073 ;;

2074 --release)

2075 RELEASE=true

2076 shift

2077 ;;

2078 --src)

2079 DO_SRC=true

2080 shift 1

2081 ;;

2082 --stage)

2083 STAGEDIR=$2

2084 shift 2

2085 ;;

2086 --tag)

2087 shift 2

2088 echo "WARNING: \"--tag\" is deprecated" > 2

2089 ;;

2090 --target)

2091 TARGET=$2

2092 shift 2

2093 ;;

2094 --target-archs)

2095 TARGET_ARCHS=$2

2096 shift 2

2097 ;;

2098 --xen)

2099 XEN=true

2100 shift

2101 ;;

2102 --set-value)

2103 eval $2

2104 shift 2

2105 ;;

2106 --)

2107 shift

2108 # there are actually some lustre configure flags that we need to

2109 # handle ourselves (but we still give them to configure)

2110 if [[ \ $@\ == *\ --disable-tests\ * ]]; then

2111 LUSTRE_TESTS=false

2112 fi

2113 CONFIGURE_FLAGS=$@

2114 CONFIGURE_FLAGS="$CONFIGURE_FLAGS --enable-liblustre --enable-liblustre-tests"

2115 break

2116 ;;

2117 *)

2118 usage 1 "Unrecognized option: $1"

2119 ;;

2120 esac

2121 done

2122

2123 check_options

2124

2125 unpack_lustre

2126

2127 # XXX - should we _always_ get the buildid from the META file? what are the

2128 # other (i.e. non-lustre-tarball use cases of lbuild)?

2129 BUILDID=$(sed -ne '/^BUILDID =/s/.*= *//p' lustre/META)

2130 VERSION=$(sed -ne '/^VERSION =/s/.*= *//p' lustre/META)

2131

2132 load_target

2133

2134 if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then

2135 download_ofed

2136 unpack_ofed || fatal 1 "Error unpacking OFED tarball"

2137 fi

2138

2139 if [ -n "$MPSS_VERSION" ]; then

2140 [ -z "$MPSS_DISTRO" ] && MPSS_DISTRO=$(autodetect_distro)

2141

2142 MPSS_INFO=$(mktemp -u mpss-info-XXXXXXXXXX.html)

2143 download_mpss_info "$MPSS_INFO"

2144

2145 if [ "$MPSS_VERSION" = "last" ]; then

2146 MPSS_VERSION=$(parse_mpss_info "$MPSS_INFO" "" ${MPSS_DISTRO})

2147 [ -z "$MPSS_VERSION" ] && fatal 1 "Could not determine the last MPSS version"

2148 elif [[ $MPSS_VERSION != [0-9].[0-9].[0-9]*-[0-9]* ]]; then

2149 fatal 1 "Incorrect MPSS version $MPSS_VERSION"

2150 fi

2151

2152 download_mpss "$MPSS_INFO"

2153 [ -r "$MPSS_INFO" ] && rm -f "$MPSS_INFO"

2154 echo "Building with MPSS $MPSS_VERSION"

2155 unpack_mpss || fatal 1 "Error unpacking MPSS tarballs"

2156 prepare_mpss || fatal 1 "Error preparing MPSS for kernel modules build"

2157

2158 if [ -z "$MPSS_OFED" ]; then

2159 MPSS_OFED=$(find $PWD -type f -path "*/ofed-driver-*/Module.symvers")

2160 if [ -n "$MPSS_OFED" ]; then

2161 MPSS_OFED="--with-o2ib=$(dirname $MPSS_OFED)"

2162 else

2163 MPSS_OFED="--without-o2ib"

2164 fi

2165 fi

2166

2167 # disable unsupported parts:

2168 PATCHLESS=true

2169 IOKITRPM=false

2170 LDISKFSRPM=false

2171 ZFSNOTSUPPORTED="yes"

2172

2173 # define variables for cross compilation:

2174 CROSS_SUFFIX="-mic"

2175 if [ "${MPSS_VERSION%%.*}" = "3" ]; then

2176 CC_TARGET_ARCH=k1om-mpss-linux

2177 LINUX="$TOPDIR/mpss"

2178 else

2179 CC_TARGET_ARCH=x86_64-k1om-linux

2180 LINUX="$TOPDIR/mpss/card/kernel"

2181 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_requires intel-mic-gpl = ${MPSS_VERSION%%-*}\""

2182 fi

2183 CONFIGURE_FLAGS="$CONFIGURE_FLAGS $MPSS_OFED --host=$CC_TARGET_ARCH --build=x86_64-pc-linux"

2184 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"post_script build/gen_filelist.sh\""

2185 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"make_args ARCH=k1om CROSS_COMPILE=${CC_TARGET_ARCH}-\""

2186 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_path ${CROSS_PATH:=/opt/lustre/${VERSION}/${CC_TARGET_ARCH}}\""

2187 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"rootdir %{cross_path}\""

2188 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_prefix %{cross_path}/usr\""

2189 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_mandir %{_prefix}/share/man\""

2190 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"_sysconfdir %{cross_path}/etc\""

2191 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"kmoddir extra\""

2192

2193 # redefine CC for proper ./configure during rpmbuild

2194 export CC=${CC_TARGET_ARCH}-gcc

2195 fi

2196

2197 # make sure the RPM build environment is set up

2198 create_rpmbuild_dirs

2199

2200 # if an unpacked kernel source tree was given on the command line

2201 # just build lustre with it (nothing distro kernel specific here)

2202 if [ -n "$LINUX" ]; then

2203 find_linux_release() {

2204 _find_linux_release $LINUX

2205 }

2206 build_ofed "${LINUXOBJ:-$LINUX}" "$OFED_VERSION" ||

2207 fatal 1 "error building OFED"

2208 build_lustre "$LINUX" "$LINUXOBJ"

2209 else

2210 if [ ! -f "${LBUILD_DIR}/lbuild-$DISTRO" ]; then

2211 fatal 1 "${LBUILD_DIR}/lbuild-$DISTRO not found"

2212 fi

2213 source ${LBUILD_DIR}/lbuild-$DISTRO

2214 build_with_srpm || fatal 1 "Failed to build_with_srpm"

2215 fi

2216

2217 stage