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 overwriten 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 confoptions=""

956

957 if $PATCHLESS; then

958 confoptions="$confoptions --disable-server"

959 fi

960

961 local rpmbuildopt='-tb'

962 if $NORPM; then

963 rpmbuildopt='-tc'

964 echo NORPM mode. Only compiling.

965 fi

966

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

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

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

970 # line above so is at least consistant.

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

972 if ! build_spl_zfs; then

973 popd >/dev/null # pushd lustre

974 return 255

975 fi

976 fi

977

978 if $PATCHLESS; then

979 RPMBUILD_DEFS="$RPMBUILD_DEFS --without servers"

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

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

982 fi

983 fi

984

985 # ditto for the lustre-tests boolean

986 if ! $LUSTRE_TESTS; then

987 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_tests"

988 fi

989

990 if ! $IOKITRPM; then

991 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_iokit"

992 fi

993

994 local osd_zfs=""

995 if $OSDZFSRPM; then

996 osd_zfs="yes"

997 fi

998

999 local osd_ldiskfs=""

1000 if $OSDLDISKFSRPM; then

1001 osd_ldiskfs="yes"

1002 fi

1003

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

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

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

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

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

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

1010

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

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

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

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

1015

1016 if $DO_SRC; then

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

1018 popd >/dev/null

1019 return 255

1020 fi

1021 fi

1022 popd >/dev/null

1023

1024 }

1025

1026 build_lustre_dkms() {

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

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

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

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

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

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

1033 return 0

1034 }

1035

1036 ###

1037 # build_spl_zfs

1038 #

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

1040 #

1041 # Overrides:

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

1043 # SPLZFSTAG - Tag to checkout of clone repositories

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

1045 #

1046 # return 0 if successful, else 255

1047 build_spl_zfs() {

1048 # make sure the RPM build environment is set up

1049 pushd $TOPDIR

1050 create_rpmbuild_dirs

1051 popd

1052

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

1054 # destination for the rpms

1055 export RPM_BUILD_ROOT=$TOPDIR

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

1057 SPLZFSTAG=${SPLZFSTAG:-}

1058

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

1060 local kver=$(find_linux_release)

1061

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

1063 local pkg

1064 for pkg in spl zfs; do

1065

1066 local rpmpkg

1067

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

1069

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

1071 # default to github but allow override

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

1073

1074 pushd $pkg || return 255

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

1076 git checkout $SPLZFSTAG

1077 else

1078 git checkout -b lbuild $pkg-$SPLZFSVER

1079 fi

1080

1081 # This differentiates between older zfs versions

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

1083 rpmpkg=$pkg-modules

1084 specdir=.

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

1086 else

1087 rpmpkg=kmod-$pkg-devel

1088 specdir=rpm/generic

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

1090 fi

1091

1092 sh autogen.sh || return 255

1093

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

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

1096 ! make dist 2>&1; then

1097 popd

1098 return 255

1099 fi

1100 popd

1101

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

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

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

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

1106 fi

1107

1108 local rpmb

1109 if $DO_SRC; then

1110 rpmb=-ba

1111 else

1112 rpmb=-bb

1113 fi

1114

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

1116 # directories

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

1118 # Manually build rpms

1119 for spec in $speclist; do

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

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

1122 --nodeps -v \

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

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

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

1126 --define "kver $kver" \

1127 --define "kernels $kver" \

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

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

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

1131 return 255

1132 fi

1133 done

1134

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

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

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

1138

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

1140 pushd $TOPDIR

1141 local rpm

1142 for rpm in $rpms; do

1143 rpm2cpio $rpm | cpio -id

1144 done

1145

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

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

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

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

1150 # libraries in the zfs rpm

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

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

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

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

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

1156 for rpm in $devel_rpms; do

1157 rpm2cpio $rpm | cpio -id

1158 done

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

1160 fi

1161 popd

1162

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

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

1165 done

1166

1167 OSDZFSRPM=true

1168

1169 return 0

1170 }

1171

1172 prepare_mpss() {

1173

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

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

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

1177 if ! make ARCH=k1om silentoldconfig ; then

1178 popd >/dev/null

1179 return 1

1180 fi

1181 if ! make ARCH=k1om modules_prepare ; then

1182 popd >/dev/null

1183 return 1

1184 fi

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

1186 else

1187 if ! make defconfig-miclinux; then

1188 popd >/dev/null

1189 return 1

1190 fi

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

1192 popd >/dev/null

1193 return 1

1194 fi

1195 fi

1196 popd >/dev/null

1197

1198 }

1199

