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 the dir that should be used to store reuse products

64 REUSEBUILD=

65 # should cached products be used or force rebuilding?

66 USE_BUILD_CACHE=true

67 # what does this do exactly? does it imply no kernel build?

68 NORPM=false

69 IOKITRPM=true

70 OSDLDISKFSRPM=true

71 OSDZFSRPM=false

72 SMPTYPES="smp bigsmp default ''"

73 PATCHLESS=false

74 WITH_ZFS=""

75 XEN=false

76 LINUXOBJ=

77 DISTRO=

78 KERNELTREE=

79 # default to not adding -lustre- into the kernel RPM package names

80 KERNEL_LUSTRE_NAMING=false

81 # default not use kabi check.

82 USE_KABI=false

84 # patchless build

85 KERNELRPMSBASE=

86 RPMSMPTYPE=

88 # from target file

89 SERIES=

90 BASE_ARCHS=

91 BIGMEM_ARCHS=

92 BOOT_ARCHS=

93 JENSEN_ARCHS=

94 SMP_ARCHS=

95 BIGSMP_ARCHS=

96 PSERIES64_ARCHS=

97 UP_ARCHS=

99 # not in the target file any more

100 CONFIG=

101

102 # build the lustre-tests rpm?

103 LUSTRE_TESTS=true

104

105 DATE=$(date)

106

107 RPMBUILD=

108

109 export CC=${CC:-gcc}

110

111 # Readlink is not present on some older distributions: emulate it.

112 readlink() {

113 local path=$1 ll

114

115 if [ -L "$path" ]; then

116 ll="$(LC_ALL=C ls -l "$path" 2> /dev/null)" &&

117 echo "${ll/* -> }"

118 else

119 return 1

120 fi

121 }

122

