build/lbuild.old_school

   1 # vim:expandtab:shiftwidth=4:softtabstop=4:tabstop=4:
   2
   3 OLD_SCHOOL=true
   4
   5 RHBUILD=${RHBUILD:-0}
   6 SUSEBUILD=${SUSEBUILD:-0}
   7 LINUX26=${LINUX26:-0}
   8 SUSEBUILD=${SUSEBUILD:-0}
   9
  10 # make sure this module does not get used for anything other than RHEL4
  11 # as this will die when our RHEL4 support (read: need to build binaries)
  12 # dies
  13 if [ "$DISTRO" != "rhel4" -a "$DISTRO" != "sles9" ]; then
  14     fatal 1 "lbuild.old_school is deprecated and only supported for RHEL4
  15 to add lbuild support for $DISTRO you probably want to create an lbuild-$DISTRO
  16 file in the lustre-build module"
  17 fi
  18
  19 build_tarball() {
  20     local TARGET=$1
  21     local SRPM=$2
  22
  23     if [ "$TARGET" = "rhel-2.6" -o "$TARGET" = "rhel-2.4" ]; then
  24         local SPEC=""
  25         if [ "$TARGET" = "rhel-2.6" ]; then
  26             SPEC=kernel-2.6.spec
  27             OLDCONFIG=nonint_oldconfig
  28         elif [ "$TARGET" = "rhel-2.4" ]; then
  29             SPEC=kernel-2.4.spec
  30             OLDCONFIG=oldconfig
  31         fi
  32
  33         RPMTOPDIR=$(mktemp -d $KERNELDIR/rpm_XXXXXX)
  34         mkdir $RPMTOPDIR/BUILD/
  35         rpm -ivh $KERNELDIR/$SRPM --define "_topdir $RPMTOPDIR" || \
  36             { rm -rf $RPMTOPDIR; fatal 1 "Error installing kernel SRPM."; }
  37         $RPMBUILD -bp --nodeps --target i686 $RPMTOPDIR/SPECS/$SPEC --define "_topdir $RPMTOPDIR" 2>&1
  38         pushd $RPMTOPDIR/BUILD/kernel-${lnxmaj}/linux-${lnxmaj} && {
  39             make mrproper
  40             cp configs/kernel-${lnxmaj}-i686-smp.config .config
  41             if ! make $OLDCONFIG > /dev/null; then
  42                 fatal 1 "error trying to make $OLDCONFIG while building a tarball from SRPM."
  43             fi
  44             make include/linux/version.h
  45             rm -f .config
  46             cd ..
  47             tar cjf $KERNEL_FILE linux-${lnxmaj}
  48         }
  49         popd
  50         rm -rf $RPMTOPDIR
  51     fi
  52 }
  53
  54 download_and_build_tarball() {
  55     local target=$1
  56     local kernel_file=$2
  57
  58     local srpm=kernel-${lnxmaj}-${lnxrel}.src.rpm
  59
  60     echo "Downloading http://downloads.lustre.org/public/kernels/$target/old/$srpm..."
  61     if ! wget -nv "http://downloads.lustre.org/public/kernels/$target/old/$srpm" \
  62         -O "$KERNELDIR/$srpm" ; then
  63         fatal 1 "Could not download target $kernel_file's kernel SRPM $srpm from downloads.lustre.org."
  64     fi
  65     [ -s "$KERNELDIR/$srpm" ] || {
  66         rm -rf $KERNELDIR/$srpm
  67         fatal 1 "Could not download target $kernel_file's kernel SRPM $srpm from downloads.lustre.org."
  68     }
  69
  70     build_tarball $target $srpm
  71 }
  72
  73 unpack_linux() {
  74
  75     untar "$KERNEL_FILE" || fatal 1 "Error unpacking Linux tarball"
  76     [ -d linux ] || ln -sf linux* linux
  77
  78 }
  79
  80 patch_linux() {
  81
  82     [ "$SERIES" ] || return 0
  83
  84     do_patch_linux true
  85
  86     echo "Replacing .config files..."
  87     [ -d linux/configs ] || mkdir linux/configs || \
  88         fatal 1 "Error creating configs directory."
  89     rm -f linux/configs/*
  90     copysuccess=0
  91     for patchesdir in "$EXTERNAL_PATCHES" "lustre/lustre/kernel_patches" ; do
  92         [ "$patchesdir" ] && \
  93             cp -v $patchesdir/kernel_configs/kernel-${VERSION}-${TARGET}*.config linux/configs/ >/dev/null && copysuccess=1
  94     done
  95     [ "$copysuccess" = "1" ] || \
  96         fatal 1 "Error copying in kernel configs."
  97 }
  98
  99 pack_linux() {
 100     TARBALL="$(readlink linux)-$EXTRA_VERSION.tar.gz"
 101     echo "Creating patched linux tarball $TARBALL..."
 102     tar -zcf "$TARBALL" "$(readlink linux)" \
 103         --exclude "CVS" --exclude ".cvsignore" \
 104         --exclude "*.orig" --exclude "*~" --exclude "*.rej" || \
 105         fatal 1 "Error creating patched Linux tarball."
 106 }
 107
 108 clean_linux() {
 109     [ -d linux ] || return 0
 110     echo "Cleaning linux..."
 111     [ -L linux ] && rm -rf $(readlink linux)
 112     rm -rf linux
 113 }
 114
 115 prep_kernel_build() {
 116     local lmakeopts="\"\""
 117     if $XEN; then
 118         lmakeopts="--xen"
 119     fi
 120     # make .spec file
 121     ENABLE_INIT_SCRIPTS=""
 122     sed \
 123         -e "s^@BASE_ARCHS@^$BASE_ARCHS^g" \
 124         -e "s^@BIGMEM_ARCHS@^$BIGMEM_ARCHS^g" \
 125         -e "s^@BIGSMP_ARCHS@^$BIGSMP_ARCHS^g" \
 126         -e "s^@BOOT_ARCHS@^$BOOT_ARCHS^g" \
 127         -e "s^@CONFIGURE_FLAGS@^$CONFIGURE_FLAGS^g" \
 128         -e "s^@ENABLE_INIT_SCRIPTS@^$ENABLE_INIT_SCRIPTS^g" \
 129         -e "s^@JENSEN_ARCHS@^$BOOT_ARCHS^g" \
 130         -e "s^@KERNEL_EXTRA_VERSION@^$EXTRA_VERSION^g" \
 131         -e "s^@KERNEL_EXTRA_VERSION_DELIMITER@^$EXTRA_VERSION_DELIMITER^g" \
 132         -e "s^@KERNEL_TARGET_DELIMITER@^$TARGET_DELIMITER^g" \
 133         -e "s^@KERNEL_RELEASE@^${EXTRA_VERSION//-/_}^g" \
 134         -e "s^@KERNEL_SOURCE@^$KERNEL^g" \
 135         -e "s^@KERNEL_VERSION@^$VERSION^g" \
 136         -e "s^@LINUX26@^$LINUX26^g" \
 137         -e "s^@LUSTRE_SOURCE@^${LUSTRE##*/}^g" \
 138         -e "s^@LUSTRE_TARGET@^$TARGET^g" \
 139         -e "s^@PSERIES64_ARCHS@^$PSERIES64_ARCHS^g" \
 140         -e "s^@RHBUILD@^$RHBUILD^g" \
 141         -e "s^@SMP_ARCHS@^$SMP_ARCHS^g" \
 142         -e "s^@SUSEBUILD@^$SUSEBUILD^g" \
 143         -e "s^@UP_ARCHS@^$UP_ARCHS^g" \
 144         -e "s^@LMAKEOPTS@^$lmakeopts^g" \
 145         < $TOPDIR/lustre/build/lustre-kernel-2.4.spec.in \
 146         > lustre-kernel-2.4.spec
 147     [ -d SRPMS ] || mkdir SRPMS
 148     [ -d RPMS ] || mkdir RPMS
 149     [ -d BUILD ] || mkdir BUILD
 150     [ -d SOURCES ] || mkdir SOURCES
 151     for script in linux-{rhconfig.h,merge-config.awk,merge-modules.awk} \
 152         suse-{functions.sh,post.sh,postun.sh,trigger-script.sh.in} \
 153         sles8-{pre,post,postun,update_{INITRD_MODULES,rcfile_setting}}.sh ; do
 154         cp $TOPDIR/lustre/build/$script SOURCES
 155     done
 156     cp "$LUSTRE" "$KERNEL_FILE" SOURCES
 157     if [ "$EXTERNAL_PATCHES" -a -d "$EXTERNAL_PATCHES" ] ; then
 158         tar zcf SOURCES/external-patches.tar.gz -C "$EXTERNAL_PATCHES" series targets patches kernel_configs
 159     else
 160         touch SOURCES/external-patches.tar.gz
 161     fi
 162 }
 163
 164 clean_lustre() {
 165     [ -d lustre ] || return 0
 166     echo "Cleaning Lustre..."
 167     [ -L lustre ] && rm -rf $(readlink lustre)
 168     rm -rf lustre
 169 }
 170
 171 build_kernel() {
 172     echo "Building kernel + Lustre RPMs for: $BUILD_ARCHS..."
 173     targets=
 174     for arch in $BUILD_ARCHS ; do
 175         targets="--target $arch $targets"
 176     done
 177
 178     local rpmbuildopt='-bb'
 179 #    if $NORPM; then
 180 #        rpmbuildopt='-bc'
 181 #        echo NORPM mode. Only compiling.
 182 #        echo "XXX: need to fix lmake - add options to do rpmbuild -bc instead of -bb"
 183 #    fi
 184
 185     $RPMBUILD $targets $rpmbuildopt lustre-kernel-2.4.spec \
 186         --define "_tmppath $TMPDIR" \
 187         --define "_topdir $TOPDIR" 2>&1 || \
 188         fatal 1 "Error building rpms for $BUILD_ARCHS."
 189
 190     if $DO_SRC; then
 191         $RPMBUILD -bs lustre-kernel-2.4.spec \
 192             --define "_tmppath $TMPDIR" \
 193             --define "_topdir $TOPDIR" 2>&1 || \
 194             fatal 1 "Error building .src.rpm."
 195     fi
 196
 197     ( $(skeep_ldiskfs_rpm $TAG) ) && return
 198
 199     pushd $TOPDIR/BUILD/lustre*/ldiskfs || return 255
 200     make dist
 201     if [ "$?" != "0" ] ; then
 202         popd
 203         return 255
 204     fi
 205     cp lustre-ldiskfs*.tar.gz $TOPDIR/SOURCES
 206
 207     gen_lustre_version
 208
 209     local ldiskfs_spec=lustre-ldiskfs.spec
 210     [ -f "$ldiskfs_spec" ] && sed \
 211     -e "s^Release: .*$^Release: $LUSTRE_EXTRA_VERSION^" \
 212     < $ldiskfs_spec \
 213     > ../lustre-ldiskfs.spec
 214
 215     if ! $RPMBUILD $targets $rpmbuildopt ../lustre-ldiskfs.spec \
 216                    --define "_tmppath /var/tmp" \
 217                    --define "_topdir $TOPDIR" 2>&1; then
 218         popd
 219         return 255
 220     fi
 221
 222     if $DO_SRC; then
 223             if ! $RPMBUILD -bs ../lustre-ldiskfs.spec \
 224                            --define "_tmppath /var/tmp" \
 225                            --define "_topdir $TOPDIR" 2>&1; then
 226             popd
 227             return 255
 228         fi
 229     fi
 230     popd
 231 }
 232
 233 #get date of last changed target/config/series/patches
 234 get_last_source_date() {
 235     local filelist="${TOPDIR}/lustre/lustre/kernel_patches/series/${SERIES} \
 236         $CONFIG_FILE"
 237     local TOPDIRnew=$(echo ${TOPDIR} | sed -e s/\\//\\\\\\//g)
 238     filelist="$filelist $( \
 239         cat ${TOPDIR}/lustre/lustre/kernel_patches/series/${SERIES} | \
 240         sed -e s/^/${TOPDIRnew}\\/lustre\\/lustre\\/kernel_patches\\/patches\\// 2>&1)"
 241     local sourcelastdate=$( find ${filelist} -name CVS -prune -o \
 242                 -type f -printf "%T@\n" 2>&1 | sort | tail -1 )
 243     is_integer $sourcelastdate && echo $sourcelastdate
 244 }
 245
 246 #check if variable is integer
 247 is_integer() {
 248     local invariable=$1
 249     [ "$invariable" = "" ] && return 255
 250     local invariableint=$( echo $invariable | sed -e s/[^0-9]//g )
 251     [ "$invariable" = "$invariableint" ] || return 255
 252 }
 253
 254 #store RPMs and/or BUILD dir for future reuse
 255 store_for_reuse() {
 256     local rpmonly=$1
 257     if [ ! "$REUSEBUILD" = "" ] && [ -d  "/$REUSEBUILD/" ] ; then
 258         [ -d "${REUSEBUILD}/${TIMESTAMP}" ] || mkdir "${REUSEBUILD}/${TIMESTAMP}"
 259         [ -d "${REUSEBUILD}/${TIMESTAMP}" ] || return 255
 260     else
 261         return 255
 262     fi
 263
 264     local lnxrelnew=${lnxrel//-/_}
 265     local EXTRA_VERSIONnew=${EXTRA_VERSION//-/_}
 266     local KERNELRPMnew=$(basename "$KERNELRPM")
 267     if [ ! "$rpmonly" = "rpmonly" ]; then
 268             local builddir=
 269         if [ ! "$KERNELCOMPILEDIR" = "" ]; then
 270             builddir="$KERNELCOMPILEDIR"
 271         else
 272             builddir="BUILD/lustre-kernel-${lnxmaj}/lustre/linux-${lnxmaj}"
 273             [ "$KERNELCOMPILEDIR" = "" ] || builddir="$KERNELCOMPILEDIR"
 274             [ -d "$builddir" ] || builddir="BUILD/lustre-kernel-${lnxmaj}/lustre/linux-${lnxmaj}.${lnxrel}"
 275             [ -d "$builddir" ] || builddir="BUILD/lustre-kernel-${lnxmaj}/lustre/linux-${lnxmaj}-${lnxrel}"
 276             if [ ! -d "$builddir" ]; then
 277                 pushd "BUILD/lustre-kernel-${lnxmaj}/lustre/" || return 255
 278                 local basebuilddir=$(ls -d linux-${lnxmaj}* | head -1)
 279                 [ "$basebuilddir" = "" ] || builddir="BUILD/lustre-kernel-${lnxmaj}/lustre/${basebuilddir}"
 280                 popd
 281             fi
 282         fi
 283         [ -d "$builddir" ] || return 255
 284         local dstdir="${REUSEBUILD}/${TIMESTAMP}/linux-${KERNCONFSMPTYPE}-${lnxmaj}-${EXTRA_VERSIONnew}.${TARGET_ARCH}"
 285         ( $PATCHLESS ) && dstdir="${REUSEBUILD}/${TIMESTAMP}/linux-$KERNELRPMnew" && \
 286                 dstdir="${dstdir%.rpm}"
 287         [ -d "$dstdir" ] && rm -rf "$dstdir"
 288         mv "${builddir}" "$dstdir" || return 255
 289         if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
 290             # move the OFED kernel-ib-devel tree as well
 291             mv "${builddir%/*}/kernel-ib-devel/usr/src/ofa_kernel" "${dstdir%/*}" || return 255
 292         fi
 293     fi
 294     #store kernel rpm
 295     local kernelrpmname="kernel-lustre-${KERNCONFSMPTYPE}-${lnxmaj}-${EXTRA_VERSIONnew}.${TARGET_ARCH}.rpm"
 296     [ -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" ] || kernelrpmname="kernel-${KERNCONFSMPTYPE}-${lnxmaj}-${EXTRA_VERSNnew}.${TARGET_ARCH}.rpm"
 297     ( $PATCHLESS ) && [ -f "$KERNELRPM" ] && kernelrpmname="$KERNELRPMnew"
 298     if [ "$rpmonly" = "rpmonly" ] && [ -f "${REUSEBUILD}/${TIMESTAMP}/${kernelrpmname}" ]; then
 299         echo "RPM already exist in store directory tree"
 300     else
 301         [ -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" ] && cp -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" "${REUSEBUILD}/${TIMESTAMP}/"
 302     fi
 303     #store kernel source rpm
 304     kernelrpmname="kernel-lustre-source-${lnxmaj}-${EXTRA_VERSIONnew}.${TARGET_ARCH}.rpm"
 305     [ -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" ] || kernelrpmname="kernel-source-${lnxmaj}-${EXTRA_VERSIONnew}.${TARGET_ARCH}.rpm"
 306     ( $PATCHLESS ) && [ -f "$KERNELSOURCERPM" ] && kernelrpmname=$(basename "$KERNELSOURCERPM")
 307     if [ "$rpmonly" = "rpmonly" ] && [ -f "${REUSEBUILD}/${TIMESTAMP}/${kernelrpmname}" ]; then
 308         echo "RPM already exist in store directory tree"
 309     else
 310             [ -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" ] && cp -f "RPMS/${TARGET_ARCH}/${kernelrpmname}" "${REUSEBUILD}/${TIMESTAMP}/"
 311     fi
 312     if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
 313         # store kernel-ib RPMs
 314         local rpmname
 315         local ofed_version=$(echo $OFED_VERSION |
 316                              sed -re 's/-(20[0-9]{6,6}-[0-9]{4,4}|rc[0-9]*)$//')
 317         for rpmname in "kernel-ib" "kernel-ib-devel"; do
 318             rpmname="${rpmname}-${ofed_version}"
 319             if $PATCHLESS; then
 320                 rpmname="${rpmname}-${LINUXRELEASE//-/_}"
 321             else
 322                 rpmname="${rpmname}-${lnxmaj}${EXTRA_VERSION_DELIMITER//-/_}${EXTRA_VERSIONnew}${TARGET_DELIMITER//-/_}${KERNCONFSMPTYPE}"
 323             fi
 324             rpmname="${rpmname}.${TARGET_ARCH}.rpm"
 325             if [ "$rpmonly" = "rpmonly" ] && [ -f "${REUSEBUILD}/${TIMESTAMP}/${rpmname}" ]; then
 326                 echo "RPM already exist in store directory tree"
 327             else
 328                 [ -f "RPMS/${TARGET_ARCH}/${rpmname}" ] && cp -f "RPMS/${TARGET_ARCH}/${rpmname}" "${REUSEBUILD}/${TIMESTAMP}/"
 329             fi
 330         done
 331     fi
 332 }
 333
 334 #look for kernel source RPM
 335 find_linux_source_rpm() {
 336     local rpmfile=
 337     local findarch=true
 338     local arch=
 339     local pathtorpms=
 340     [ ! "$TARGET_ARCH" = "" ] && arch=$TARGET_ARCH && findarch=false
 341
 342     if ! $findarch; then
 343         pathtorpms="${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}/${arch}"
 344         [ -d $pathtorpms ] || return 255
 345         case "$DISTRO" in
 346             rhel4)
 347                 rpmfile="kernel-${lnxmaj}-${lnxrel}.src.rpm"
 348             ;;
 349             sles10)
 350                 rpmfile="kernel-source-${lnxmaj}.${lnxrel}.${arch}.rpm"
 351             ;;
 352             *)
 353                 rpmfile="kernel-source-${lnxmaj}-${lnxrel}.${arch}.rpm"
 354             ;;
 355         esac
 356         [ -f "${pathtorpms}/${rpmfile}" ] || return 255
 357         KERNELSOURCERPM="${pathtorpms}/${rpmfile}"
 358     else
 359         for arch in $TARGET_ARCHS_ALL; do
 360         pathtorpms="${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}/${arch}"
 361         [ -d $pathtorpms ] || continue
 362         case "$DISTRO" in
 363             rhel4)
 364                 rpmfile="kernel-${lnxmaj}-${lnxrel}.src.rpm"
 365             ;;
 366             sles10)
 367                 rpmfile="kernel-source-${lnxmaj}.${lnxrel}.${arch}.rpm"
 368             ;;
 369             *)
 370                 rpmfile="kernel-source-${lnxmaj}-${lnxrel}.${arch}.rpm"
 371             ;;
 372         esac
 373         [ -f "${pathtorpms}/${rpmfile}" ] || continue
 374         KERNELSOURCERPM="${pathtorpms}/${rpmfile}"
 375         TARGET_ARCH=${arch}
 376         break
 377         done
 378     fi
 379     [ -f "${KERNELSOURCERPM}" ] || return 255
 380 }
 381
 382 #unpack and make symlinks for reusing kernel RPM
 383 reuse_kernel_rpm() {
 384     local pathtorpm=$1
 385     local pathtokernelibrpm=$2
 386     [ "$pathtorpm" = "" ] && return 255
 387     [ -f "$pathtorpm" ] || return 255
 388     [ -d $TOPDIR/reused ] || mkdir $TOPDIR/reused
 389     pushd $TOPDIR/reused || return 255
 390
 391     rpm2cpio < $pathtorpm | cpio -idc
 392     [ ${PIPESTATUS[0]} -eq 0 ] || return 255
 393
 394     if [ -n "$pathtokernelibrpm" ] && [ -f "$pathtokernelibrpm" ]; then
 395         rpm2cpio < $pathtokernelibrpm | cpio -idc
 396         [ ${PIPESTATUS[0]} -eq 0 -o ${PIPESTATUS[1]} -eq 0 ] || return 255
 397         CONFIGURE_FLAGS="--with-o2ib=$(pwd)/usr/src/ofa_kernel ${CONFIGURE_FLAGS}"
 398     fi
 399
 400     local smptype=
 401     if pushd usr/src/linux-*-obj/${TARGET_ARCH}; then
 402         local smptypes="$SMPTYPES"
 403         [ "$RPMSMPTYPE" = "" ] || smptypes=$RPMSMPTYPE
 404         ( ! $PATCHLESS ) && [ ! "$KERNCONFSMPTYPE" = "" ] && smptypes="$KERNCONFSMPTYPE"
 405         local cursmptype=
 406         for cursmptype in $smptypes; do
 407             [ "$cursmptype" = "''" ] && continue
 408             [ -d $cursmptype ] && smptype=$cursmptype
 409             [ -d $smptype ] && break
 410         done
 411         popd
 412     fi
 413     if [ "${smptype}" = "" ]; then
 414         popd
 415         return 255 # cannot detect smp type
 416     fi
 417     if pushd usr/src/linux-*-obj/${TARGET_ARCH}/$smptype/include2; then
 418         local base=$(readlink asm)
 419         if [ ! -d "/${base}/" ]; then
 420             rm -f asm
 421             base=$(basename "$base")
 422             if pushd ../../../../linux-*/include; then
 423                 local lsrc=$(pwd)
 424                 popd
 425                 [ -d "$lsrc/${base}" ] && ln -s $lsrc/${base} asm
 426             fi
 427         fi
 428         popd
 429         read a b < <(echo $(pwd)/usr/src/linux-*)
 430         if [[ $a == $(pwd)/* && $b = $(pwd)/* ]]; then
 431             cp -f $a/include/linux/config.h $b/${TARGET_ARCH}/$smptype/include/linux/
 432             cp $b/${TARGET_ARCH}/$smptype/.config $a/
 433             [ -f "$b/${TARGET_ARCH}/$smptype/.config" ] && KERNELRPMCONFIG="$b/${TARGET_ARCH}/$smptype/.config"
 434             cp $b/${TARGET_ARCH}/$smptype/.kernelrelease $a/
 435             [ -f "$b/${TARGET_ARCH}/$smptype/.kernelrelease" ] && KERNELRPMRELEASE="$b/${TARGET_ARCH}/$smptype/.kernelrelease"
 436             LINUX=$a
 437             LINUXOBJ=$b/${TARGET_ARCH}/$smptype
 438 #            local fname=$(basename $kernel_rpm)
 439 #            KERNELRPMSDIR=${kernel_rpm%$fname}
 440         fi
 441     fi
 442     popd
 443     [ "$LINUX" = "" ] && return 255
 444     [ -d "$LINUX" ] || return 255
 445 }
 446
 447 #build linux kernel rpm
 448 build_linux_rpm() {
 449     pushd $LINUX || return 255
 450     make binrpm-pkg || ( popd ; return 255 )
 451     local addlnxrel=
 452     [ -f ".version" ] && addlnxrel="-$(cat .version)"
 453     popd
 454     local arch=
 455     for arch in $TARGET_ARCHS_ALL; do
 456         [ -f "/usr/src/rpm/RPMS/$arch/kernel-$lnxmaj.${lnxrel}${addlnxrel}.$arch.rpm" ] && \
 457             KERNELRPM="/usr/src/rpm/RPMS/$arch/kernel-$lnxmaj.${lnxrel}${addlnxrel}.$arch.rpm" && \
 458             TARGET_ARCH="$arch"
 459         [ -f "/usr/src/packages/RPMS/$arch/kernel-$lnxmaj.${lnxrel}${addlnxrel}.$arch.rpm" ] && \
 460             KERNELRPM="/usr/src/packages/RPMS/$arch/kernel-$lnxmaj.${lnxrel}${addlnxrel}.$arch.rpm" && \
 461             TARGET_ARCH="$arch"
 462     done
 463     [ "$KERNELRPM" = "" ] || return
 464     return 255
 465 }
 466
 467 #build linux kernel
 468 build_linux() {
 469     local nofullmake=$1
 470     local nocopykernel=$2
 471     pushd $LINUX || fatal 1 "Kernel source not found"
 472     [ "$nofullmake" = "nofullmake" ] || make mrproper
 473     [ "$nofullmake" = "nofullmake" ] || rm -f rpm-release
 474 #    [ "$nocopykernel" = "copyrpmkernel" ] || rm -f localversion-*
 475     [ "$nocopykernel" = "copykernel" ] && [ -f "$CONFIG_FILE" ] && cp $CONFIG_FILE .config
 476     if [ "$nocopykernel" = "copyrpmkernel" ]; then
 477         [ -f "$KERNELRPMCONFIG" ] && cp $KERNELRPMCONFIG .config
 478         if [ -f "$KERNELRPMRELEASE" ]; then
 479             cp $KERNELRPMRELEASE .
 480         else
 481             sed -e "s/^EXTRAVERSION\s\+=\s\+.*$/EXTRAVERSION = -${lnxrel}/" < Makefile > Makefile.new
 482             [ -f "Makefile.new" ] && mv Makefile.new Makefile
 483         fi
 484     fi
 485     [ -f ".config" ] || ( popd ; echo "Cannot find .config file"; return 255 )
 486     make oldconfig || ( popd ; return 255 )
 487     make include/linux/version.h
 488     if [ ! "$nofullmake" = "nofullmake" ]; then
 489         make || ( popd ; return 255 )
 490     fi
 491     popd
 492     return
 493 }
 494
 495 #build patchless lustre
 496 patchless_build_sequence() {
 497     if [ -f $LINUX/Makefile ]; then
 498         # Get the correct kernel release - I'm unsure how this can ever
 499         # work otherwise, unless you're using the exact same kernel version
 500         # Lustre is shipped with.
 501
 502         local LINUXRELEASE=$(find_linux_release ${LINUXOBJ:-$LINUX})
 503         if [ -z "$LINUXRELEASE" ]; then
 504             echo "Failed to find linux release in ${LINUXOBJ:-$LINUX}"
 505             RC=255
 506         fi
 507
 508         lnxmaj=$(echo $LINUXRELEASE | cut -f1 -d-)
 509         EXTRA_VERSION=$(echo $LINUXRELEASE | cut -f2 -d-)_lustre.$LUSTRE_VERSION
 510         RPMSMPTYPE=" "
 511         build_lustre "${LINUX}" "${LINUXOBJ}" && buildsuccess=true
 512     else
 513     #try to build from kernel-devel RPM (RHEL)
 514     LINUX=
 515     TARGET_ARCH=
 516     local rpmfound=false
 517     local buildsuccess=false
 518     local storeforreuse=false
 519     if [ "$KERNELRPMSBASE" = "" ] || [ ! -d "$KERNELRPMSBASE" ]; then
 520         return 255
 521     fi
 522     [ -d $TOPDIR/reused ] && rm -rf $TOPDIR/reused
 523
 524     local delimiter=${EXTRA_VERSION_DELIMITER:-"-"}
 525
 526     # default to source type -source and special case below
 527     local type=-source
 528     case "$DISTRO" in
 529         rhel*)
 530             type=-devel
 531             ;;
 532     esac
 533
 534     local kernel_devel_rpm
 535
 536     if ! kernel_devel_rpm=$(find_linux_rpm "$type" "$delimiter"); then
 537         fatal 1 "Could not find the kernel$type RPM in ${KERNELRPMSBASE}/${lnxmaj}/${DISTRO}"
 538     fi
 539
 540     # find_linux_rpm() used to set these globals, but now it's a function
 541     # run in a subshell so it's unable to set globals in our namespace
 542     TARGET_ARCH=$(rpm -q --queryformat "%{ARCH}" -p "$kernel_devel_rpm")
 543     BUILD_ARCHS="$TARGET_ARCH"
 544
 545     unpack_linux_devel_rpm "$kernel_devel_rpm" "$delimiter" && rpmfound=true
 546
 547     [ -d SRPMS ] || mkdir SRPMS
 548     [ -d RPMS ] || mkdir RPMS
 549     [ -d BUILD ] || mkdir BUILD
 550     [ -d SOURCES ] || mkdir SOURCES
 551
 552     # first build kernel-ib
 553     if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
 554         $rpmfound && build_kernel_ib
 555     fi
 556     ( $rpmfound ) && build_lustre "${LINUX}" "${LINUXOBJ}" && buildsuccess=true && find_linux_source_rpm
 557     fi
 558
 559     if $buildsuccess; then
 560         [ -d "RPMS/${TARGET_ARCH}" ] && [ -f "$KERNELRPM" ] && \
 561             cp "$KERNELRPM" RPMS/${TARGET_ARCH}/
 562         [ -d "RPMS/${TARGET_ARCH}" ] && [ -f "$KERNELSOURCERPM" ] && \
 563             cp "$KERNELSOURCERPM" RPMS/${TARGET_ARCH}/
 564         KERNELCOMPILEDIR="$LINUX"
 565         if $storeforreuse; then
 566             store_for_reuse || echo "Cannot store for future reuse"
 567         fi
 568
 569         return
 570     elif ! $rpmfound; then
 571         echo "COULD NOT FIND VENDOR -devel or -source RPM for $DISTRO/$TARGET_ARCH: $lnxmaj-$lnxrel in $KERNELRPMSBASE"
 572         return 255
 573     else
 574         echo "Patchless build failed."
 575         return 255
 576     fi
 577 }
 578
 579 #check timestamp value. should bi 14-digits string
 580 check_timestamp() {
 581     local invalue=$1
 582     local timestampnodig=$(echo $invalue | sed -e s/[0-9]*//g)
 583     [ "$timestampnodig" = "" ] || return 255
 584     local timestamplength="${#invalue}"
 585     [ $timestamplength -eq 14 ] || return 255
 586 }
 587
 588 # get list of suitable directories with potential reused staff
 589 get_reuse_dir_list() {
 590     local rpmonly=$1
 591     local reusedkernelmasknew=$2
 592     local buildtimestamp=
 593     local dirsforreuse=
 594     local sourcelastdate=$(get_last_source_date)
 595     for buildtimestamp in $(ls "$REUSEBUILD/" 2>&1); do
 596         [ -d "$REUSEBUILD/$buildtimestamp" ] || continue
 597         check_timestamp "$buildtimestamp" || continue
 598         local buildtimestampstr=$(echo $buildtimestamp | \
 599             sed -e "s^\(....\)\(..\)\(..\)\(..\)\(..\)\(..\)^\1-\2-\3 \4:\5:\6 GMT^g")
 600         local buildtimestampepoch=$(date --date="$buildtimestampstr"  +%s )
 601         #check for suitable date
 602             if ! $PATCHLESS; then
 603             [ $buildtimestampepoch -ge $sourcelastdate ] || continue
 604             fi
 605         #check for suitable version
 606         if [ "$rpmonly" = "rpmonly" ]; then
 607             local reusedkernelprefix="kernel-lustre-"
 608             ( $PATCHLESS ) && reusedkernelprefix=
 609             local rpmmask="${reusedkernelprefix}${REUSEDKERNELMASK}"
 610             [ "$reusedkernelmasknew" = "" ] || rpmmask="$reusedkernelmasknew"
 611             [ -f $REUSEBUILD/$buildtimestamp/${rpmmask}.rpm ] && \
 612                 dirsforreuse="$dirsforreuse $REUSEBUILD/$buildtimestamp"
 613         else
 614             local rpmmask="$REUSEDKERNELMASK"
 615             [ "$reusedkernelmasknew" = "" ] || rpmmask="$reusedkernelmasknew"
 616             pushd $REUSEBUILD/$buildtimestamp/linux-${rpmmask} > /dev/null 2>&1 || continue
 617             local curdir=$(pwd)
 618             dirsforreuse="$dirsforreuse $curdir"
 619             popd
 620         fi
 621     done
 622     echo "$dirsforreuse"
 623 }
 624
 625 #try to reuse old RPM
 626 build_sequence_rpm_reuse() {
 627     local sourcerpm=$1
 628     [ "$REUSERPM" = "" ] && [ "$REUSEBUILD" = "" ] && return 255
 629     local dirsforreuse=
 630     if ! [ "$REUSEBUILD" = "" ] && [ -d "$REUSEBUILD" ]; then #try to reuse RPM
 631         local REUSEDKERNELMASKnew=$(echo $REUSEDKERNELMASK | sed -e "s/^[^0-9]*//")
 632         REUSEDKERNELMASKnew="kernel-lustre-source-${REUSEDKERNELMASKnew}"
 633         local dirsforreuse="$(get_reuse_dir_list rpmonly $REUSEDKERNELMASKnew)"
 634         local buildsuccess=false
 635         LINUXOBJ=
 636         for curdir in $(echo $dirsforreuse); do
 637             [ -d "$curdir" ] || continue
 638             local reusedkernelprefix="kernel-lustre-"
 639             local reusedkernelrpm=
 640             [ -f ${curdir}/${reusedkernelprefix}${REUSEDKERNELMASK}.rpm ] && \
 641                 reusedkernelrpm=$(ls ${curdir}/${reusedkernelprefix}${REUSEDKERNELMASK}.rpm | head -1 )
 642             [ -f "$reusedkernelrpm" ] || continue
 643
 644             local reusedkernelsourcerpm=
 645             [ -f ${curdir}/${REUSEDKERNELMASKnew}.rpm ] && \
 646                 reusedkernelsourcerpm=$(ls ${curdir}/${REUSEDKERNELMASKnew}.rpm | head -1 )
 647             [ -f "$reusedkernelsourcerpm" ] || continue
 648
 649             # don't need to check for kernel-ib RPM reuse here because sles9 is not supported
 650             # by OFED >= 1.3.0 and this function appears to only be used for sles9
 651
 652             [ -d $TOPDIR/reused ] && rm -rf $TOPDIR/reused
 653             reuse_kernel_rpm "$reusedkernelsourcerpm" "" && build_linux nofullmake copyrpmkernel && build_lustre "${LINUX}" "${LINUXOBJ}" && buildsuccess=true
 654             ( $buildsuccess ) || continue
 655             if ( ! $NORPM ) && ( ! $PATCHLESS ) ; then
 656                 [ -f "$reusedkernelrpm" ] && \
 657                     cp -f  "$reusedkernelrpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1
 658
 659                 [ -f "$reusedkernelsourcerpm" ] && \
 660                     cp -f  "$reusedkernelsourcerpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1 && \
 661                     touch RPMS/${TARGET_ARCH}/kernel_was_reused
 662             fi
 663             return
 664         done
 665     fi
 666     return 255
 667 }
 668
 669 #try to reuse old BUILD dir
 670 build_sequence_reuse() {
 671     local sourcerpm=$1
 672     [ "$REUSERPM" = "" ] && [ "$REUSEBUILD" = "" ] && return 255
 673     local dirsforreuse=
 674     if [ ! "$REUSEBUILD" = "" ] && [ -d "$REUSEBUILD" ]; then #try to reuse old kernel build directory
 675         local dirsforreuse="$(get_reuse_dir_list)"
 676         local buildsuccess=false
 677         LINUXOBJ=
 678         local REUSEDKERNELMASKnew=$(echo $REUSEDKERNELMASK | sed -e "s/^[^0-9]*//")
 679         for curdir in $(echo $dirsforreuse); do
 680             local reusedkernelrpm=
 681             local reusedkernelsourcerpm=
 682             local reusedkernelibrpm=
 683             [ -d "$curdir" ] || continue
 684             [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" -a
 685               ! -d "${curdir%/*}/ofa_kernel" ] && continue
 686             local reusedkernelprefix="kernel-lustre-"
 687             ( $PATCHLESS ) && reusedkernelprefix=
 688             [ -f ${curdir}/../${reusedkernelprefix}${REUSEDKERNELMASK}.rpm ] && \
 689                 reusedkernelrpm=$(ls ${curdir}/../${reusedkernelprefix}${REUSEDKERNELMASK}.rpm | head -1 )
 690             reusedkernelprefix="kernel-lustre-source-"
 691             [ -f ${curdir}/../${reusedkernelprefix}${REUSEDKERNELMASKnew}.rpm ] && \
 692                 reusedkernelsourcerpm=$(ls ${curdir}/../${reusedkernelprefix}${REUSEDKERNELMASKnew}.rpm | head -1 )
 693             if [ -n "$OFED_VERSION" -a "$OFED_VERSION" != "inkernel" ]; then
 694                 gen_lustre_version
 695                 reusedkernelprefix="kernel-ib-"
 696                 [ -f ${curdir}/../${reusedkernelprefix}${OFED_VERSION}-${LUSTRE_EXTRA_VERSION}.${TARGET_ARCH}.rpm ] && \
 697                     reusedkernelibrpm=$(ls ${curdir}/../${reusedkernelprefix}${OFED_VERSION}-${LUSTRE_EXTRA_VERSION}.${TARGET_ARCH}.rpm | head -1 )
 698                     reusedkernelibdevelrpm=$(ls ${curdir}/../${reusedkernelprefix}devel-${OFED_VERSION}-${LUSTRE_EXTRA_VERSION}.${TARGET_ARCH}.rpm | head -1 )
 699             fi
 700             if ! ( $NORPM ) && ! [ -f "$reusedkernelrpm" ]; then #kernel rpm not found. Build all
 701                 continue
 702             fi
 703             if ! ( $NORPM ) && ! [ -f "$reusedkernelsourcerpm" ]; then #kernel source rpm not found. Build all
 704                 continue
 705             fi
 706             if [ -n "$OFED_VERSION" ]; then
 707                 if [ "$OFED_VERSION" != "inkernel" ]; then
 708                     if ! ( $NORPM ) && [ ! -f "$reusedkernelibrpm" -o ! -f "$reusedkernelibdevelrpm"]; then #kernel-ib{,-devel} rpm not found. Build all
 709                         continue
 710                     fi
 711                     CONFIGURE_FLAGS="--with-o2ib=${curdir%/*}/ofa_kernel ${CONFIGURE_FLAGS}"
 712                 else
 713                     CONFIGURE_FLAGS="--with-o2ib=yes ${CONFIGURE_FLAGS}"
 714                 fi
 715             fi
 716             LINUX="$curdir"
 717             build_lustre "${LINUX}" "${LINUXOBJ}" || continue
 718             touch "$curdir/../"
 719             buildsuccess=true
 720             if ( ! $NORPM ) && ( ! $PATCHLESS ) ; then
 721                 [ -f "$reusedkernelrpm" ] && \
 722                     cp -f  "$reusedkernelrpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1 && \
 723                     touch RPMS/${TARGET_ARCH}/kernel_was_reused
 724                 [ -f "$reusedkernelsourcerpm" ] && \
 725                     cp -f  "$reusedkernelsourcerpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1
 726                 [ -f "$reusedkernelibrpm" ] && \
 727                     cp -f  "$reusedkernelibrpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1
 728                     cp -f  "$reusedkernelibdevelrpm"  RPMS/${TARGET_ARCH}/ > /dev/null 2>&1
 729             fi
 730             return
 731         done
 732     fi
 733     return 255
 734 }
 735
 736 build_sequence() {
 737     if $DO_SRC; then
 738         unpack_linux
 739         patch_linux
 740         pack_linux
 741         clean_linux
 742     fi
 743     prep_kernel_build || return 255
 744     clean_lustre || return 255
 745
 746     build_kernel || return 255
 747 }
 748
 749 old_school_download_kernel() {
 750
 751     if [ "$KERNELDIR" ] ; then
 752         KERNEL_FILE="$KERNELDIR/$KERNEL"
 753         if [ ! -r "$KERNEL_FILE" ] ; then
 754             # see if we have an SRPM we can build a tarball for
 755             KERNEL_SRPM=kernel-${lnxmaj}-${lnxrel}.src.rpm
 756             if [ -r "$KERNELDIR/$KERNEL_SRPM" ] ; then
 757                 build_tarball $CANONICAL_TARGET $KERNEL_SRPM
 758             else
 759                 if $DOWNLOAD; then
 760                     echo "Downloading http://downloads.lustre.org/public/kernels/$DISTRO/old/$KERNEL..."
 761                     if ! wget -nv "http://downloads.lustre.org/public/kernels/$DISTRO/old/$KERNEL" -O "$KERNELDIR/$KERNEL" ; then
 762                         # see if we can do it with an SRPM from the download site
 763                         download_and_build_tarball $CANONICAL_TARGET $KERNEL_FILE
 764                     else
 765                         [ -s "$KERNELDIR/$KERNEL" ] || {
 766                             rm -rf "$KERNELDIR/$KERNEL"
 767                             fatal 1 "Target $TARGET's kernel $KERNEL not found in directory $KERNELDIR."
 768                         }
 769                     fi
 770                 else
 771                     fatal 1 "Target $TARGET's kernel file $KERNEL not found in kernel directory $KERNELDIR."
 772                 fi
 773             fi
 774         fi
 775     fi
 776 }