1200 stage() {

1201

1202 [ "$STAGEDIR" ] || return 0

1203

1204 for arch in $BUILD_ARCHS; do

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

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

1207 mkdir -p "${rpmdir}"

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

1209 if [ -d RPMS/noarch ]; then

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

1211 fi

1212 done

1213

1214 cp -v "$LUSTRE" "$STAGEDIR"

1215

1216 }

1217

1218 set_rpm_smp_type() {

1219

1220 local infact_arch="${TARGET_ARCH}"

1221

1222 RPMSMPTYPE=""

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

1224

1225 local smp_type

1226 for smp_type in $SMP_ARCHS; do

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

1228 done

1229

1230 for smp_type in $BIGSMP_ARCHS; do

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

1232 done

1233

1234 for smp_type in $PPC64_ARCHS; do

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

1236 done

1237

1238 for smp_type in $DEFAULT_ARCHS; do

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

1240 done

1241

1242 }

1243

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

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

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

1247 _find_linux_release() {

1248 local SRC="$1"

1249 local LINUXRELEASEHEADER=""

1250

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

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

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

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

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

1256 fi

1257

1258 if [ ! -s $LINUXRELEASEHEADER ]; then

1259 fatal 1 "could not find UTS_RELEASE"

1260 fi

1261

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

1263 }

1264

1265 # unpack kernel(/source/devel) RPM

1266 #

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

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

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

1270 # lustre itself)

1271 unpack_linux_devel_rpm() {

1272 local kernelrpm="${1}"

1273

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

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

1276

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

1278

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

1280 return 255

1281 fi

1282

1283 # call a distro specific hook, if available

1284 if type -p unpack_linux_devel_rpm-$DISTROMAJ; then

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

1286 return 255

1287 fi

1288 fi

1289

1290 popd &>/dev/null

1291

1292 find_linux_devel_paths $TOPDIR/reused

1293

1294 return 0

1295

1296 }

1297

1298 build_kernel_ib() {

1299 local linux="$1"

1300 local kib_prefix="$2"

1301 local kib_rpm="$3"

1302

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

1304 local K_SRC="K_SRC"

1305 # ofed 1.3 had a bug in the rpm spec

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

1307 K_SRC="KSRC"

1308 fi

1309

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

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

1312

1313 if compare_version $OFED_VERSION 3.0; then

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

1315 else

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

1317 fi

1318

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

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

1321 case "$TARGET_ARCH" in

1322 ppc64)

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

1324 ;;

1325 esac

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

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

1328 OFED_ISCSI="--with-srp-mod"

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

1330 ##kernels >= 2.6.30)

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

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

1333 #fi

1334

1335 # assume we are just rebuilding the SRPM

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

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

1338

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

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

1341 BUILD_TYPE="-bb"

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

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

1344 local file ed_fragment1 ed_fragment2 n=1

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

1346 ed_fragment1="$ed_fragment1

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

1348 ed_fragment2="$ed_fragment2

1349 %patch$n -p0"

1350 cp $file ${TOPDIR}/SOURCES

1351 let n=$n+1

1352 done

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

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

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

1356 # convention

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

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

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

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

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

1362 if [ $? -eq 0 ] ; then

1363 ed_fragment3="$ed_fragment3

1364 $(cat $file)"

1365 let n=$n+1

1366 fi

1367 done

1368

1369 if [ $n -gt 1 ]; then

1370 ed $SOURCE <<EOF

1371 /^Source: /a

1372 $ed_fragment1

1373 .

1374 /^%setup /a

1375 $ed_fragment2

1376 .

1377 $ed_fragment3

1378 wq

1379 EOF

1380 fi

1381 fi

1382

1383 local linuxrelease=$(find_linux_release)

1384 if compare_version $OFED_VERSION 3.0; then

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

1386 fi

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

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

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

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

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

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

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

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

1395 ${SOURCE} 2>&1; then

1396 fatal 1 "Error building ${kib_rpm}"

1397 fi

1398

1399 }

1400

1401 store_for_reuse() {

1402 local articles="$1"

1403 local module="$2"

1404 local location="$3"

1405 local signature="$4"

1406 local use_links="$5"

1407

1408 local linkflag=""

1409 if $use_links; then

1410 linkflag="l"

1411 fi

1412

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

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

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

1416 fi

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

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

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

1420 fi

1421

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

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

1424 mkdir -p "$location"

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

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

1427 # this solution still slightly racy with the cleanup script

1428 # but the race is a lot tighter now

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

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

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

1432 local article

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

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

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

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

1437 # product, but is around for analysis

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

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

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

1441 "necessary"

1442 return 1

1443 fi

1444 done

1445

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

1447 # interrupted while caching)

1448 touch "$location/.lastused"

1449

1450 # put the temporary location into the final location

1451 # (last one wins)

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

1453 mv "$location" "$finallocation"

1454 rmdir "${location%/*}"

1455 return 0

1456

1457 }