123 usage() {

124 cat <<EOF

125 Usage: ${0##*/} [OPTION]... [-- <lustre configure options>]

126

127 --external-patches=EXTERNAL_PATCHES

128 Directory similar to lustre/lustre/kernel_patches/ that lbuild should

129 look for seres and config files in before looking in the lustre

130 tree.

131

132 --extraversion=EXTRAVERSION

133 Text to use for the rpm release and kernel extraversion.

134

135 --timestamp=TIMESTAMP

136 Date of building lustre in format YYYYMMDDhhmmss

137

138 --reusebuild=DIR

139 Try to reuse old kernel builds from DIR

140

141 --kernelrpm=DIR

142 Path to distro kernel RPM collection

143

144 --ccache

145 Use ccache

146

147 --norpm

148 Do not build RPMs (compile only mode)

149

150 --patchless

151 Build lustre client only

152

153 --distro=DISTRO

154 Which distro using. Autodetect by default

155

156 --kerneldir=KERNELDIR

157 Directory containing Linux source tarballs referenced by target

158 files.

159

160 --kerneltree=KERNELTREE

161 Directory containing dirs with Linux source tarballs referenced by target

162 files. Dir names in format kernel version ('2.6.9', etc.)

163

164 --linux=LINUX --with-linux=LINUX

165 Directory of Linux kernel sources. When this option is used, only

166 Lustre modules and userspace are built.

167

168 --lustre=LUSTRE

169 Path to an existing lustre source tarball to use.

170

171 --nodownload

172 Do not try to download a kernel from downloads.hpdd.intel.com

173

174 --nosrc

175 Do not build a .src.rpm, a full kernel patch, or a patched kernel

176 tarball.

177

178 --ldiskfs

179 Build with ldiskfs support. (Deprecated, always true)

180

181 --noiokit

182 Do not build lustre-iokit RPM. Now true by default

183

184 --publish

185 Unused.

186

187 --release

188 Specifies that the files generated do not include timestamps, and

189 that this is an official release.

190

191 --disable-zfs

192 Build Lustre without ZFS.

193

194 --src

195 Build a .src.rpm, a full kernel patch, and a patched kernel tarball.

196

197 --stage=DIR

198 Directory used to stage packages for release. RPMs will be placed

199 more or less in DIR/<target>-<arch>, and the tarball will be

200 placed in DIR.

201

202 --target=TARGET

203 The name of the target to build. The available targets are listed

204 below.

205

206 --target-archs=TARGET_ARCHS

207 A (space delimited) list of architectures to build. By default,

208 all of the archs supported by the TARGET will be built, in

209 addition to a .src.rpm. This option can limit those, for machines

210 that can only build certain archs or if you only want a certain

211 arch built (for testing, or a one-off kernel).

212

213 Also note that by using a non-"base" arch (eg, i386) only kernels

214 will be built - there will be no lustre-lite-utils package.

215

216 --xen

217 Builds a Xen domX kernel.

218

219 --set-value

220 Sets a variable to a given value.

221

222 EOF

223

224 # list_targets

225

226 fatal "$1" "$2"

227 }

228

229 # canonicalize a relative path to a file

230 canon_filepath() {

231 local PATH="$1"

232

233 if [ ! -f "$PATH" ]; then

234 return 1

235 fi

236

237 local FILE=${PATH##*/}

238 local DIR=${PATH%/*}

239

240 echo $(canon_path "$DIR")/$FILE

241 return 0

242 }

243

244 # canonicalize a relative path to a dir

245 canon_path() {

246 local PATH="$1"

247

248 if [ ! -d "$PATH" ]; then

249 return 1

250 fi

251

252 pushd "$PATH" >/dev/null || return 1

253 local CANONPATH=$PWD

254 popd >/dev/null

255

256 echo "$CANONPATH"

257 return 0

258 }

259

260 check_options() {

261

262 if [ -z "$LUSTRE" -o ! -r "$LUSTRE" ]; then

263 usage 1 "Could not find Lustre source tarball '$LUSTRE'."

264 fi

265

266 if [ -z "$DISTRO" ] ; then

267 DISTRO=$(autodetect_distro)

268 # remove separator

269 DISTRO=${DISTRO/-/}

270 fi

271 DISTROMAJ=${DISTRO%%.*}

272

273 [ -z "$TARGET" ] && TARGET=$(autodetect_target "$DISTRO")

274

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

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

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

278

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

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

281

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

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

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

285 fi

286

287 case $TARGET in

288 3.10-rhel7)

289 CANONICAL_TARGET="rhel7"

290 ;;

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 if [ -z "$target" ]; then

406 fatal 1 "fetch_url() called without a target to fetch to"

407 fi

408

409 if [ -d $target ]; then

410 target+="/${url##*/}"

411 fi

412

413 local rc=0

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

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

416 rc=${PIPESTATUS[0]}

417 fi

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

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

420 rc=${PIPESTATUS[0]}

421 fi

422 else

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

424 fi

425

426 return $rc

427

428 }

429

430 download_srpm() {

431 local target=$1

432 local srpm=$2

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

434

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

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

437 if $DOWNLOAD; then

438 local location="https://downloads.hpdd.intel.com/public/kernels/$target/old"

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

440 if type -p kernel_srpm_location; then

441 location=$(kernel_srpm_location)

442 fi

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

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

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

446 rm -f $KERNELDIR/$srpm

447 # punt to a distro specific method if it exists

448 if ! type -p download_srpm-$DISTROMAJ; then

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

450 else

451 if ! download_srpm-$DISTROMAJ "$target" "$srpm" "$force"; then

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

453 fi

454 fi

455 fi

456 else

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

458 fi

459 fi

460

461 }

462

463 download_file() {

464 local from="$1"

465 local to="$2"

466 local force="$3"

467

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

469

470 if [ -d $to ]; then

471 to="$to/$file"

472 fi

473

474 local semaphore="$to-downloading"

475

476 is_downloading() {

477 if [ ! -f $semaphore ]; then

478 return 1

479 fi

480

481 # make sure the download has not been aborted

482 local now=$(date +%s)

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

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

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

486 if [ $staleness -gt 60 ]; then

487 return 1

488 fi

489

490 return 0

491 }

492

493 is_downloaded() {

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

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

496 if [ -f $semaphore ]; then

497 return 1

498 fi

499

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

501 return 0

502 fi

503

504 return 1

505 }

506

507 if $force || ! is_downloaded; then

508 if is_downloading; then

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

510 while is_downloading; do

511 echo "Waiting for $to to finish downloading"

512 sleep 60

513 done

514 if is_downloaded; then

515 return 0

516 else

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

518 fi

519

520 fi

521

522 if $DOWNLOAD; then

523 echo "Downloading $from..."

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

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

526 touch $semaphore

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

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

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

530 fi

531 rm -f $semaphore

532 delete_exit_trap "download"

533 else

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

535 fi

536 fi

537

538 return 0

539

540 }

541

542 download_ofed() {

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

544

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

546 return 0

547 fi

548

549 local OFED_BASE_VERSION=$OFED_VERSION

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

551 OFED_BASE_VERSION=${OFED_VERSION%.*}

552 fi

553

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

555

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

557 local Mmv

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

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

560 fi

561

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

563 local Mmv

564 Mmv=${OFED_VERSION/daily-/}

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

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

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

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

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

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

571 fi

572 fi

573

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

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

576

577 }

578

579 parse_mpss_info() {

580 local file="$1"

581 local build="$2"

582 local distro="$3"

583

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

585

586 # convert to MPSS distro naming

587 distro=${distro/sles/suse}

588 distro_name=${distro%%-*}

589

590 # extract links from MPSS info file

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

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

593 grep '.intel.com/' | \

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

595 grep '.tar')

596 local res2=""

597 local res3=""

598 for url in $urls; do

599 local ver2=""

600 local ver3=""

601 # Try to match with MPSS 3.3 package

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

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

604 ver3=${ver3%%-linux.tar}

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

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

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

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

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

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

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

612 ver3=${ver3%%.tar}

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

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

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

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

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

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

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

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

621 fi

622

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

624 ver3="${ver3}-0"

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

626 res3="$ver3"

627 elif [ "${build%%-*}" = "${ver3%%-*}" ]; then

628 res3="$res3 $url"

629 fi

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

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

632 res2="$ver2"

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

634 res2="$res2 $url"

635 fi

636 fi

637

638 done

639

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

641 # return a last version of MPSS

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

643 echo "$res3"

644 else

645 echo "$res2"

646 fi

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

648 # return URLs from MPSS info file

649 echo "$res3"

650 else

651 # return URLs from MPSS info file

652 echo "$res2"

653 fi

654 }

655

656 # Get public information about last releases of

657 # Intel Manycore Platform Software Stack (MPSS)

658 download_mpss_info() {

659 local file="$1"

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

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

662

663 download_file "$url" "$file" "$force"

664 }

665

666 download_mpss() {

667 local file="$1"

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

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

670

671 [ -z "$urls" ] && return 0

672

673 local url

674 local i=0

675 for url in $urls; do

676 file="$KERNELTREE/mpss_src-${MPSS_VER}-${MPSS_BLD}-${MPSS_DISTRO}-part$i.tar"

677 download_file "$url" "$file" "$force"

678 i=$((i+1))

679 done

680 }

681

682 load_target() {

683

684 EXTRA_VERSION_save="$EXTRA_VERSION"

685 for patchesdir in "$EXTERNAL_PATCHES" \

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

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

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

689 done

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

691

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

693

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

695 # the target file specifies

696 local env_OFED_VERSION="$OFED_VERSION"

697

698 . "$TARGET_FILE"

699

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

701 OFED_VERSION="$env_OFED_VERSION"

702 fi

703

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

705 if $XEN; then

706 OFED_VERSION=""

707 fi

708

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

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

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

712

713 # CC might have been overwritten in TARGET_FILE

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

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

716 fi

717

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

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

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

721 fi

722

723 # verify the series is available

724 if [ "$SERIES" ]; then

725 for series in $SERIES; do

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

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

728 done

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

730 done

731 fi

732

733 # set the location of the .config file

734 local XENPOSTFIX=""

735 if $XEN; then

736 XENPOSTFIX="-xen"

737 fi

738

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

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

741 fi

742

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

744

745 # remember the EXTRA_VERSION before we diddle it here

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

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

748 # a new variable.

749 PRISTINE_EXTRA_VERSION=$EXTRA_VERSION

750

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

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

753 fi

754

755 if [ "$EXTRA_VERSION_save" ]; then

756 EXTRA_VERSION="$EXTRA_VERSION_save"

757 elif ! $RELEASE; then

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

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

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

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

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

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

764 fi

765 fi

766 fi

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

768

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

770

771 BUILD_ARCHS=

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

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

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

775 BUILD_ARCHS="$BUILD_ARCHS $arch"

776 fi

777 done

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

779 echo "Building for: $BUILD_ARCHS"

780 }

781

782 tarflags() {

783 local file="$1"

784

785 echo -n '--wildcards '

786 case "$file" in

787 '')

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

789 ;;

790 *.tar.gz | *.tgz)

