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

1 #!/bin/bash

3 # vim:expandtab:shiftwidth=4:softtabstop=4:tabstop=4:

5 # this is an alternative FD for stdout, to be used especially when we are

6 # taking stdout from a function as it's return value. i.e. foo=$(bar)

7 # this is a workaround until a version of bash where we can put xtrace

8 # on a specific FD

9 exec 3>&1; STDOUT=3

11 #set -x

12 xtrace="+x"

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

14 xtrace="-x"

15 fi

16 shopt -s extdebug

18 # Assume that lbuild's support files can be found in the same

19 # canonicalized path as this very script.

20 LBUILD_SCRIPT=$(readlink -f ${0})

21 LBUILD_DIR=${LBUILD_DIR:-$(dirname ${LBUILD_SCRIPT})}

23 # include the exit_traps library

24 . ${LBUILD_DIR}/exit_traps.sh

25 . ${LBUILD_DIR}/funcs.sh

27 # our children should die when we do

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

30 # increment this if you have made a change that should force a new kernel

31 # to build built

32 #BUILD_GEN=1

33 #BUILD_GEN=2 # bz19952: remove -lustre tag from kernel RPM names

34 #BUILD_GEN=3 # bz19975: enable the building of src.rpms by default

35 #BUILD_GEN=4 # bz22281: use the git hash in the kernel extra version

36 #BUILD_GEN=5 # TT-107: don't cache the BUILD dir

37 BUILD_GEN=6 # TT-1092: don't cache the BUILD dir, to rebuild external OFED

39 TOPDIR=$PWD

41 KERNELDIR=

42 LINUX=

43 LUSTRE=

44 RELEASE=false

45 # XXX - some recent hacking has pretty much neutered this option.

46 # search through this file for "-bb" and see how many places

47 # simply don't account for this option

48 DO_SRC=true

49 DOWNLOAD=true

50 CANONICAL_TARGET=

51 TARGET=

52 TARGET_ARCH="$(uname -m)"

53 # change default behavior to only build for the current arch

54 TARGET_ARCHS="$TARGET_ARCH"

55 TARGET_ARCHS_ALL="$TARGET_ARCH"

56 [ "$TARGET_ARCH" = "i686" ] && TARGET_ARCHS_ALL="i686 i586 i386"

57 CONFIGURE_FLAGS=

58 EXTERNAL_PATCHES=

59 EXTRA_VERSION=

60 STAGEDIR=

61 TMPDIR=${TMPDIR:-"/var/tmp"}

62 TIMESTAMP=

63 # this is a dir to try reuse old kernel RPMs in (although, it seems to be

64 # unused in any real manner

65 REUSERPM=

66 # this is the dir that should be used to store reuse products

67 REUSEBUILD=

68 # should cached products be used or force rebuilding?

69 USE_BUILD_CACHE=true

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

71 NORPM=false

72 IOKITRPM=true

73 OSDLDISKFSRPM=true

74 OSDZFSRPM=false

75 SMPTYPES="smp bigsmp default ''"

76 PATCHLESS=false

77 XEN=false

78 LINUXOBJ=

79 DISTRO=

80 KERNELTREE=

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

82 KERNEL_LUSTRE_NAMING=false

83 # default not use kabi check.

84 USE_KABI=false

86 # patchless build

87 KERNELRPMSBASE=

88 RPMSMPTYPE=

90 # from target file

91 SERIES=

92 BASE_ARCHS=

93 BIGMEM_ARCHS=

94 BOOT_ARCHS=

95 JENSEN_ARCHS=

96 SMP_ARCHS=

97 BIGSMP_ARCHS=

98 PSERIES64_ARCHS=

99 UP_ARCHS=

100

101 # not in the target file any more

102 CONFIG=

103

104 # build the lustre-tests rpm?

105 LUSTRE_TESTS=true

106

107 DATE=$(date)

108

109 RPMBUILD=

110

111 export CC=${CC:-gcc}

112

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

114 readlink() {

115 local path=$1 ll

116

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

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

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

120 else

121 return 1

122 fi

123 }

124

125 usage() {

126 cat <<EOF

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

128

129 --external-patches=EXTERNAL_PATCHES

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

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

132 tree.

133

134 --extraversion=EXTRAVERSION

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

136

137 --timestamp=TIMESTAMP

138 Date of building lustre in format YYYYMMDDhhmmss

139

140 --reuserpm=DIR

141 Try to reuse old kernel RPMs from DIR

142

143 --reusebuild=DIR

144 Try to reuse old kernel builds from DIR

145

146 --kernelrpm=DIR

147 Path to distro kernel RPM collection

148

149 --ccache

150 Use ccache

151

152 --norpm

153 Do not build RPMs (compile only mode)

154

155 --patchless

156 Build lustre client only

157

158 --distro=DISTRO

159 Which distro using. Autodetect by default

160

161 --kerneldir=KERNELDIR

162 Directory containing Linux source tarballs referenced by target

163 files.

164

165 --kerneltree=KERNELTREE

166 Directory containing dirs with Linux source tarballs referenced by target

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

168

169 --linux=LINUX --with-linux=LINUX

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

171 Lustre modules and userspace are built.

172

173 --lustre=LUSTRE

174 Path to an existing lustre source tarball to use.

175

176 --nodownload

177 Do not try to download a kernel from downloads.lustre.org

178

179 --nosrc

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

181 tarball.

182

183 --ldiskfs

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

185

186 --noiokit

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

188

189 --publish

190 Unused.

191

192 --release

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

194 that this is an official release.

195

196 --src

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

198

199 --stage=DIR

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

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

202 placed in DIR.

203

204 --target=TARGET

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

206 below.

207

208 --target-archs=TARGET_ARCHS

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

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

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

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

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

214

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

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

217

218 --xen

219 Builds a Xen domX kernel.

220

221 --set-value

222 Sets a variable to a given value.

223

224 EOF

225

226 # list_targets

227

228 fatal "$1" "$2"

229 }