1458

1459 reuse() {

1460 local module="$1"

1461 local dest="$2"

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

1463 local signature="$4"

1464

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

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

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

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

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

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

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

1472 return 1

1473 fi

1474

1475 # so that we know how stale this entry is

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

1477

1478 if $use_links; then

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

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

1481 fi

1482 else

1483 # copying is pretty heavy

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

1485 # do some creative symlinking instead

1486 local dir

1487 for dir in BUILD SRPMS SPECS; do

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

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

1490 fi

1491 done

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

1493 # be a dir we can write into

1494 # could overrun ls's arg list here

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

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

1497 xargs ln -t $dest/SOURCES -s

1498

1499 # same for RPMS/* dirs

1500 # could overrun ls's arg list here

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

1502 local dir

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

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

1505 find $dir -type f |

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

1507 done

1508 fi

1509 return 0

1510 else

1511 return 1

1512 fi

1513 }

1514

1515 basearch() {

1516 local arch="$1"

1517

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

1519 echo "i386"

1520 else

1521 echo "$arch"

1522 fi

1523

1524 }

1525

1526 build_kernel_with_srpm() {

1527 local outfd=$1

1528

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

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

1531 fi

1532

1533 # need to generate the patch for this target

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

1535

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

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

1538 # in BUILD_ARCHS

1539 local release_str

1540 if $RELEASE; then

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

1542 fi

1543

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

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

1546 echo $BUILD_GEN;

1547 cat "$CONFIG_FILE";

1548 cat "$TARGET_FILE";

1549 cat "$FULL_PATCH";

1550 cat "$LBUILD_DIR/lbuild";

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

1552 md5sum | cut -d" " -f1)

1553 # see if we can link to the reuse pool

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

1555 # "library"

1556 local CAN_LINK_FOR_REUSE=false

1557 touch $REUSEBUILD/$$

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

1559 CAN_LINK_FOR_REUSE=true

1560 fi

1561 rm $REUSEBUILD/$$

1562 fi

1563

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

1565 # kernel, remember)

1566 local kernel_extra_version=""

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

1568 "$REUSE_SIGNATURE"; then

1569 # nothing cached, build from scratch

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

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

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

1573 fi

1574

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

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

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

1578 #rm -rf $RPMTOPDIR

1579 fatal 1 "Error installing kernel SRPM."

1580 fi

1581

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

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

1584 prepare_and_build_srpm >&${outfd} ||

1585 fatal 1 "failed to prepare_and_build_srpm"

1586

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

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

1589 else

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

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

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

1593 "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1594 "$CAN_LINK_FOR_REUSE"; then

1595 error "Failed to store kernel RPMS for reuse"

1596 echo "unknown" >&${outfd}

1597 return 1

1598 fi

1599 fi

1600 fi # build reuse

1601

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

1603 local KERNEL_RPM

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

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

1606 fi

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

1608

1609 # should now have the following RPMs

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

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

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

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

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

1615

1616 echo $kernel_extra_version

1617 return 0

1618

1619 }

1620

1621 # build OFED

1622 # globals used:

1623 # TOPDIR

1624 # REUSEBUILD, USE_BUILD_CACHE

1625 # CONFIGURE_FLAGS

1626

1627 build_ofed() {

1628 local linux="$1"

1629 local ofed_version="$2"

1630 local kib_prefix

1631 local kib_rpm

1632

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

1634 # not any vendor specific "inkernel" version

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

1636 return 0

1637 fi

1638

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

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

1641 # that if it exists

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

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

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

1645 if type -p build_ofed-$DISTROMAJ; then

1646 local ofed_location

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

1648 local rc=${PIPESTATUS[0]}

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

1650 return $rc

1651 else

1652 return 0

1653 fi

1654 elif compare_version $OFED_VERSION 3.0; then

1655 kib_prefix="ofa_kernel"

1656 kib_rpm="kernel-ib"

1657 else

1658 kib_prefix="compat-rdma"

1659 kib_rpm="compat-rdma"

1660 fi

1661

1662 # build kernel-ib/compat-rdma

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

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

1665 echo "$(find_linux_release;

1666 echo "$BUILD_GEN")";

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

1668 cat "$LBUILD_DIR/lbuild";

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

1670 md5sum | cut -d" " -f1)

1671 # see if we can link to the reuse pool

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

1673 # "library"

1674 local CAN_LINK_FOR_REUSE=false