791 echo '-zxf'

792 ;;

793 *.tar.bz2)

794 echo '-jxf'

795 ;;

796 *.tar)

797 echo '-xf'

798 ;;

799 *)

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

801 ;;

802 esac

803

804 }

805

806 untar() {

807 local tarfile="$1"

808 shift

809 local extractfile="$@"

810

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

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

813

814 }

815

816 unpack_ofed() {

817

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

819 return 1

820 fi

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

822

823 }

824

825 unpack_lustre() {

826

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

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

829

830 }

831

832 unpack_mpss() {

833

834 [ -d mpss ] && return 0

835

836 if [ "$MPSS_MAJ" = "3" ]; then

837 local file

838 local i

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

840 file="$KERNELTREE/mpss_src-${MPSS_VER}-${MPSS_BLD}-${MPSS_DISTRO}-part$i.tar"

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

842 untar "$file" \

843 "mpss-$MPSS_VER/*/linux-*.tar.bz2" \

844 "mpss-$MPSS_VER/*/kernel-dev-*.rpm" \

845 "mpss-$MPSS_VER/*/ofed-driver-devel-*.rpm" \

846 "mpss-$MPSS_VER/*/ofed-driver-*-devel-*.rpm"

847 fi

848 done

849 # Extract kernel configs

850 file=$(find mpss-$MPSS_VER -type f -path "*/kernel-dev-*.rpm" -print -quit)

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

852 echo "Error extracting MPSS kernel configs"

853 return 1

854 fi

855 # Unpack kernel sources

856 file=$(find mpss-$MPSS_VER -type f -path "*/linux-*.tar.bz2" -print -quit)

857 if ! untar "$file"; then

858 echo "Error unpacking MPSS kernel sources"

859 return 1

860 fi

861 # Extract OFED headers

862 file=$(find mpss-$MPSS_VER -type f -path "*/ofed-driver-*-devel-*.rpm" -print -quit)

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

864 # Name was changed in MPSS 3.3

865 file=$(find mpss-$MPSS_VER -type f -path "*/ofed-driver-devel-*.rpm" -print -quit)

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

867 echo "Error extracting MPSS OFED headers"

868 return 1

869 fi

870 fi

871 # Remove unpacked archives to save space

872 rm -rf mpss-$MPSS_VER

873 # Make link to MPSS kernel sources

874 ln -sf linux-* mpss

875 else

876 local dir="mpss-${MPSS_VER}-${MPSS_BLD}-${MPSS_DISTRO%%-*}"

877

878 mkdir $dir || return 255

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

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

881 popd >/dev/null

882 rm -rf $dir

883 echo "Error unpacking MPSS tarball 1"

884 return 1

885 fi

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

887 if ! untar "$file"; then

888 popd >/dev/null

889 rm -rf $dir

890 echo "Error unpacking MPSS tarball 2"

891 return 1

892 fi

893 popd >/dev/null

894 ln -sf $dir mpss

895 fi

896

897 }

898

899 do_patch_linux() {

900

901 local do_patch=${1:-true}

902

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

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

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

906 for series in $SERIES; do

907 echo -n "Applying series $series:"

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

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

910 SERIES_FILE="$patchesdir/series/$series"

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

912 echo -n " $patch"

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

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

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

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

917 rm -f $FULL_PATCH

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

919 }

920 if $do_patch; then

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

922 rm -f $FULL_PATCH

923 fatal 1 "Error applying patch $patch."

924 }

925 fi

926 done

927 break

928 done

929 echo

930 done

931 $do_patch && popd >/dev/null

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

933

934 }

935