230

231 # canonicalize a relative path to a file

232 canon_filepath() {

233 local PATH="$1"

234

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

236 return 1

237 fi

238

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

240 local DIR=${PATH%/*}

241

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

243 return 0

244 }

245

246 # canonicalize a relative path to a dir

247 canon_path() {

248 local PATH="$1"

249

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

251 return 1

252 fi

253

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

255 local CANONPATH=$PWD

256 popd >/dev/null

257

258 echo "$CANONPATH"

259 return 0

260 }

261

262 check_options() {

263

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

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

266 fi

267

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

269 DISTRO=$(autodetect_distro)

270 # remove minor version only for rhel and oel

271 [[ $DISTRO =~ "el-" ]] && DISTRO=${DISTRO%%.*}

272 # remove separator

273 DISTRO=${DISTRO/-/}

274 fi

275

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

277

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

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

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

281

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

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

284

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

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

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

288 fi

289

290 case $TARGET in

291 2.6-rhel6)

292 CANONICAL_TARGET="rhel6"

293 ;;

294 2.6-rhel5)

295 CANONICAL_TARGET="rhel5"

296 ;;

297 2.6-rhel4)

298 CANONICAL_TARGET="rhel-2.6"

299 ;;

300 2.6-suse)

301 CANONICAL_TARGET="sles-2.6"

302 ;;

303 2.6-sles10)

304 CANONICAL_TARGET="sles10-2.6"

305 ;;

306 2.6-sles11 | 3.0-sles11)

307 CANONICAL_TARGET="sles11"

308 ;;

309 2.6-oel5)

310 CANONICAL_TARGET="oel5"

311 ;;

312 hp_pnnl-2.4)

313 CANONICAL_TARGET="hp-pnnl-2.4"

314 ;;

315 2.6-vanilla \

316 | suse-2.4.21-2 \

317 | rh-2.4 \

318 | rhel-2.4 \

319 | sles-2.4 \

320 | 2.6-patchless)

321 CANONICAL_TARGET="$TARGET"

322 ;;

323 esac

324

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

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

327 local timestamplength="${#TIMESTAMP}"

328 if [ $timestamplength -eq 12 ]; then

329 TIMESTAMP="${TIMESTAMP}00"

330 elif [ $timestamplength -ne 14 ]; then

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

332 fi

333

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

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

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

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

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

339 fi

340 fi

341

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

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

344

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

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

347 local bindir="$TOPDIR/bin"

348

349 if [ ! -d $bindir ]; then

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

351 else

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

353 fi

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

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

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

357 export PATH=$bindir:$PATH

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

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

360 echo -n "ccache "

361 ccache -z

362

363 # get some ccache stats when we are done

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

365 # should remove the ccache trap if lbuild is interrupted

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

367 fi

368 fi

369

370 return 0

371

372 }

373

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

375 compare_version () {

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

377 local IFS=.

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

379

380 # padding zero to val1 if it needs

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

382 val1[i]=0

383 done

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

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

386

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

388 return 0

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

390 return 1

391 fi

392 done

393 }

394

395 uniqify() {

396

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

398

399 }

400

401 fetch_url() {

402 local url="$1"

403 local target="$2"

404

405 local rc=0

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

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

408 rc=${PIPESTATUS[0]}

409 fi

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

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

412 rc=${PIPESTATUS[0]}

413 fi

414 else

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

416 fi

417

418 return $rc

419

420 }

421

422 download_srpm() {

423 local target=$1

424 local srpm=$2

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

426

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

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

429 if $DOWNLOAD; then

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

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

432 if type -p kernel_srpm_location; then

433 location=$(kernel_srpm_location)

434 fi

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

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

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

438 rm -f $KERNELDIR/$srpm

439 # punt to a distro specific method if it exists

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

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

442 else

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

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

445 fi

446 fi

447 fi

448 else

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

450 fi

451 fi

452

453 }

454

455 download_file() {

456 local from="$1"

457 local to="$2"

458 local force="$3"

459

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

461

462 if [ -d $to ]; then

463 to="$to/$file"

464 fi

465

466 local semaphore="$to-downloading"

467

468 is_downloading() {

469 if [ ! -f $semaphore ]; then

470 return 1

471 fi

472

473 # make sure the download has not been aborted

474 local now=$(date +%s)

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

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

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

478 if [ $staleness -gt 60 ]; then

479 return 1

480 fi

481

482 return 0

483 }

484

485 is_downloaded() {

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

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

488 if [ -f $semaphore ]; then

489 return 1

490 fi

491

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

493 return 0

494 fi

495

496 return 1

497 }

498

499 if $force || ! is_downloaded; then

500 if is_downloading; then

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

502 while is_downloading; do

503 echo "Waiting for $to to finish downloading"

504 sleep 60

505 done

506 if is_downloaded; then

507 return 0

508 else

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

510 fi

511

512 fi

513

514 if $DOWNLOAD; then

515 echo "Downloading $from..."

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

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

518 touch $semaphore

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

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

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

522 fi

523 rm -f $semaphore

524 delete_exit_trap "download"

525 else

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

527 fi

528 fi

529

530 return 0

531

532 }

533

534 download_ofed() {

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

536

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

538 return 0

539 fi

540

541 local OFED_BASE_VERSION=$OFED_VERSION

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

543 OFED_BASE_VERSION=${OFED_VERSION%.*}

544 fi

545

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

547

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

549 local Mmv

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

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

552 fi

553

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

555 local Mmv daily

556 OFED_VERSION=${OFED_VERSION/daily-/}

557 Mmv=${OFED_VERSION%%-*}

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

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

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

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

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

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

564 fi

565 fi

566

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

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

569

570 }

571

572 parse_mpss_info() {

573 local file="$1"

574 local build="$2"

575 local distro="$3"

576

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

578

579 # convert to MPSS distro naming

580 distro=${distro/sles/suse}

581 distro_name=${distro%%-*}

582

583 # extract links from MPSS info file

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

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

586 grep '.intel.com/' | \

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

588 grep '.tar')

589 local res2=""

590 local res3=""

591 for url in $urls; do

592 # Try to match with MPSS 3.1 distro package

593 if [[ $url =~ mpss-[0-9].[0-9]-$distro.tar ]]; then

594 local bid=${url##*mpss-}

595 bid="${bid%%-$distro.tar}.0-0"

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

597 res3="$bid"

598 elif [ "$build" = "$bid" ]; then

599 res3="$res3 $url"

600 fi

601 # Try to match with MPSS 3.1 source package

602 elif [[ $url =~ mpss-src-[0-9].[0-9].tar ]]; then

603 local bid=${url##*mpss-src-}

604 bid="${bid%%.tar}.0-0"

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

606 res3="$bid"

607 elif [ "$build" = "$bid" ]; then

608 res3="$res3 $url"

609 fi

610 # Try to match with MPSS 3.1 cross compiler package

611 elif [[ $url =~ mpss-[0-9].[0-9]-k1om.tar ]]; then

612 local bid=${url##*mpss-}

613 bid="${bid%%-k1om.tar}.0-0"

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

615 res3="$bid"

616 elif [ "$build" = "$bid" ]; then

617 res3="$res3 $url"

618 fi

619 # Try to match with MPSS 2.1 source package

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

621 local bid=${url##*_src-}

622 bid=${bid%%_$distro_name.tar}

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

624 res2="$bid"

625 elif [ "$build" = "$bid" ]; then

626 res2="$res2 $url"

627 fi

628 fi

629 done

630

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

632 # return a last version of MPSS

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

634 echo "$res3"

635 else

636 echo "$res2"

637 fi

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

639 local ver=${build%.*}

640 local bid=${build%%-*}

641 bid=${bid##$ver.}

642 if [ $bid -eq 0 ]; then

643 # return URLs from MPSS info file

644 echo "$res3"

645 else

646 # return URLs from internal site with MPSS builds

647 # kernel sources:

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

649 # kernel configs:

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

651 # OFED headers:

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

653 fi

654 else

655 # return URLs from MPSS info file

656 echo "$res2"

657 fi

658 }

659

660 # Get public information about last releases of

661 # Intel Manycore Platform Software Stack (MPSS)

662 download_mpss_info() {

663 local file="$1"

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

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

666

667 download_file "$url" "$file" "$force"

668 }

669

670 download_mpss() {

671 local file="$1"

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

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

674

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

676

677 # force re-download if build number is zero

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

679

680 local url

681 local i=0

682 for url in $urls; do

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

684 download_file "$url" "$file" "$force"

685 i=$((i+1))

686 done

687 }

688

689 load_target() {

690

691 EXTRA_VERSION_save="$EXTRA_VERSION"

692 for patchesdir in "$EXTERNAL_PATCHES" \

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

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

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

696 done

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

698

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

700

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

702 # the target file specifies

703 local env_OFED_VERSION="$OFED_VERSION"

704

705 . "$TARGET_FILE"

706

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

708 OFED_VERSION="$env_OFED_VERSION"

709 fi

710

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

712 if $XEN; then

713 OFED_VERSION=""

714 fi

715

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

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

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

719

720 # CC might have been overwriten in TARGET_FILE

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

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

723 fi

724

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

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

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

728 fi

729

730 # verify the series is available

731 if [ "$SERIES" ]; then

732 for series in $SERIES; do

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

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

735 done

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

737 done

738 fi

739

740 # set the location of the .config file

741 local XENPOSTFIX=""

742 if $XEN; then

743 XENPOSTFIX="-xen"

744 fi

745

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

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

748 fi

749

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

751

752 # remember the EXTRA_VERSION before we diddle it here

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

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

755 # a new variable.

756 PRISTINE_EXTRA_VERSION=$EXTRA_VERSION

757

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

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

760 fi

761

762 if [ "$EXTRA_VERSION_save" ]; then

763 EXTRA_VERSION="$EXTRA_VERSION_save"

764 elif ! $RELEASE; then

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

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

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

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

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

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

771 fi

772 fi

773 fi

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

775

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

777

778 BUILD_ARCHS=

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

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

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

782 BUILD_ARCHS="$BUILD_ARCHS $arch"

783 fi

784 done

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

786 echo "Building for: $BUILD_ARCHS"

787 }

788

789 tarflags() {

790 local file="$1"

791

792 case "$file" in

793 '')

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

795 ;;

796 *.tar.gz | *.tgz)

797 echo 'zxf'

798 ;;

799 *.tar.bz2)

800 echo 'jxf'

801 ;;

802 *.tar)

803 echo 'xf'

804 ;;

805 *)

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

807 ;;

808 esac

809

810 }

811

812 untar() {

813 local tarfile="$1"

814 shift

815 local extractfile="$@"

816

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

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

819

820 }

821

822 unpack_ofed() {

823

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

825 return 1

826 fi

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

828

829 }

830

831 unpack_lustre() {

832

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

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

835

836 }

837

838 unpack_mpss() {

839

840 [ -d mpss ] && return 0

841

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

843 local ver=${MPSS_VERSION%.*}

844 local file

845 local i

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

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

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

849 untar "$file" \

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

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

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

853 fi

854 done

855 # Extract kernel configs

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

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

858 echo "Error extracting MPSS kernel configs"

859 return 1

860 fi

861 # Unpack kernel sources

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

863 if ! untar "$file"; then

864 echo "Error unpacking MPSS kernel sources"

865 return 1

866 fi

867 # Extract OFED headers

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

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

870 echo "Error extracting MPSS OFED headers"

871 return 1

872 fi

873 # Remove unpacked archives to save space

874 rm -rf mpss-$ver

875 # Make link to MPSS kernel sources

876 ln -sf linux-* mpss

877 else

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

879

880 mkdir $dir || return 255

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

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

883 popd >/dev/null

884 rm -rf $dir

885 echo "Error unpacking MPSS tarball 1"

886 return 1

887 fi

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

889 if ! untar "$file"; then

890 popd >/dev/null

891 rm -rf $dir

892 echo "Error unpacking MPSS tarball 2"

893 return 1

894 fi

895 popd >/dev/null

896 ln -sf $dir mpss

897 fi

898

899 }

900

901 do_patch_linux() {

902

903 local do_patch=${1:-true}

904

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

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

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

908 for series in $SERIES; do

909 echo -n "Applying series $series:"

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

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

912 SERIES_FILE="$patchesdir/series/$series"

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

914 echo -n " $patch"

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

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

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

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

919 rm -f $FULL_PATCH

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

921 }

922 if $do_patch; then

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

924 rm -f $FULL_PATCH

925 fatal 1 "Error applying patch $patch."

926 }

927 fi

928 done

929 break

930 done

931 echo

932 done

933 $do_patch && popd >/dev/null

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

935

936 }

937

938 build_lustre() {

939 local linux="$1"

940 local linuxobj="$2"

941

942 cp "$LUSTRE" SOURCES

943

944 pushd lustre >/dev/null

945

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

947 local targets arch

948 for arch in $BUILD_ARCHS; do

949 targets="--target $arch $targets"

950 done

951

952 local confoptions=""

953

954 if $PATCHLESS; then

955 confoptions="$confoptions --disable-server"

956 fi

957

958 local rpmbuildopt='-tb'

959 if $NORPM; then

960 rpmbuildopt='-tc'

961 echo NORPM mode. Only compiling.

962 fi

963

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

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

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

967 # line above so is at least consistant.

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

969 if ! build_spl_zfs; then

970 popd >/dev/null # pushd lustre

971 return 255

972 fi

973 fi

974

975 if $PATCHLESS; then

976 RPMBUILD_DEFS="$RPMBUILD_DEFS --without servers"

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

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

979 fi

980 fi

981

982 # ditto for the lustre-tests boolean

983 if ! $LUSTRE_TESTS; then

984 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_tests"

985 fi

986

987 if ! $IOKITRPM; then

988 RPMBUILD_DEFS="$RPMBUILD_DEFS --without lustre_iokit"

989 fi

990

991 local osd_zfs=""

992 if $OSDZFSRPM; then

993 osd_zfs="yes"

994 fi

995

996 local osd_ldiskfs=""

997 if $OSDLDISKFSRPM; then

998 osd_ldiskfs="yes"

999 fi

1000

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

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

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

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

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

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

1007

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

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

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

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

1012

1013 if $DO_SRC; then

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

1015 popd >/dev/null

1016 return 255

1017 fi

1018 fi

1019 popd >/dev/null

1020

1021 }

1022

1023 ###

1024 # build_spl_zfs

1025 #

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

1027 #

1028 # Overrides:

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

1030 # SPLZFSTAG - Tag to checkout of clone repositories

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

1032 #

1033 # return 0 if successful, else 255

1034 build_spl_zfs() {

1035 # make sure the RPM build environment is set up

1036 pushd $TOPDIR

1037 create_rpmbuild_dirs

1038 popd

1039

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

1041 # destination for the rpms

1042 export RPM_BUILD_ROOT=$TOPDIR

1043 SPLZFSVER=${SPLZFSVER:-0.6.2}

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

1045

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

1047 local kver=$(find_linux_release)

1048

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

1050 local pkg

1051 for pkg in spl zfs; do

1052

1053 local rpmpkg

1054

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

1056

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

1058 # default to github but allow override

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

1060

1061 pushd $pkg || return 255

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

1063 git checkout $SPLZFSTAG

1064 else

1065 git checkout -b lbuild $pkg-$SPLZFSVER

1066 fi

1067

1068 # This differentiates between older zfs versions

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

1070 rpmpkg=$pkg-modules

1071 specdir=.

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

1073 else

1074 rpmpkg=kmod-$pkg-devel

1075 specdir=rpm/generic

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

1077 fi

1078

1079 sh autogen.sh || return 255

1080

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

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

1083 ! make dist 2>&1; then

1084 popd

1085 return 255

1086 fi

1087 popd

1088

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

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

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

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

1093 fi

1094

1095 local rpmb

1096 if $DO_SRC; then

1097 rpmb=-ba

1098 else

1099 rpmb=-bb

1100 fi

1101

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

1103 # directories

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

1105 # Manually build rpms

1106 for spec in $speclist; do

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

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

1109 --nodeps -v \

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

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

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

1113 --define "kver $kver" \

1114 --define "kernels $kver" \

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

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

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

1118 return 255

1119 fi

1120 done

1121

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

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

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

1125

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

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

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

1129

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

1131 pushd $TOPDIR

1132 local rpm

1133 for rpm in $rpms; do

1134 rpm2cpio $rpm | cpio -id

1135 done

1136

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

1138 mkdir -p $TOPDIR/zfsdevel

1139 pushd $TOPDIR/zfsdevel

1140 # We also need to extract zfs-devel rpm

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

1142 rpm2cpio $devel_rpm | cpio -id

1143 popd

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

1145 fi

1146 popd

1147

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

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

1150 done

1151

1152 OSDZFSRPM=true

1153

1154 return 0

1155 }

1156

1157 prepare_mpss() {

1158

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

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

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

1162 if ! make ARCH=k1om silentoldconfig ; then

1163 popd >/dev/null

1164 return 1

1165 fi

1166 if ! make ARCH=k1om modules_prepare ; then

1167 popd >/dev/null

1168 return 1

1169 fi

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

1171 else

1172 if ! make defconfig-miclinux; then

1173 popd >/dev/null

1174 return 1

1175 fi

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

1177 popd >/dev/null

1178 return 1

1179 fi

1180 fi

1181 popd >/dev/null

1182

1183 }

1184

1185 stage() {

1186

1187 [ "$STAGEDIR" ] || return 0

1188

1189 for arch in $BUILD_ARCHS; do

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

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

1192 mkdir -p "${rpmdir}"

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

1194 if [ -d RPMS/noarch ]; then

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

1196 fi

1197 done

1198

1199 cp -v "$LUSTRE" "$STAGEDIR"

1200

1201 }

1202

1203 set_rpm_smp_type() {

1204

1205 local infact_arch="${TARGET_ARCH}"

1206

1207 RPMSMPTYPE=""

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

1209

1210 local smp_type

1211 for smp_type in $SMP_ARCHS; do

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

1213 done

1214

1215 for smp_type in $BIGSMP_ARCHS; do

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

1217 done

1218

1219 for smp_type in $PPC64_ARCHS; do

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

1221 done

1222

1223 for smp_type in $DEFAULT_ARCHS; do

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

1225 done

1226

1227 }

1228

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

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

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

1232 _find_linux_release() {

1233 local SRC="$1"

1234 local LINUXRELEASEHEADER=""

1235

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

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

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

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

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

1241 fi

1242

1243 if [ ! -s $LINUXRELEASEHEADER ]; then

1244 fatal 1 "could not find UTS_RELEASE"

1245 fi

1246

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

1248 }

1249

1250 # unpack kernel(/source/devel) RPM

1251 #

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

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

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

1255 # lustre itself)

1256 unpack_linux_devel_rpm() {

1257 local kernelrpm="${1}"

1258

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

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

1261

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

1263

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

1265 return 255

1266 fi

1267

1268 # call a distro specific hook, if available

1269 if type -p unpack_linux_devel_rpm-$DISTRO; then

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

1271 return 255

1272 fi

1273 fi

1274

1275 popd &>/dev/null

1276

1277 find_linux_devel_paths $TOPDIR/reused

1278

1279 return 0

1280

1281 }

1282

1283 build_kernel_ib() {

1284 local linux="$1"

1285 local kib_prefix="$2"

1286 local kib_rpm="$3"

1287

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

1289 local K_SRC="K_SRC"

1290 # ofed 1.3 had a bug in the rpm spec

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

1292 K_SRC="KSRC"

1293 fi

1294

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

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

1297

1298 if compare_version $OFED_VERSION 3.0; then

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

1300 else

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

1302 fi

1303

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

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

1306 case "$TARGET_ARCH" in

1307 ppc64)

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

1309 ;;

1310 esac

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

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

1313 OFED_ISCSI="--with-srp-mod"

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

1315 ##kernels >= 2.6.30)

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

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

1318 #fi

1319

1320 # assume we are just rebuilding the SRPM

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

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

1323

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

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

1326 BUILD_TYPE="-bb"

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

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

1329 local file ed_fragment1 ed_fragment2 n=1

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

1331 ed_fragment1="$ed_fragment1

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

1333 ed_fragment2="$ed_fragment2

1334 %patch$n -p0"

1335 cp $file ${TOPDIR}/SOURCES

1336 let n=$n+1

1337 done

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

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

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

1341 # convention

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

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

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

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

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

1347 if [ $? -eq 0 ] ; then

1348 ed_fragment3="$ed_fragment3

1349 $(cat $file)"

1350 let n=$n+1

1351 fi

1352 done

1353

1354 if [ $n -gt 1 ]; then

1355 ed $SOURCE <<EOF

1356 /^Source: /a

1357 $ed_fragment1

1358 .

1359 /^%setup /a

1360 $ed_fragment2

1361 .

1362 $ed_fragment3

1363 wq

1364 EOF

1365 fi

1366 fi

1367

1368 local linuxrelease=$(find_linux_release)

1369 if compare_version $OFED_VERSION 3.0; then

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

1371 fi

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

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

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

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

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

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

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

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

1380 ${SOURCE} 2>&1; then

1381 fatal 1 "Error building ${kib_rpm}"

1382 fi

1383

1384 }

1385

1386 store_for_reuse() {

1387 local articles="$1"

1388 local module="$2"

1389 local location="$3"

1390 local signature="$4"

1391 local use_links="$5"

1392

1393 local linkflag=""

1394 if $use_links; then

1395 linkflag="l"

1396 fi

1397

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

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

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

1401 fi

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

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

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

1405 fi

1406

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

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

1409 mkdir -p "$location"

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

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

1412 # this solution still slightly racy with the cleanup script

1413 # but the race is a lot tighter now

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

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

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

1417 local article

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

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

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

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

1422 # product, but is around for analysis

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

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

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

1426 "necessary"

1427 return 1

1428 fi

1429 done

1430

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

1432 # interrupted while caching)

1433 touch "$location/.lastused"

1434

1435 # put the temporary location into the final location

1436 # (last one wins)

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

1438 mv "$location" "$finallocation"

1439 rmdir "${location%/*}"

1440 return 0

1441

1442 }

1443

1444 reuse() {

1445 local module="$1"

1446 local dest="$2"

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

1448 local signature="$4"

1449

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

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

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

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

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

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

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

1457 return 1

1458 fi

1459

1460 # so that we know how stale this entry is

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

1462

1463 if $use_links; then

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

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

1466 fi

1467 else

1468 # copying is pretty heavy

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

1470 # do some creative symlinking instead

1471 local dir

1472 for dir in BUILD SRPMS SPECS; do

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

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

1475 fi

1476 done

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

1478 # be a dir we can write into

1479 # could overrun ls's arg list here

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

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

1482 xargs ln -t $dest/SOURCES -s

1483

1484 # same for RPMS/* dirs

1485 # could overrun ls's arg list here

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

1487 local dir

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

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

1490 find $dir -type f |

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

1492 done

1493 fi

1494 return 0

1495 else

1496 return 1

1497 fi

1498 }

1499

1500 basearch() {

1501 local arch="$1"

1502

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

1504 echo "i386"

1505 else

1506 echo "$arch"

1507 fi

1508

1509 }

1510

1511 build_kernel_with_srpm() {

1512 local outfd=$1

1513

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

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

1516 fi

1517

1518 # need to generate the patch for this target

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

1520

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

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

1523 # in BUILD_ARCHS

1524 local release_str

1525 if $RELEASE; then

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

1527 fi

1528

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

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

1531 echo $BUILD_GEN;

1532 cat $CONFIG_FILE $TARGET_FILE $FULL_PATCH;

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

1534 md5sum | cut -d" " -f1)

1535 # see if we can link to the reuse pool

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

1537 # "library"

1538 local CAN_LINK_FOR_REUSE=false

1539 touch $REUSEBUILD/$$

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

1541 CAN_LINK_FOR_REUSE=true

1542 fi

1543 rm $REUSEBUILD/$$

1544 fi

1545

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

1547 # kernel, remember)

1548 local kernel_extra_version=""

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

1550 "$REUSE_SIGNATURE"; then

1551 # nothing cached, build from scratch

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

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

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

1555 fi

1556

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

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

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

1560 #rm -rf $RPMTOPDIR

1561 fatal 1 "Error installing kernel SRPM."

1562 fi

1563

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

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

1566 prepare_and_build_srpm >&${outfd} ||

1567 fatal 1 "failed to prepare_and_build_srpm"

1568

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

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

1571 else

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

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

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

1575 "kernel" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1576 "$CAN_LINK_FOR_REUSE"; then

1577 error "Failed to store kernel RPMS for reuse"

1578 echo "unknown" >&${outfd}

1579 return 1

1580 fi

1581 fi

1582 fi # build reuse

1583

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

1585 local KERNEL_RPM

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

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

1588 fi

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

1590

1591 # should now have the following RPMs

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

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

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

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

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

1597

1598 echo $kernel_extra_version

1599 return 0

1600

1601 }

1602

1603 # build OFED

1604 # globals used:

1605 # TOPDIR

1606 # REUSEBUILD, USE_BUILD_CACHE

1607 # CONFIGURE_FLAGS

1608

1609 build_ofed() {

1610 local linux="$1"

1611 local ofed_version="$2"

1612 local kib_prefix

1613 local kib_rpm

1614

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

1616 # not any vendor specific "inkernel" version

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

1618 return 0

1619 fi

1620

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

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

1623 # that if it exists

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

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

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

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

1628 local ofed_location

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

1630 local rc=${PIPESTATUS[0]}

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

1632 return $rc

1633 else

1634 return 0

1635 fi

1636 elif compare_version $OFED_VERSION 3.0; then

1637 kib_prefix="ofa_kernel"

1638 kib_rpm="kernel-ib"

1639 else

1640 kib_prefix="compat-rdma"

1641 kib_rpm="compat-rdma"

1642 fi

1643

1644 # build kernel-ib/compat-rdma

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

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

1647 echo "$(find_linux_release;

1648 echo "$BUILD_GEN")";

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

1650 cat "$LBUILD_DIR/lbuild" ;

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

1652 md5sum | cut -d" " -f1)

1653 # see if we can link to the reuse pool

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

1655 # "library"

1656 local CAN_LINK_FOR_REUSE=false

1657 touch $REUSEBUILD/$$

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

1659 CAN_LINK_FOR_REUSE=true

1660 fi

1661 rm $REUSEBUILD/$$

1662 fi

1663

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

1665 "$REUSE_SIGNATURE"; then

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

1667 # stash away the existing built articles for a moment

1668 mkdir bak

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

1670 function mv_back {

1671 pushd bak

1672 find . | cpio -pudlm ..

1673 popd

1674 rm -rf bak

1675 }

1676 create_rpmbuild_dirs

1677 fi

1678 # build it

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

1680

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

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

1683 else

1684 # store the resulting RPM build tree for future use

1685 echo "Storing the built ofed for future reuse"

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

1687 "ofed" "$REUSEBUILD" "$REUSE_SIGNATURE" \

1688 "$CAN_LINK_FOR_REUSE"; then

1689 error "Failed to store OFED RPMS for reuse"

1690 mv_back

1691 return 1

1692 fi

1693 # put the stuff we stashed away back

1694 mv_back

1695 fi

1696 fi

1697

1698 pushd "$TOPDIR" >/dev/null

1699 rm -rf ${kib_rpm}-devel

1700 mkdir ${kib_rpm}-devel

1701 cd ${kib_rpm}-devel

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

1703 # might be present on the file

1704 #local linuxrelease=$(find_linux_release)

1705 #ofed_version=$(echo $ofed_version |

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

1707 # FIXME

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

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

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

1711 # can remove following filter.

1712 #ofed_version=$(echo $ofed_version |

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

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

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

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

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

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

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

1720 fi

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

1722 popd >/dev/null

1723

1724 }

1725

1726 build_with_srpm() {

1727

1728 if ! $PATCHLESS; then

1729 local kernel_extra_version

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

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

1732 fi

1733

1734 for arch in $BUILD_ARCHS; do

1735 local kernel_devel_rpm

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

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

1738 fi

1739

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

1741 if ! lnxrel="$kernel_extra_version" unpack_linux_devel_rpm \

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

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

1744 fi

1745 done

1746 else

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

1748 # client build

1749 local kernelrpm

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

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

1752 fi

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

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

1755 fi

1756 fi

1757

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

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

1760 # kernel-devel artifacts

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

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

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

1764 local tmp="$(pwd)"

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

1766 ed find-requires <<EOF

1767 1a

1768 set -x

1769 .

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

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

1772 wq

1773 EOF

1774 ed find-requires.ksyms <<EOF

1775 1a

1776 set -x

1777 .

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

1779 wq

1780 EOF

1781 ed symset-table <<EOF

1782 1a

1783 set -x

1784 .

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

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

1787 wq

1788 EOF

1789

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

1791 fatal 1 "error building OFED"

1792

1793 # now build Lustre

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

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

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

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

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

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

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

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

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

1803 # RPM reuse?

1804 local dir

1805 for dir in RPMS/*; do

1806 pushd $dir

1807 for file in $(ls); do

1808 if [ -h $file ]; then

1809 cp $file foo

1810 mv foo $file

1811 fi

1812 done

1813 popd

1814 done

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

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

1817 for dir in RPMS/*; do

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

1819 continue

1820 fi

1821 pushd $dir

1822 local files=$(ls)

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

1824 cp -al $files ../$TARGET_ARCH

1825 fi

1826 popd

1827 done

1828 else

1829 return 1

1830 fi

1831

1832 }

1833

1834 create_rpmbuild_dirs() {

1835

1836 [ -d RPMS ] || mkdir RPMS

1837 for arch in $BUILD_ARCHS; do

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

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

1840 # even if the target arch is i686

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

1842 fi

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

1844 done

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

1846 [ -d BUILD ] || mkdir BUILD

1847 [ -d SOURCES ] || mkdir SOURCES

1848 [ -d SPECS ] || mkdir SPECS

1849 [ -d SRPMS ] || mkdir SRPMS

1851 }

1853 new_list() {

1855 echo ""

1857 }

1859 add_list() {

1860 local list="$1"

1861 local item="$2"

1862

1863 echo "$list $item"

1864

1865 }

1866

1867 is_list_member() {

1868 local list="$1"

1869 local item="$2"

1870

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

1872

1873 }

1874

1875 #########################################################################

1876 # Generate a backtrace through the call stack.

1877 #

1878 # Input: None

1879 # Output: None

1880 #########################################################################

1881 backtrace() {

1882 local strip=${1:-1}

1883

1884 local funcname="" sourcefile="" lineno="" n

1885

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

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

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

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

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

1891 if [ $n = 1 ]; then

1892 let lineno-=11

1893 fi

1894 # Display function arguments

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

1896 local args newarg j p=0

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

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

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

1900 done

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

1902 fi

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

1904 done

1905

1906 echo

1907 echo "BEGIN BACKTRACE"

1908

1909 #echo ${BASH_LINENO[*]}

1910 #echo ${BASH_SOURCE[*]}

1911 #echo ${FUNCNAME[*]}

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

1913 while [ $i -ge 0 ]; do

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

1915 if [ $i = 0 ]; then

1916 let lineno-=11

1917 fi

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

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

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

1921 echo "$SOURCELINE:$FUNCTION"

1922 i=$((i - 1))

1923 done

1924

1925 echo "END BACKTRACE"

1926

1927 echo $BACKTRACE

1928

1929 }

1930

1931 seen_list=$(new_list)

1932 trap 'set +x;

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

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

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

1936 echo

1937 # have we seen this one

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

1939

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

1941 echo "seen this one already"

1942 else

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

1944 fi

1945 backtrace

1946 ) ; set $xtrace' ERR

1947 set -E

1948

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

1950

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

1952

1953 if [ $? != 0 ]; then

1954 usage 1

1955 fi

1956

1957 eval set -- "$options"

1958

1959 while [ "$1" ]; do

1960 case "$1" in

1961 '')

1962 usage 1

1963 ;;

1964 --ccache)

1965 CCACHE='ccache'

1966 shift

1967 ;;

1968 -D)

1969 DATE=$2

1970 shift 2

1971 ;;

1972 --external-patches)

1973 EXTERNAL_PATCHES=$2

1974 shift 2

1975 ;;

1976 --extraversion)

1977 EXTRA_VERSION=$2

1978 shift 2

1979 ;;

1980 --help | -h)

1981 usage 0

1982 ;;

1983 --kerneldir)

1984 KERNELDIR=$2

1985 shift 2

1986 ;;

1987 --kerneltree)

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

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

1990 fi

1991 shift 2

1992 ;;

1993 --linux | --with-linux)

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

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

1996 fi

1997 shift 2

1998 ;;

1999 --distro)

2000 DISTRO=$2

2001 shift 2

2002 ;;

2003 --reuserpm)

2004 REUSERPM=$2

2005 shift 2

2006 ;;

2007 --reusebuild)

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

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

2010 fi

2011 shift 2

2012 ;;

2013 --norpm)

2014 NORPM=true

2015 shift

2016 ;;

2017 --ldiskfs)

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

2019 shift

2020 ;;

2021 --noiokit)

2022 IOKITRPM=false

2023 shift

2024 ;;

2025 --patchless)

2026 PATCHLESS=true

2027 shift

2028 ;;

2029 --kernelrpm)

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

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

2032 fi

2033 shift 2

2034 ;;

2035 --timestamp)

2036 TIMESTAMP=$2

2037 shift 2

2038 ;;

2039 --lustre)

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

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

2042 fi

2043 shift 2

2044 ;;

2045 --nodownload)

2046 DOWNLOAD=false

2047 shift 1

2048 ;;

2049 --nosrc)

2050 DO_SRC=false

2051 shift 1

2052 ;;

2053 --ofed-version)

2054 OFED_VERSION="$2"

2055 shift 2

2056 ;;

2057 --mpss-version)

2058 MPSS_VERSION="$2"

2059 shift 2

2060 ;;

2061 --publish)

2062 shift

2063 ;;

2064 --release)

2065 RELEASE=true

2066 shift

2067 ;;

2068 --src)

2069 DO_SRC=true

2070 shift 1

2071 ;;

2072 --stage)

2073 STAGEDIR=$2

2074 shift 2

2075 ;;

2076 --tag)

2077 shift 2

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

2079 ;;

2080 --target)

2081 TARGET=$2

2082 shift 2

2083 ;;

2084 --target-archs)

2085 TARGET_ARCHS=$2

2086 shift 2

2087 ;;

2088 --xen)

2089 XEN=true

2090 shift

2091 ;;

2092 --set-value)

2093 eval $2

2094 shift 2

2095 ;;

2096 --)

2097 shift

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

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

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

2101 LUSTRE_TESTS=false

2102 fi

2103 CONFIGURE_FLAGS=$@

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

2105 break

2106 ;;

2107 *)

2108 usage 1 "Unrecognized option: $1"

2109 ;;

2110 esac

2111 done

2112

2113 check_options

2114

2115 unpack_lustre

2116

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

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

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

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

2121

2122 load_target

2123

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

2125 download_ofed

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

2127 fi

2128

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

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

2131

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

2133 download_mpss_info "$MPSS_INFO"

2134

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

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

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

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

2139 fatal 1 "Incorrect MPSS version $MPSS_VERSION"

2140 fi

2141

2142 download_mpss "$MPSS_INFO"

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

2144 echo "Building with MPSS $MPSS_VERSION"

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

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

2147

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

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

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

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

2152 else

2153 MPSS_OFED="--without-o2ib"

2154 fi

2155 fi

2156

2157 # disable unsupported parts:

2158 PATCHLESS=true

2159 IOKITRPM=false

2160 LDISKFSRPM=false

2161 ZFSNOTSUPPORTED="yes"

2162

2163 # define variables for cross compilation:

2164 CROSS_SUFFIX="-mic"

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

2166 CC_TARGET_ARCH=k1om-mpss-linux

2167 LINUX="$TOPDIR/mpss"

2168 RPMBUILD_DEFS="$RPMBUILD_DEFS --define \"cross_requires mpss-bootimage\""

2169 else

2170 CC_TARGET_ARCH=x86_64-k1om-linux

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

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

2173 fi

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

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

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

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

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

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

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

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

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

2183

2184 # redefine CC for proper ./configure during rpmbuild

2185 export CC=${CC_TARGET_ARCH}-gcc

2186 fi

2187

2188 # make sure the RPM build environment is set up

2189 create_rpmbuild_dirs

2190

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

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

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

2194 find_linux_release() {

2195 _find_linux_release $LINUX

2196 }

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

2198 fatal 1 "error building OFED"

2199 build_lustre "$LINUX" "$LINUXOBJ"

2200 else

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

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

2203 fi

2204 source ${LBUILD_DIR}/lbuild-$DISTRO

2205 build_with_srpm || fatal 1 "Failed to build_with_srpm"

2206 fi

2207

2208 stage