1675 touch $REUSEBUILD/$$

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

1677 CAN_LINK_FOR_REUSE=true

1678 fi

1679 rm $REUSEBUILD/$$

1680 fi

1681

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

1683 "$REUSE_SIGNATURE"; then

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

1685 # stash away the existing built articles for a moment

1686 mkdir bak

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

1688 function mv_back {

1689 pushd bak

1690 find . | cpio -pudlm ..

1691 popd

1692 rm -rf bak

1693 }

1694 create_rpmbuild_dirs

1695 fi

1696 # build it

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

1698

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

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

1701 else

1702 # store the resulting RPM build tree for future use

1703 echo "Storing the built ofed for future reuse"

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

1705 "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1706 "$CAN_LINK_FOR_REUSE"; then

1707 error "Failed to store OFED RPMS for reuse"

1708 mv_back

1709 return 1

1710 fi

1711 # put the stuff we stashed away back

1712 mv_back

1713 fi

1714 fi

1715

1716 pushd "$TOPDIR" >/dev/null

1717 rm -rf ${kib_rpm}-devel

1718 mkdir ${kib_rpm}-devel

1719 cd ${kib_rpm}-devel

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

1721 # might be present on the file

1722 #local linuxrelease=$(find_linux_release)

1723 #ofed_version=$(echo $ofed_version |

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

1725 # FIXME

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

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

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

1729 # can remove following filter.

1730 #ofed_version=$(echo $ofed_version |

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

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

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

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

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

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

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

1738 fi

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

1740 popd >/dev/null

1741

1742 }

1743

