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