936 build_lustre() {

937 local linux="$1"

938 local linuxobj="$2"

939

940 cp "$LUSTRE" SOURCES

941

942 pushd lustre >/dev/null

943

944 if ! build_lustre_dkms; then

945 popd >/dev/null # pushd lustre

946 return 255

947 fi

948

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

950 local targets arch

951 for arch in $BUILD_ARCHS; do

952 targets="--target $arch $targets"

953 done

954

955 local rpmbuildopt='-tb'

956 if $NORPM; then

957 rpmbuildopt='-tc'

958 echo NORPM mode. Only compiling.

959 fi

960

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

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

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

964 # line above so is at least consistant.

965 if [ $PATCHLESS == false ] && [ "x$WITH_ZFS" == "x" ]; then

966 if ! build_spl_zfs; then

967 popd >/dev/null # pushd lustre

968 return 255

969 fi

970 fi

971

972 if $PATCHLESS; then

973 RPMBUILD_DEFS="$RPMBUILD_DEFS --without servers"

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

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

976 fi

977 fi

978

979 # ditto for the lustre-tests boolean

980 if ! $LUSTRE_TESTS; then

981 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_tests"

982 fi

983

984 if ! $IOKITRPM; then

985 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_iokit"

986 fi

987

988 local osd_zfs=""

989 if $OSDZFSRPM; then

990 osd_zfs="yes"

991 fi

992

993 local osd_ldiskfs=""

994 if $OSDLDISKFSRPM; then

995 osd_ldiskfs="yes"

996 fi

997

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

999 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"configure_args ${CONFIGURE_FLAGS}\""

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

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

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

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

1004

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

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

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

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

1009

1010 if $DO_SRC; then

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

1012 popd >/dev/null

1013 return 255

1014 fi

1015 fi

1016 popd >/dev/null

1017

1018 }

1019

1020 build_lustre_dkms() {

1021 [ -n "$MPSS_VERSION" ] && return 0

1022 local ver=$(eval echo $(awk '/LUSTRE_VERSION_STRING/ {print $3}' lustre/include/lustre_ver.h))

1023 echo "Building Lustre DKMS RPMs for: $BUILD_ARCHS..."

1024 ./configure --enable-dist || return 255

1025 $RPMBUILD --define="_topdir $TOPDIR" -bs lustre-dkms.spec || return 255

1026 $RPMBUILD --rebuild --define="_topdir $TOPDIR" $TOPDIR/SRPMS/lustre-dkms-$ver-*.src.rpm || return 255

1027 return 0

1028 }

1029

1030 ###

1031 # build_spl_zfs

1032 #

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

1034 #

1035 # Overrides:

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

1037 # SPLZFSTAG - Tag to checkout of clone repositories

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

1039 #

1040 # return 0 if successful, else 255