1744 build_with_srpm() {

1745

1746 if ! $PATCHLESS; then

1747 local kernel_extra_version

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

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

1750 fi

1751

1752 for arch in $BUILD_ARCHS; do

1753 local kernel_devel_rpm

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

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

1756 fi

1757

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

1759 if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \

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

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

1762 fi

1763 done

1764 else

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

1766 # client build

1767 local kernelrpm

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

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

1770 fi

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

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

1773 fi

1774 fi

1775

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

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

1778 # kernel-devel artifacts

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

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

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

1782 local tmp="$(pwd)"

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

1784 ed find-requires <<EOF

1785 1a

1786 set -x

1787 .

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

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

1790 wq

1791 EOF

1792 ed find-requires.ksyms <<EOF

1793 1a

1794 set -x

1795 .

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

1797 wq

1798 EOF

1799 ed symset-table <<EOF

1800 1a

1801 set -x

1802 .

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

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

1805 wq

1806 EOF

1807

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

1809 fatal 1 "error building OFED"

1810

1811 # now build Lustre

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

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

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

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

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

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

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

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

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

1821 # RPM reuse?

1822 local dir

1823 for dir in RPMS/*; do

1824 pushd $dir

1825 for file in $(ls); do

1826 if [ -h $file ]; then

1827 cp $file foo

1828 mv foo $file

1829 fi

1830 done

1831 popd

1832 done

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

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

1835 for dir in RPMS/*; do

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

1837 continue

1838 fi

1839 pushd $dir

1840 local files=$(ls)

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

1842 cp -al $files ../$TARGET_ARCH

1843 fi

1844 popd

1845 done

1846 else

1847 return 1

1848 fi

1849

1850 }

1851

1852 create_rpmbuild_dirs() {

1853

1854 [ -d RPMS ] || mkdir RPMS

1855 for arch in $BUILD_ARCHS; do

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

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

1858 # even if the target arch is i686

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

1860 fi

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

1862 done

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

1864 [ -d BUILD ] || mkdir BUILD

1865 [ -d SOURCES ] || mkdir SOURCES

1866 [ -d SPECS ] || mkdir SPECS

1867 [ -d SRPMS ] || mkdir SRPMS

1869 }

1871 new_list() {

1873 echo ""

1875 }

1877 add_list() {

1878 local list="$1"

1879 local item="$2"

1880

1881 echo "$list $item"

1882

1883 }

1884

1885 is_list_member() {

1886 local list="$1"

1887 local item="$2"

1888

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

1890

1891 }

1892

1893 #########################################################################

1894 # Generate a backtrace through the call stack.

1895 #

1896 # Input: None

1897 # Output: None

1898 #########################################################################

1899 backtrace() {

1900 local strip=${1:-1}

1901

1902 local funcname="" sourcefile="" lineno="" n

1903

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

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

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

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

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

1909 if [ $n = 1 ]; then

1910 let lineno-=11

1911 fi

1912 # Display function arguments

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

1914 local args newarg j p=0

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

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

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

1918 done

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

1920 fi

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

1922 done

1923

1924 echo

1925 echo "BEGIN BACKTRACE"

1926

1927 #echo ${BASH_LINENO[*]}

1928 #echo ${BASH_SOURCE[*]}

1929 #echo ${FUNCNAME[*]}

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

1931 while [ $i -ge 0 ]; do

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

1933 if [ $i = 0 ]; then

1934 let lineno-=11

1935 fi

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

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

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

1939 echo "$SOURCELINE:$FUNCTION"

1940 i=$((i - 1))

1941 done

1942

1943 echo "END BACKTRACE"

1944

1945 echo $BACKTRACE

1946

1947 }

1948

1949 seen_list=$(new_list)

1950 trap 'set +x;

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

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

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

1954 echo

1955 # have we seen this one

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

1957

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

1959 echo "seen this one already"

1960 else

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

1962 fi

1963 backtrace

1964 ) ; set $xtrace' ERR

1965 set -E

1966

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

1968

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

1970

1971 if [ $? != 0 ]; then

1972 usage 1

1973 fi

1974

1975 eval set -- "$options"

1976

1977 while [ "$1" ]; do

1978 case "$1" in

1979 '')

1980 usage 1

1981 ;;

1982 --ccache)

1983 CCACHE='ccache'

1984 shift

1985 ;;

1986 -D)

1987 DATE=$2

1988 shift 2

1989 ;;

1990 --external-patches)

1991 EXTERNAL_PATCHES=$2

1992 shift 2

1993 ;;

1994 --extraversion)

1995 EXTRA_VERSION=$2

1996 shift 2

1997 ;;

1998 --help | -h)

1999 usage 0

2000 ;;

2001 --kerneldir)

2002 KERNELDIR=$2

2003 shift 2

2004 ;;

2005 --kerneltree)

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

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

2008 fi

2009 shift 2

2010 ;;

2011 --linux | --with-linux)

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

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

2014 fi

2015 shift 2

2016 ;;

2017 --distro)

2018 DISTRO=$2

2019 shift 2

2020 ;;

2021 --reusebuild)

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

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

2024 fi

2025 shift 2

2026 ;;

2027 --norpm)

2028 NORPM=true

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 --disable-zfs)

2075 WITH_ZFS="no"

2076 shift

2077 ;;

2078 --release)

2079 RELEASE=true

2080 shift

2081 ;;

2082 --src)

2083 DO_SRC=true

2084 shift 1

2085 ;;

2086 --stage)

2087 STAGEDIR=$2

2088 shift 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 break

2115 ;;

2116 *)

2117 usage 1 "Unrecognized option: $1"

2118 ;;

2119 esac

2120 done

2121

2122 check_options

2123

2124 unpack_lustre

2125

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

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

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

2129

2130 load_target

2131

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

2133 download_ofed

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

2135 fi

2136

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

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

2139

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

2141 download_mpss_info "$MPSS_INFO"

2142

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

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

2145 [ -z "$MPSS_VERSION" ] &&

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

2147 fi

2148

2149 MPSS_MAJ=${MPSS_VERSION%%.*}

2150 MPSS_VER=${MPSS_VERSION%%-*}

2151 MPSS_BLD=${MPSS_VERSION##*-}

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

2153

2154 download_mpss "$MPSS_INFO"

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

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

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

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

2159

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

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

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

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

2164 else

2165 MPSS_OFED="--without-o2ib"

2166 fi

2167 fi

2168

2169 # disable unsupported parts:

2170 PATCHLESS=true

2171 IOKITRPM=false

2172 LDISKFSRPM=false

2173 WITH_ZFS="no"

2174

2175 # define variables for cross compilation:

2176 CROSS_SUFFIX="-mic"

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

2178 CC_TARGET_ARCH=k1om-mpss-linux

2179 LINUX="$TOPDIR/mpss"

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

2181 else

2182 CC_TARGET_ARCH=x86_64-k1om-linux

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

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

2185 fi

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

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

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

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

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

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

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

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

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

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

2196

2197 # redefine CC for proper ./configure during rpmbuild

2198 export CC=${CC_TARGET_ARCH}-gcc

2199 fi

2200

2201 # make sure the RPM build environment is set up

2202 create_rpmbuild_dirs

2203

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

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

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

2207 find_linux_release() {

2208 _find_linux_release $LINUX

2209 }

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

2211 fatal 1 "error building OFED"

2212 build_lustre "$LINUX" "$LINUXOBJ"

2213 else

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

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

2216 fi

2217 source ${LBUILD_DIR}/lbuild-$DISTROMAJ

2218 build_with_srpm || fatal 1 "Failed to build_with_srpm"

2219 fi

2220

2221 stage