1041 build_spl_zfs() {

1042 # make sure the RPM build environment is set up

1043 pushd $TOPDIR

1044 create_rpmbuild_dirs

1045 popd

1046

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

1048 # destination for the rpms

1049 export RPM_BUILD_ROOT=$TOPDIR

1050 SPLZFSVER=${SPLZFSVER:-0.6.3-1.2}

1051 SPLZFSTAG=${SPLZFSTAG:-}

1052

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

1054 local kver=$(find_linux_release)

1055

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

1057 local pkg

1058 for pkg in spl zfs; do

1059

1060 local rpmpkg

1061

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

1063

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

1065 # default to github but allow override

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

1067

1068 pushd $pkg || return 255

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

1070 git checkout $SPLZFSTAG

1071 else

1072 git checkout -b lbuild $pkg-$SPLZFSVER

1073 fi

1074

1075 # This differentiates between older zfs versions

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

1077 rpmpkg=$pkg-modules

1078 specdir=.

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

1080 else

1081 rpmpkg=kmod-$pkg-devel

1082 specdir=rpm/generic

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

1084 fi

1085

1086 sh autogen.sh || return 255

1087

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

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

1090 ! make dist 2>&1; then

1091 popd

1092 return 255

1093 fi

1094 popd

1095

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

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

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

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

1100 fi

1101

1102 local rpmb

1103 if $DO_SRC; then

1104 rpmb=-ba

1105 else

1106 rpmb=-bb

1107 fi

1108

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

1110 # directories

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

1112 # Manually build rpms

1113 for spec in $speclist; do

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

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

1116 --nodeps -v \

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

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

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

1120 --define "kver $kver" \

1121 --define "kernels $kver" \

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

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

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

1125 return 255

1126 fi

1127 done

1128

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

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

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

1132

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

1134 pushd $TOPDIR

1135 local rpm

1136 for rpm in $rpms; do

1137 rpm2cpio $rpm | cpio -id

1138 done

1139

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

1141 # We also need to extract both the zfs and zfs-devel rpms

1142 # the zfs rpm is needed because it has the actual libraries in

1143 # it and the zfs-devel rpm only has unversioned symlinks to the

1144 # libraries in the zfs rpm

1145 # this will all change one day when we have a libzfs rpm per

1146 # https://github.com/zfsonlinux/zfs/issues/2329

1147 # and it looks like it could be one day soon:

1148 # https://github.com/zfsonlinux/zfs/pull/2341

1149 local devel_rpms=$(ls -1 $TOPDIR/RPMS/*/{$pkg-devel,$pkg-$SPLZFSVER,lib*}-*.rpm)

1150 for rpm in $devel_rpms; do

1151 rpm2cpio $rpm | cpio -id

1152 done

1153 CONFIGURE_FLAGS="--with-$pkg-devel=$TOPDIR ${CONFIGURE_FLAGS}"

1154 fi

1155 popd

1156

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

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

1159 done

1160

1161 OSDZFSRPM=true

1162

1163 return 0

1164 }

1165

1166 prepare_mpss() {

1167

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

1169 if [ "$MPSS_MAJ" = "3" ]; then

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

1171 if ! make ARCH=k1om silentoldconfig ; then

1172 popd >/dev/null

1173 return 1

1174 fi

1175 if ! make ARCH=k1om modules_prepare ; then

1176 popd >/dev/null

1177 return 1

1178 fi

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

1180 else

1181 if ! make defconfig-miclinux; then

1182 popd >/dev/null

1183 return 1

1184 fi

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

1186 popd >/dev/null

1187 return 1

1188 fi

1189 fi

1190 popd >/dev/null

1191

1192 }

1193

1194 stage() {

1195

1196 [ "$STAGEDIR" ] || return 0

1197

1198 for arch in $BUILD_ARCHS; do

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

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

1201 mkdir -p "${rpmdir}"

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

1203 if [ -d RPMS/noarch ]; then

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

1205 fi

1206 done

1207

1208 cp -v "$LUSTRE" "$STAGEDIR"

1209

1210 }

1211

1212 set_rpm_smp_type() {

1213

1214 local infact_arch="${TARGET_ARCH}"

1215

1216 RPMSMPTYPE=""

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

1218

1219 local smp_type

1220 for smp_type in $SMP_ARCHS; do

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

1222 done

1223

1224 for smp_type in $BIGSMP_ARCHS; do

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

1226 done

1227

1228 for smp_type in $PPC64_ARCHS; do

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

1230 done

1231

1232 for smp_type in $DEFAULT_ARCHS; do

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

1234 done

1235

1236 }

1237

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

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

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

1241 _find_linux_release() {

1242 local SRC="$1"

1243 local LINUXRELEASEHEADER=""

1244

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

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

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

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

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

1250 fi

1251

1252 if [ ! -s $LINUXRELEASEHEADER ]; then

1253 fatal 1 "could not find UTS_RELEASE"

1254 fi

1255

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

1257 }

1258

1259 # unpack kernel(/source/devel) RPM

1260 #

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

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

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

1264 # lustre itself)

1265 unpack_linux_devel_rpm() {

1266 local kernelrpm="${1}"

1267

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

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

1270

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

1272

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

1274 return 255

1275 fi

1276

1277 # call a distro specific hook, if available

1278 if type -p unpack_linux_devel_rpm-$DISTROMAJ; then

1279 if ! unpack_linux_devel_rpm-$DISTROMAJ "$kernelrpm"; then

1280 return 255

1281 fi

1282 fi

1283

1284 popd &>/dev/null

1285

1286 find_linux_devel_paths $TOPDIR/reused

1287

1288 return 0

1289

1290 }

1291

1292 build_kernel_ib() {

1293 local linux="$1"

1294 local kib_prefix="$2"

1295 local kib_rpm="$3"

1296

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

1298 local K_SRC="K_SRC"

1299 # ofed 1.3 had a bug in the rpm spec

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

1301 K_SRC="KSRC"

1302 fi

1303

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

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

1306

1307 if compare_version $OFED_VERSION 3.0; then

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

1309 else

1310 OFED_HARDWARE="$OFED_HARDWARE --with-mlx5-mod --with-cxgb4-mod --with-ocrdma-mod --with-qib-mod"

1311 fi

1312

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

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

1315 case "$TARGET_ARCH" in

1316 ppc64)

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

1318 ;;

1319 esac

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

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

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

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

1324 ##kernels >= 2.6.30)

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

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

1327 #fi

1328

1329 # assume we are just rebuilding the SRPM

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

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

1332

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

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

1335 BUILD_TYPE="-bb"

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

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

1338 local file ed_fragment1 ed_fragment2 n=1

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

1340 ed_fragment1="$ed_fragment1

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

1342 ed_fragment2="$ed_fragment2

1343 %patch$n -p0"

1344 cp $file ${TOPDIR}/SOURCES

1345 let n=$n+1

1346 done

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

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

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

1350 # convention

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

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

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

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

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

1356 if [ $? -eq 0 ] ; then

1357 ed_fragment3="$ed_fragment3

1358 $(cat $file)"

1359 let n=$n+1

1360 fi

1361 done

1362

1363 if [ $n -gt 1 ]; then

1364 ed $SOURCE <<EOF

1365 /^Source: /a

1366 $ed_fragment1

1367 .

1368 /^%setup /a

1369 $ed_fragment2

1370 .

1371 $ed_fragment3

1372 wq

1373 EOF

1374 fi

1375 fi

1376

1377 local linuxrelease=$(find_linux_release)

1378 if compare_version $OFED_VERSION 3.0; then

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

1380 fi

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

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

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

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

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

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

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

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

1389 ${SOURCE} 2>&1; then

1390 fatal 1 "Error building ${kib_rpm}"

1391 fi

1392

1393 }

1394

1395 store_for_reuse() {

1396 local articles="$1"

1397 local module="$2"

1398 local location="$3"

1399 local signature="$4"

1400 local use_links="$5"

1401

1402 local linkflag=""

1403 if $use_links; then

1404 linkflag="l"

1405 fi

1406

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

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

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

1410 fi

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

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

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

1414 fi

1415

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

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

1418 mkdir -p "$location"

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

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

1421 # this solution still slightly racy with the cleanup script

1422 # but the race is a lot tighter now

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

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

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

1426 local article

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

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

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

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

1431 # product, but is around for analysis

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

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

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

1435 "necessary"

1436 return 1

1437 fi

1438 done

1439

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

1441 # interrupted while caching)

1442 touch "$location/.lastused"

1443

1444 # put the temporary location into the final location

1445 # (last one wins)

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

1447 mv "$location" "$finallocation"

1448 rmdir "${location%/*}"

1449 return 0

1450

1451 }

1452

1453 reuse() {

1454 local module="$1"

1455 local dest="$2"

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

1457 local signature="$4"

1458

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

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

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

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

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

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

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

1466 return 1

1467 fi

1468

1469 # so that we know how stale this entry is

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

1471

1472 if $use_links; then

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

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

1475 fi

1476 else

1477 # copying is pretty heavy

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

1479 # do some creative symlinking instead

1480 local dir

1481 for dir in BUILD SRPMS SPECS; do

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

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

1484 fi

1485 done

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

1487 # be a dir we can write into

1488 # could overrun ls's arg list here

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

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

1491 xargs ln -t $dest/SOURCES -s

1492

1493 # same for RPMS/* dirs

1494 # could overrun ls's arg list here

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

1496 local dir

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

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

1499 find $dir -type f |

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

1501 done

1502 fi

1503 return 0

1504 else

1505 return 1

1506 fi

1507 }

1508

1509 basearch() {

1510 local arch="$1"

1511

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

1513 echo "i386"

1514 else

1515 echo "$arch"

1516 fi

1517

1518 }

1519

1520 build_kernel_with_srpm() {

1521 local outfd=$1

1522

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

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

1525 fi

1526

1527 # need to generate the patch for this target

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

1529

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

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

1532 # in BUILD_ARCHS

1533 local release_str

1534 if $RELEASE; then

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

1536 fi

1537

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

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

1540 echo $BUILD_GEN;

1541 cat "$CONFIG_FILE";

1542 cat "$TARGET_FILE";

1543 cat "$FULL_PATCH";

1544 cat "$LBUILD_DIR/lbuild";

1545 cat "$LBUILD_DIR/lbuild-$DISTROMAJ"; } |

1546 md5sum | cut -d" " -f1)

1547 # see if we can link to the reuse pool

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

1549 # "library"

1550 local CAN_LINK_FOR_REUSE=false

1551 touch $REUSEBUILD/$$

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

1553 CAN_LINK_FOR_REUSE=true

1554 fi

1555 rm $REUSEBUILD/$$

1556 fi

1557

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

1559 # kernel, remember)

1560 local kernel_extra_version=""

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

1562 "$REUSE_SIGNATURE"; then

1563 # nothing cached, build from scratch

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

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

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

1567 fi

1568

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

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

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

1572 #rm -rf $RPMTOPDIR

1573 fatal 1 "Error installing kernel SRPM."

1574 fi

1575

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

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

1578 prepare_and_build_srpm >&${outfd} ||

1579 fatal 1 "failed to prepare_and_build_srpm"

1580

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

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

1583 else

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

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

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

1587 "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1588 "$CAN_LINK_FOR_REUSE"; then

1589 error "Failed to store kernel RPMS for reuse"

1590 echo "unknown" >&${outfd}

1591 return 1

1592 fi

1593 fi

1594 fi # build reuse

1595

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

1597 local KERNEL_RPM

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

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

1600 fi

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

1602

1603 # should now have the following RPMs

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

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

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

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

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

1609

1610 echo $kernel_extra_version

1611 return 0

1612

1613 }

1614

1615 # build OFED

1616 # globals used:

1617 # TOPDIR

1618 # REUSEBUILD, USE_BUILD_CACHE

1619 # CONFIGURE_FLAGS

1620

1621 build_ofed() {

1622 local linux="$1"

1623 local ofed_version="$2"

1624 local kib_prefix

1625 local kib_rpm

1626

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

1628 # not any vendor specific "inkernel" version

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

1630 return 0

1631 fi

1632

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

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

1635 # that if it exists

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

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

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

1639 if type -p build_ofed-$DISTROMAJ; then

1640 local ofed_location

1641 ofed_location=$(build_ofed-$DISTROMAJ ${STDOUT})

1642 local rc=${PIPESTATUS[0]}

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

1644 return $rc

1645 else

1646 return 0

1647 fi

1648 elif compare_version $OFED_VERSION 3.0; then

1649 kib_prefix="ofa_kernel"

1650 kib_rpm="kernel-ib"

1651 else

1652 kib_prefix="compat-rdma"

1653 kib_rpm="compat-rdma"

1654 fi

1655

1656 # build kernel-ib/compat-rdma

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

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

1659 echo "$(find_linux_release;

1660 echo "$BUILD_GEN")";

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

1662 cat "$LBUILD_DIR/lbuild";

1663 cat "$LBUILD_DIR/lbuild-$DISTROMAJ"; } |

1664 md5sum | cut -d" " -f1)

1665 # see if we can link to the reuse pool

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

1667 # "library"

1668 local CAN_LINK_FOR_REUSE=false

1669 touch $REUSEBUILD/$$

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

1671 CAN_LINK_FOR_REUSE=true

1672 fi

1673 rm $REUSEBUILD/$$

1674 fi

1675

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

1677 "$REUSE_SIGNATURE"; then

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

1679 # stash away the existing built articles for a moment

1680 mkdir bak

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

1682 function mv_back {

1683 pushd bak

1684 find . | cpio -pudlm ..

1685 popd

1686 rm -rf bak

1687 }

1688 create_rpmbuild_dirs

1689 fi

1690 # build it

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

1692

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

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

1695 else

1696 # store the resulting RPM build tree for future use

1697 echo "Storing the built ofed for future reuse"

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

1699 "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1700 "$CAN_LINK_FOR_REUSE"; then

1701 error "Failed to store OFED RPMS for reuse"

1702 mv_back

1703 return 1

1704 fi

1705 # put the stuff we stashed away back

1706 mv_back

1707 fi

1708 fi

1709

1710 pushd "$TOPDIR" >/dev/null

1711 rm -rf ${kib_rpm}-devel

1712 mkdir ${kib_rpm}-devel

1713 cd ${kib_rpm}-devel

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

1715 # might be present on the file

1716 #local linuxrelease=$(find_linux_release)

1717 #ofed_version=$(echo $ofed_version |

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

1719 # FIXME

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

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

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

1723 # can remove following filter.

1724 #ofed_version=$(echo $ofed_version |

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

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

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

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

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

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

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

1732 fi

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

1734 popd >/dev/null

1735

1736 }

1737

1738 build_with_srpm() {

1739

1740 if ! $PATCHLESS; then

1741 local kernel_extra_version

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

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

1744 fi

1745

1746 for arch in $BUILD_ARCHS; do

1747 local kernel_devel_rpm

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

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

1750 fi

1751

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

1753 if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \

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

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

1756 fi

1757 done

1758 else

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

1760 # client build

1761 local kernelrpm

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

1763 fatal 1 "Could not find the kernel-$DEVEL_KERNEL_TYPE RPM in $KERNELRPMSBASE/$lnxmaj/$DISTROMAJ"

1764 fi

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

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

1767 fi

1768 fi

1769

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

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

1772 # kernel-devel artifacts

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

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

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

1776 local tmp="$(pwd)"

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

1778 ed find-requires <<EOF

1779 1a

1780 set -x

1781 .

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

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

1784 wq

1785 EOF

1786 ed find-requires.ksyms <<EOF

1787 1a

1788 set -x

1789 .

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

1791 wq

1792 EOF

1793 ed symset-table <<EOF

1794 1a

1795 set -x

1796 .

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

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

1799 wq

1800 EOF

1801

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

1803 fatal 1 "error building OFED"

1804

1805 # now build Lustre

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

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

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

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

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

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

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

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

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

1815 # RPM reuse?

1816 local dir

1817 for dir in RPMS/*; do

1818 pushd $dir

1819 for file in $(ls); do

1820 if [ -h $file ]; then

1821 cp $file foo

1822 mv foo $file

1823 fi

1824 done

1825 popd

1826 done

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

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

1829 for dir in RPMS/*; do

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

1831 continue

1832 fi

1833 pushd $dir

1834 local files=$(ls)

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

1836 cp -al $files ../$TARGET_ARCH

1837 fi

1838 popd

1839 done

1840 else

1841 return 1

1842 fi

1843

1844 }

1845

1846 create_rpmbuild_dirs() {

1847

1848 [ -d RPMS ] || mkdir RPMS

1849 for arch in $BUILD_ARCHS; do

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

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

1852 # even if the target arch is i686

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

1854 fi

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

1856 done

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

1858 [ -d BUILD ] || mkdir BUILD

1859 [ -d SOURCES ] || mkdir SOURCES

1860 [ -d SPECS ] || mkdir SPECS

1861 [ -d SRPMS ] || mkdir SRPMS

1863 }

1865 new_list() {

1867 echo ""

1869 }

1871 add_list() {

1872 local list="$1"

1873 local item="$2"

1874

1875 echo "$list $item"

1876

1877 }

1878

1879 is_list_member() {

1880 local list="$1"

1881 local item="$2"

1882

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

1884

1885 }

1886

1887 #########################################################################

1888 # Generate a backtrace through the call stack.

1889 #

1890 # Input: None

1891 # Output: None

1892 #########################################################################

1893 backtrace() {

1894 local strip=${1:-1}

1895

1896 local funcname="" sourcefile="" lineno="" n

1897

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

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

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

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

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

1903 if [ $n = 1 ]; then

1904 let lineno-=11

1905 fi

1906 # Display function arguments

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

1908 local args newarg j p=0

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

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

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

1912 done

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

1914 fi

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

1916 done

1917

1918 echo

1919 echo "BEGIN BACKTRACE"

1920

1921 #echo ${BASH_LINENO[*]}

1922 #echo ${BASH_SOURCE[*]}

1923 #echo ${FUNCNAME[*]}

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

1925 while [ $i -ge 0 ]; do

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

1927 if [ $i = 0 ]; then

1928 let lineno-=11

1929 fi

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

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

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

1933 echo "$SOURCELINE:$FUNCTION"

1934 i=$((i - 1))

1935 done

1936

1937 echo "END BACKTRACE"

1938

1939 echo $BACKTRACE

1940

1941 }

1942

1943 seen_list=$(new_list)

1944 trap 'set +x;

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

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

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

1948 echo

1949 # have we seen this one

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

1951

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

1953 echo "seen this one already"

1954 else

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

1956 fi

1957 backtrace

1958 ) ; set $xtrace' ERR

1959 set -E

1960

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

1962

1963 options=$(getopt -o D:h -l kerneltree:,distro:,kernelrpm:,reusebuild:,patchless,ccache,norpm,external-patches:,timestamp:,extraversion:,kerneldir:,linux:,lustre:,nodownload,nosrc,noiokit,ofed-version:,mpss-version:,publish,disable-zfs,release,set-value:,src,stage:,target:,target-archs:,with-linux:,xen -- "$@")

1964

1965 if [ $? != 0 ]; then

1966 usage 1

1967 fi

1968

1969 eval set -- "$options"

1970

1971 while [ "$1" ]; do

1972 case "$1" in

1973 '')

1974 usage 1

1975 ;;

1976 --ccache)

1977 CCACHE='ccache'

1978 shift

1979 ;;

1980 -D)

1981 DATE=$2

1982 shift 2

1983 ;;

1984 --external-patches)

1985 EXTERNAL_PATCHES=$2

1986 shift 2

1987 ;;

1988 --extraversion)

1989 EXTRA_VERSION=$2

1990 shift 2

1991 ;;

1992 --help | -h)

1993 usage 0

1994 ;;

1995 --kerneldir)

1996 KERNELDIR=$2

1997 shift 2

1998 ;;

1999 --kerneltree)

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

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

2002 fi

2003 shift 2

2004 ;;

2005 --linux | --with-linux)

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

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

2008 fi

2009 shift 2

2010 ;;

2011 --distro)

2012 DISTRO=$2

2013 shift 2

2014 ;;

2015 --reusebuild)

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

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

2018 fi

2019 shift 2

2020 ;;

2021 --norpm)

2022 NORPM=true

2023 shift

2024 ;;

2025 --noiokit)

2026 IOKITRPM=false

2027 shift

2028 ;;

2029 --patchless)

2030 PATCHLESS=true

2031 shift

2032 ;;

2033 --kernelrpm)

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

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

2036 fi

2037 shift 2

2038 ;;

2039 --timestamp)

2040 TIMESTAMP=$2

2041 shift 2

2042 ;;

2043 --lustre)

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

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

2046 fi

2047 shift 2

2048 ;;

2049 --nodownload)

2050 DOWNLOAD=false

2051 shift 1

2052 ;;

2053 --nosrc)

2054 DO_SRC=false

2055 shift 1

2056 ;;

2057 --ofed-version)

2058 OFED_VERSION="$2"

2059 shift 2

2060 ;;

2061 --mpss-version)

2062 MPSS_VERSION="$2"

2063 shift 2

2064 ;;

2065 --publish)

2066 shift

2067 ;;

2068 --disable-zfs)

2069 WITH_ZFS="no"

2070 shift

2071 ;;

2072 --release)

2073 RELEASE=true

2074 shift

2075 ;;

2076 --src)

2077 DO_SRC=true

2078 shift 1

2079 ;;

2080 --stage)

2081 STAGEDIR=$2

2082 shift 2

2083 ;;

2084 --target)

2085 TARGET=$2

2086 shift 2

2087 ;;

2088 --target-archs)

2089 TARGET_ARCHS=$2

2090 shift 2

2091 ;;

2092 --xen)

2093 XEN=true

2094 shift

2095 ;;

2096 --set-value)

2097 eval $2

2098 shift 2

2099 ;;

2100 --)

2101 shift

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

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

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

2105 LUSTRE_TESTS=false

2106 fi

2107 CONFIGURE_FLAGS=$@

2108 break

2109 ;;

2110 *)

2111 usage 1 "Unrecognized option: $1"

2112 ;;

2113 esac

2114 done

2115

2116 check_options

2117

2118 unpack_lustre

2119

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

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

2122 BUILDID=$(sed -n -e 's/^BUILDID = //p' lustre/META)

2123

2124 load_target

2125

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

2127 download_ofed

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

2129 fi

2130

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

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

2133

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

2135 download_mpss_info "$MPSS_INFO"

2136

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

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

2139 [ -z "$MPSS_VERSION" ] &&

2140 fatal 1 "Could not determine the last MPSS version"

2141 fi

2142

2143 MPSS_MAJ=${MPSS_VERSION%%.*}

2144 MPSS_VER=${MPSS_VERSION%%-*}

2145 MPSS_BLD=${MPSS_VERSION##*-}

2146 [ "$MPSS_VER" = "$MPSS_BLD" ] && MPSS_BLD=0

2147

2148 download_mpss "$MPSS_INFO"

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

2150 echo "Building with MPSS $MPSS_VER-$MPSS_BLD"

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

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

2153

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

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

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

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

2158 else

2159 MPSS_OFED="--without-o2ib"

2160 fi

2161 fi

2162

2163 # disable unsupported parts:

2164 PATCHLESS=true

2165 IOKITRPM=false

2166 LDISKFSRPM=false

2167 WITH_ZFS="no"

2168

2169 # define variables for cross compilation:

2170 CROSS_SUFFIX="-mic"

2171 if [ "$MPSS_MAJ" = "3" ]; then

2172 CC_TARGET_ARCH=k1om-mpss-linux

2173 LINUX="$TOPDIR/mpss"

2174 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_requires /bin/sh\""

2175 else

2176 CC_TARGET_ARCH=x86_64-k1om-linux

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

2178 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_requires intel-mic-gpl = $MPSS_VER\""

2179 fi

2180 LUSTRE_VERSION=$(sed -n -e 's/^VERSION = //p' lustre/META)

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

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

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

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

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

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

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

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

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

2190

2191 # redefine CC for proper ./configure during rpmbuild

2192 export CC=${CC_TARGET_ARCH}-gcc

2193 fi

2194

2195 # make sure the RPM build environment is set up

2196 create_rpmbuild_dirs

2197

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

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

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

2201 find_linux_release() {

2202 _find_linux_release $LINUX

2203 }

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

2205 fatal 1 "error building OFED"

2206 build_lustre "$LINUX" "$LINUXOBJ"

2207 else

2208 if [ ! -f "${LBUILD_DIR}/lbuild-$DISTROMAJ" ]; then

2209 fatal 1 "${LBUILD_DIR}/lbuild-$DISTROMAJ not found"

2210 fi

2211 source ${LBUILD_DIR}/lbuild-$DISTROMAJ

2212 build_with_srpm || fatal 1 "Failed to build_with_srpm"

2213 fi

2214

2215 stage