gen_compile.sh

   1 #!/bin/bash
   2
   3 compile_kernel_args() {
   4         local ARGS
   5
   6         ARGS=''
   7         if [ "${KERNEL_CROSS_COMPILE}" != '' ]
   8         then
   9                 ARGS="${ARGS} CROSS_COMPILE=\"${KERNEL_CROSS_COMPILE}\""
  10         else
  11                 if [ "${KERNEL_CC}" != '' ]
  12                 then
  13                         ARGS="CC=\"${KERNEL_CC}\""
  14                 fi
  15                 if [ "${KERNEL_LD}" != '' ]
  16                 then
  17                         ARGS="${ARGS} LD=\"${KERNEL_LD}\""
  18                 fi
  19                 if [ "${KERNEL_AS}" != '' ]
  20                 then
  21                         ARGS="${ARGS} AS=\"${KERNEL_AS}\""
  22                 fi
  23         fi
  24         echo -n "${ARGS}"
  25 }
  26
  27 compile_utils_args()
  28 {
  29         local ARGS
  30
  31         ARGS=''
  32         if [ "${UTILS_ARCH}" != '' ]
  33         then
  34                 ARGS="ARCH=\"${UTILS_ARCH}\""
  35         fi
  36         if [ "${UTILS_CC}" != '' ]
  37         then
  38                 ARGS="CC=\"${UTILS_CC}\""
  39         fi
  40         if [ "${UTILS_LD}" != '' ]
  41         then
  42                 ARGS="${ARGS} LD=\"${UTILS_LD}\""
  43         fi
  44         if [ "${UTILS_AS}" != '' ]
  45         then
  46                 ARGS="${ARGS} AS=\"${UTILS_AS}\""
  47         fi
  48
  49         echo -n "${ARGS}"
  50 }
  51
  52 export_utils_args()
  53 {
  54         save_args
  55         if [ "${UTILS_ARCH}" != '' ]
  56         then
  57                 export ARCH="${UTILS_ARCH}"
  58         fi
  59         if [ "${UTILS_CC}" != '' ]
  60         then
  61                 export CC="${UTILS_CC}"
  62         fi
  63         if [ "${UTILS_LD}" != '' ]
  64         then
  65                 export LD="${UTILS_LD}"
  66         fi
  67         if [ "${UTILS_AS}" != '' ]
  68         then
  69                 export AS="${UTILS_AS}"
  70         fi
  71 }
  72
  73 unset_utils_args()
  74 {
  75         if [ "${UTILS_ARCH}" != '' ]
  76         then
  77                 unset ARCH
  78         fi
  79         if [ "${UTILS_CC}" != '' ]
  80         then
  81                 unset CC
  82         fi
  83         if [ "${UTILS_LD}" != '' ]
  84         then
  85                 unset LD
  86         fi
  87         if [ "${UTILS_AS}" != '' ]
  88         then
  89                 unset AS
  90         fi
  91         reset_args
  92 }
  93
  94 export_kernel_args()
  95 {
  96         if [ "${KERNEL_CC}" != '' ]
  97         then
  98                 export CC="${KERNEL_CC}"
  99         fi
 100         if [ "${KERNEL_LD}" != '' ]
 101         then
 102                 export LD="${KERNEL_LD}"
 103         fi
 104         if [ "${KERNEL_AS}" != '' ]
 105         then
 106                 export AS="${KERNEL_AS}"
 107         fi
 108         if [ "${KERNEL_CROSS_COMPILE}" != '' ]
 109         then
 110                 export CROSS_COMPILE="${KERNEL_CROSS_COMPILE}"
 111         fi
 112 }
 113
 114 unset_kernel_args()
 115 {
 116         if [ "${KERNEL_CC}" != '' ]
 117         then
 118                 unset CC
 119         fi
 120         if [ "${KERNEL_LD}" != '' ]
 121         then
 122                 unset LD
 123         fi
 124         if [ "${KERNEL_AS}" != '' ]
 125         then
 126                 unset AS
 127         fi
 128         if [ "${KERNEL_CROSS_COMPILE}" != '' ]
 129         then
 130                 unset CROSS_COMPILE
 131         fi
 132 }
 133 save_args()
 134 {
 135         if [ "${ARCH}" != '' ]
 136         then
 137                 export ORIG_ARCH="${ARCH}"
 138         fi
 139         if [ "${CC}" != '' ]
 140         then
 141                 export ORIG_CC="${CC}"
 142         fi
 143         if [ "${LD}" != '' ]
 144         then
 145                 export ORIG_LD="${LD}"
 146         fi
 147         if [ "${AS}" != '' ]
 148         then
 149                 export ORIG_AS="${AS}"
 150         fi
 151         if [ "${CROSS_COMPILE}" != '' ]
 152         then
 153                 export ORIG_CROSS_COMPILE="${CROSS_COMPILE}"
 154         fi
 155 }
 156 reset_args()
 157 {
 158         if [ "${ORIG_ARCH}" != '' ]
 159         then
 160                 export ARCH="${ORIG_ARCH}"
 161                 unset ORIG_ARCH
 162         fi
 163         if [ "${ORIG_CC}" != '' ]
 164         then
 165                 export CC="${ORIG_CC}"
 166                 unset ORIG_CC
 167         fi
 168         if [ "${ORIG_LD}" != '' ]
 169         then
 170                 export LD="${ORIG_LD}"
 171                 unset ORIG_LD
 172         fi
 173         if [ "${ORIG_AS}" != '' ]
 174         then
 175                 export AS="${ORIG_AS}"
 176                 unset ORIG_AS
 177         fi
 178         if [ "${ORIG_CROSS_COMPILE}" != '' ]
 179         then
 180                 export CROSS_COMPILE="${ORIG_CROSS_COMPILE}"
 181                 unset ORIG_CROSS_COMPILE
 182         fi
 183 }
 184
 185
 186 compile_generic() {
 187         local RET
 188         [ "$#" -lt '2' ] &&
 189                 gen_die 'compile_generic(): improper usage!'
 190         local target=${1}
 191         local argstype=${2}
 192
 193         if [ "${argstype}" = 'kernel' ] || [ "${argstype}" = 'runtask' ]
 194         then
 195                 export_kernel_args
 196                 MAKE=${KERNEL_MAKE}
 197         elif [ "${2}" = 'utils' ]
 198         then
 199                 export_utils_args
 200                 MAKE=${UTILS_MAKE}
 201         fi
 202         case "${argstype}" in
 203                 kernel) ARGS="`compile_kernel_args`" ;;
 204                 utils) ARGS="`compile_utils_args`" ;;
 205                 *) ARGS="" ;; # includes runtask
 206         esac
 207         shift 2
 208
 209         # the eval usage is needed in the next set of code
 210         # as ARGS can contain spaces and quotes, eg:
 211         # ARGS='CC="ccache gcc"'
 212         if [ "${argstype}" == 'runtask' ]
 213         then
 214                 print_info 2 "COMMAND: ${MAKE} ${MAKEOPTS/-j?/j1} ${ARGS} ${target} $*" 1 0 1
 215                 eval ${MAKE} -s ${MAKEOPTS/-j?/-j1} "${ARGS}" ${target} $*
 216                 RET=$?
 217         elif [ "${LOGLEVEL}" -gt "1" ]
 218         then
 219                 # Output to stdout and logfile
 220                 print_info 2 "COMMAND: ${MAKE} ${MAKEOPTS} ${ARGS} ${target} $*" 1 0 1
 221                 eval ${MAKE} ${MAKEOPTS} ${ARGS} ${target} $* 2>&1 | tee -a ${LOGFILE}
 222                 RET=${PIPESTATUS[0]}
 223         else
 224                 # Output to logfile only
 225                 print_info 2 "COMMAND: ${MAKE} ${MAKEOPTS} ${ARGS} ${1} $*" 1 0 1
 226                 eval ${MAKE} ${MAKEOPTS} ${ARGS} ${target} $* >> ${LOGFILE} 2>&1
 227                 RET=$?
 228         fi
 229         [ "${RET}" -ne '0' ] &&
 230                 gen_die "Failed to compile the \"${target}\" target..."
 231
 232         unset MAKE
 233         unset ARGS
 234         if [ "${argstype}" = 'kernel' ]
 235         then
 236                 unset_kernel_args
 237         elif [ "${argstype}" = 'utils' ]
 238         then
 239                 unset_utils_args
 240         fi
 241 }
 242
 243 extract_dietlibc_bincache() {
 244         cd "${TEMP}"
 245         rm -rf "${TEMP}/diet" > /dev/null
 246         /bin/tar -jxpf "${DIETLIBC_BINCACHE}" ||
 247                 gen_die 'Could not extract dietlibc bincache!'
 248         [ ! -d "${TEMP}/diet" ] &&
 249                 gen_die "${TEMP}/diet directory not found!"
 250         cd - > /dev/null
 251 }
 252
 253 clean_dietlibc_bincache() {
 254         cd "${TEMP}"
 255         rm -rf "${TEMP}/diet" > /dev/null
 256         cd - > /dev/null
 257 }
 258
 259 compile_dep() {
 260         # Only run ``make dep'' for 2.4 kernels
 261         if [ "${VER}" -eq '2' -a "${KERN_24}" -eq '1' ]
 262         then
 263                 print_info 1 "kernel: >> Making dependencies..."
 264                 cd ${KERNEL_DIR}
 265                 compile_generic dep kernel
 266         fi
 267 }
 268
 269 compile_modules() {
 270         print_info 1 "        >> Compiling ${KV} modules..."
 271         cd ${KERNEL_DIR}
 272         compile_generic modules kernel
 273         export UNAME_MACHINE="${ARCH}"
 274         # On 2.4 kernels, if MAKEOPTS > -j1 it can cause failures
 275         if [ "${VER}" -eq '2' -a "${KERN_24}" -eq '1' ]
 276         then
 277                 MAKEOPTS_SAVE="${MAKEOPTS}"
 278                 MAKEOPTS="${MAKEOPTS_SAVE/-j?/-j1}"
 279         fi
 280         [ "${INSTALL_MOD_PATH}" != '' ] && export INSTALL_MOD_PATH
 281         compile_generic "modules_install" kernel
 282         [ "${VER}" -eq '2' -a "${KERN_24}" -eq '1' ] && MAKEOPTS="${MAKEOPTS_SAVE}"
 283         export MAKEOPTS
 284         unset UNAME_MACHINE
 285 }
 286
 287 compile_kernel() {
 288         [ "${KERNEL_MAKE}" = '' ] &&
 289                 gen_die "KERNEL_MAKE undefined - I don't know how to compile a kernel for this arch!"
 290         cd ${KERNEL_DIR}
 291         print_info 1 "        >> Compiling ${KV} ${KERNEL_MAKE_DIRECTIVE/_install/ [ install ]/}..."
 292         compile_generic "${KERNEL_MAKE_DIRECTIVE}" kernel
 293         if [ "${KERNEL_MAKE_DIRECTIVE_2}" != '' ]
 294         then
 295                 print_info 1 "        >> Starting supplimental compile of ${KV}: ${KERNEL_MAKE_DIRECTIVE_2}..."
 296                 compile_generic "${KERNEL_MAKE_DIRECTIVE_2}" kernel
 297         fi
 298         if ! isTrue "${CMD_NOINSTALL}"
 299         then
 300                 copy_image_with_preserve "kernel" \
 301                         "${KERNEL_BINARY}" \
 302                         "kernel-${KNAME}-${ARCH}-${KV}"
 303
 304                 copy_image_with_preserve "System.map" \
 305                         "System.map" \
 306                         "System.map-${KNAME}-${ARCH}-${KV}"
 307
 308                 if [ "${ENABLE_PEGASOS_HACKS}" = 'yes' ]
 309                 then
 310                         copy_image_with_preserve "kernelz" \
 311                                 "${KERNEL_BINARY_2}" \
 312                                 "kernelz-${KV}"
 313                 fi
 314         else
 315                 cp "${KERNEL_BINARY}" "${TMPDIR}/kernel-${KNAME}-${ARCH}-${KV}" ||
 316                         gen_die "Could not copy the kernel binary to ${TMPDIR}!"
 317                 cp "System.map" "${TMPDIR}/System.map-${KNAME}-${ARCH}-${KV}" ||
 318                         gen_die "Could not copy System.map to ${TMPDIR}!"
 319                 if [ "${ENABLE_PEGASOS_HACKS}" = 'yes' ]
 320                 then
 321                         cp "${KERNEL_BINARY_2}" "${TMPDIR}/kernelz-${KV}" ||
 322                                 gen_die "Could not copy the kernelz binary to ${TMPDIR}!"
 323                 fi
 324         fi
 325 }
 326
 327 compile_busybox() {
 328         [ -f "${BUSYBOX_SRCTAR}" ] ||
 329                 gen_die "Could not find busybox source tarball: ${BUSYBOX_SRCTAR}!"
 330         [ -f "${BUSYBOX_CONFIG}" ] ||
 331                 gen_die "Cound not find busybox config file: ${BUSYBOX_CONFIG}!"
 332         cd "${TEMP}"
 333         rm -rf "${BUSYBOX_DIR}" > /dev/null
 334         /bin/tar -jxpf ${BUSYBOX_SRCTAR} ||
 335                 gen_die 'Could not extract busybox source tarball!'
 336         [ -d "${BUSYBOX_DIR}" ] ||
 337                 gen_die 'Busybox directory ${BUSYBOX_DIR} is invalid!'
 338         cp "${BUSYBOX_CONFIG}" "${BUSYBOX_DIR}/.config"
 339         sed -i ${BUSYBOX_DIR}/.config -e 's/#\? \?CONFIG_FEATURE_INSTALLER[ =].*/CONFIG_FEATURE_INSTALLER=y/g'
 340         cd "${BUSYBOX_DIR}"
 341         patch -p1 < "${GK_SHARE}/pkg/busybox-1.1.3+gentoo-mdadm.patch"
 342         patch -p1 < "${GK_SHARE}/pkg/busybox-1.1.3+gentoo-mdadm2.patch"
 343         print_info 1 'busybox: >> Configuring...'
 344         yes '' 2>/dev/null | compile_generic oldconfig utils
 345
 346         # Delete cache if stored config's MD5 does not match one to be used
 347         if [ -f "${BUSYBOX_BINCACHE}" -a -f "${BUSYBOX_CONFIG}" ]
 348         then
 349                 oldconfig_md5=$(tar -xjf "${BUSYBOX_BINCACHE}" -O .config | md5sum)
 350                 newconfig_md5=$(md5sum < .config)
 351                 if [ "${oldconfig_md5}" != "${newconfig_md5}" ]
 352                 then
 353                         print_info 1 "busybox: >> Removing stale cache..."
 354                         rm -rf "${BUSYBOX_BINCACHE}"
 355                 else
 356                         print_info 1 "busybox: >> Using cache"
 357                 fi
 358         fi
 359
 360         if [ ! -f "${BUSYBOX_BINCACHE}" ]
 361         then
 362                 print_info 1 'busybox: >> Compiling...'
 363                 compile_generic all utils
 364                 print_info 1 'busybox: >> Copying to cache...'
 365                 [ -f "${TEMP}/${BUSYBOX_DIR}/busybox" ] ||
 366                         gen_die 'Busybox executable does not exist!'
 367                 strip "${TEMP}/${BUSYBOX_DIR}/busybox" ||
 368                         gen_die 'Could not strip busybox binary!'
 369                 tar -cj -C "${TEMP}/${BUSYBOX_DIR}" -f "${BUSYBOX_BINCACHE}" busybox .config ||
 370                         gen_die 'Could not create the busybox bincache!'
 371         fi
 372
 373         cd "${TEMP}"
 374         rm -rf "${BUSYBOX_DIR}" > /dev/null
 375 }
 376
 377 compile_lvm() {
 378         compile_device_mapper
 379         if [ ! -f "${LVM_BINCACHE}" ]
 380         then
 381                 [ -f "${LVM_SRCTAR}" ] ||
 382                         gen_die "Could not find LVM source tarball: ${LVM_SRCTAR}! Please place it there, or place another version, changing /etc/genkernel.conf as necessary!"
 383                 cd "${TEMP}"
 384                 rm -rf ${LVM_DIR} > /dev/null
 385                 /bin/tar -zxpf ${LVM_SRCTAR} ||
 386                         gen_die 'Could not extract LVM source tarball!'
 387                 [ -d "${LVM_DIR}" ] ||
 388                         gen_die 'LVM directory ${LVM_DIR} is invalid!'
 389                 rm -rf "${TEMP}/device-mapper" > /dev/null
 390                 /bin/tar -jxpf "${DEVICE_MAPPER_BINCACHE}" -C "${TEMP}" ||
 391                         gen_die "Could not extract device-mapper binary cache!";
 392
 393                 cd "${LVM_DIR}"
 394                 print_info 1 'lvm: >> Configuring...'
 395                         LDFLAGS="-L${TEMP}/device-mapper/lib" \
 396                         CFLAGS="-I${TEMP}/device-mapper/include" \
 397                         CPPFLAGS="-I${TEMP}/device-mapper/include" \
 398                         ./configure --enable-static_link --prefix=${TEMP}/lvm >> ${LOGFILE} 2>&1 ||
 399                                 gen_die 'Configure of lvm failed!'
 400                 print_info 1 'lvm: >> Compiling...'
 401                         compile_generic '' utils
 402                         compile_generic 'install' utils
 403
 404                 cd "${TEMP}/lvm"
 405                 print_info 1 '      >> Copying to bincache...'
 406                 strip "sbin/lvm.static" ||
 407                         gen_die 'Could not strip lvm.static!'
 408                 /bin/tar -cjf "${LVM_BINCACHE}" sbin/lvm.static ||
 409                         gen_die 'Could not create binary cache'
 410
 411                 cd "${TEMP}"
 412                 rm -rf "${TEMP}/device-mapper" > /dev/null
 413                 rm -rf "${LVM_DIR}" lvm
 414         fi
 415 }
 416
 417 compile_dmraid() {
 418         compile_device_mapper
 419         if [ ! -f "${DMRAID_BINCACHE}" ]
 420         then
 421                 [ -f "${DMRAID_SRCTAR}" ] ||
 422                         gen_die "Could not find DMRAID source tarball: ${DMRAID_SRCTAR}! Please place it there, or place another version, changing /etc/genkernel.conf as necessary!"
 423                 cd "${TEMP}"
 424                 rm -rf ${DMRAID_DIR} > /dev/null
 425                 /bin/tar -jxpf ${DMRAID_SRCTAR} ||
 426                         gen_die 'Could not extract DMRAID source tarball!'
 427                 [ -d "${DMRAID_DIR}" ] ||
 428                         gen_die 'DMRAID directory ${DMRAID_DIR} is invalid!'
 429                 rm -rf "${TEMP}/device-mapper" > /dev/null
 430                 /bin/tar -jxpf "${DEVICE_MAPPER_BINCACHE}" -C "${TEMP}" ||
 431                         gen_die "Could not extract device-mapper binary cache!";
 432
 433                 cd "${DMRAID_DIR}"
 434                 print_info 1 'dmraid: >> Configuring...'
 435
 436                 LDFLAGS="-L${TEMP}/device-mapper/lib" \
 437                 CFLAGS="-I${TEMP}/device-mapper/include" \
 438                 CPPFLAGS="-I${TEMP}/device-mapper/include" \
 439                 ./configure --enable-static_link --prefix=${TEMP}/dmraid >> ${LOGFILE} 2>&1 ||
 440                         gen_die 'Configure of dmraid failed!'
 441
 442                 # We dont necessarily have selinux installed yet... look into
 443                 # selinux global support in the future.
 444                 sed -i tools/Makefile -e "s|DMRAIDLIBS += -lselinux||g"
 445                 ###echo "DMRAIDLIBS += -lselinux -lsepol" >> tools/Makefile
 446                 mkdir -p "${TEMP}/dmraid"
 447                 print_info 1 'dmraid: >> Compiling...'
 448                 # Force dmraid to be built with -j1 for bug #188273
 449                 MAKEOPTS=-j1 compile_generic '' utils
 450                 #compile_generic 'install' utils
 451                 mkdir ${TEMP}/dmraid/sbin
 452                 install -m 0755 -s tools/dmraid "${TEMP}/dmraid/sbin/dmraid"
 453                 print_info 1 '      >> Copying to bincache...'
 454                 cd "${TEMP}/dmraid"
 455                 /bin/tar -cjf "${DMRAID_BINCACHE}" sbin/dmraid ||
 456                         gen_die 'Could not create binary cache'
 457
 458                 cd "${TEMP}"
 459                 rm -rf "${TEMP}/device-mapper" > /dev/null
 460                 rm -rf "${DMRAID_DIR}" dmraid
 461         fi
 462 }
 463
 464 compile_devfsd() {
 465         local ARGS
 466         if [ ! -f "${DEVFSD_BINCACHE}" ]
 467         then
 468                 [ ! -f "${DEVFSD_SRCTAR}" ] &&
 469                         gen_die "Could not find devfsd source tarball: ${DEVFSD_SRCTAR}"
 470                 cd "${TEMP}"
 471                 rm -rf "${DEVFSD_DIR}"
 472                 /bin/tar -jxpf "${DEVFSD_SRCTAR}"
 473                 [ ! -d "${DEVFSD_DIR}" ] &&
 474                         gen_die "Devfsd directory ${DEVFSD_DIR} invalid"
 475                 cd "${DEVFSD_DIR}"
 476
 477                 print_info 1 'devfsd: >> Compiling...'
 478                 compile_generic 'LDFLAGS=-static' utils
 479
 480                 print_info 1 '        >> Copying to cache...'
 481                 [ -f "${TEMP}/${DEVFSD_DIR}/devfsd" ] || gen_die 'The devfsd executable does not exist after the compilation of devfsd!'
 482                 strip "${TEMP}/${DEVFSD_DIR}/devfsd" || gen_die 'Could not strip devfsd!'
 483                 bzip2 "${TEMP}/${DEVFSD_DIR}/devfsd" || gen_die 'Compression of devfsd failed!'
 484                 [ -f "${TEMP}/${DEVFSD_DIR}/devfsd.bz2" ] || gen_die 'Could not find compressed devfsd.bz2 binary!'
 485                 mv "${TEMP}/${DEVFSD_DIR}/devfsd.bz2" "${DEVFSD_BINCACHE}" || gen_die 'Could not move compressed binary to the package cache!'
 486
 487                 cd "${TEMP}"
 488                 rm -rf "${DEVFSD_DIR}" > /dev/null
 489         fi
 490 }
 491
 492 compile_device_mapper() {
 493         if [ ! -f "${DEVICE_MAPPER_BINCACHE}" ]
 494         then
 495                 [ ! -f "${DEVICE_MAPPER_SRCTAR}" ] &&
 496                         gen_die "Could not find device-mapper source tarball: ${DEVICE_MAPPER_SRCTAR}. Please place it there, or place another version, changing /etc/genkernel.conf as necessary!"
 497                 cd "${TEMP}"
 498                 rm -rf "${DEVICE_MAPPER_DIR}"
 499                 /bin/tar -zxpf "${DEVICE_MAPPER_SRCTAR}"
 500                 [ ! -d "${DEVICE_MAPPER_DIR}" ] &&
 501                         gen_die "device-mapper directory ${DEVICE_MAPPER_DIR} invalid"
 502                 cd "${DEVICE_MAPPER_DIR}"
 503                 ./configure --prefix=${TEMP}/device-mapper --enable-static_link \
 504                         --disable-selinux >> ${LOGFILE} 2>&1 ||
 505                         gen_die 'Configuring device-mapper failed!'
 506                 print_info 1 'device-mapper: >> Compiling...'
 507                 compile_generic '' utils
 508                 compile_generic 'install' utils
 509                 print_info 1 '        >> Copying to cache...'
 510                 cd "${TEMP}"
 511                 rm -rf "${TEMP}/device-mapper/man" ||
 512                         gen_die 'Could not remove manual pages!'
 513                 strip "${TEMP}/device-mapper/sbin/dmsetup" ||
 514                         gen_die 'Could not strip dmsetup binary!'
 515                 /bin/tar -jcpf "${DEVICE_MAPPER_BINCACHE}" device-mapper ||
 516                         gen_die 'Could not tar up the device-mapper binary!'
 517                 [ -f "${DEVICE_MAPPER_BINCACHE}" ] ||
 518                         gen_die 'device-mapper cache not created!'
 519                 cd "${TEMP}"
 520                 rm -rf "${DEVICE_MAPPER_DIR}" > /dev/null
 521                 rm -rf "${TEMP}/device-mapper" > /dev/null
 522         fi
 523 }
 524
 525 compile_e2fsprogs() {
 526         if [ ! -f "${BLKID_BINCACHE}" ]
 527         then
 528                 [ ! -f "${E2FSPROGS_SRCTAR}" ] &&
 529                         gen_die "Could not find e2fsprogs source tarball: ${E2FSPROGS_SRCTAR}. Please place it there, or place another version, changing /etc/genkernel.conf as necessary!"
 530                 cd "${TEMP}"
 531                 rm -rf "${E2FSPROGS_DIR}"
 532                 tar -zxpf "${E2FSPROGS_SRCTAR}"
 533                 [ ! -d "${E2FSPROGS_DIR}" ] &&
 534                         gen_die "e2fsprogs directory ${E2FSPROGS_DIR} invalid"
 535                 cd "${E2FSPROGS_DIR}"
 536                 print_info 1 'e2fsprogs: >> Configuring...'
 537                 ./configure  --with-ldopts=-static >> ${LOGFILE} 2>&1 ||
 538                         gen_die 'Configuring e2fsprogs failed!'
 539                 print_info 1 'e2fsprogs: >> Compiling...'
 540                 MAKE=${UTILS_MAKE} compile_generic "" ""
 541                 print_info 1 'blkid: >> Copying to cache...'
 542                 [ -f "${TEMP}/${E2FSPROGS_DIR}/misc/blkid" ] ||
 543                         gen_die 'Blkid executable does not exist!'
 544                 strip "${TEMP}/${E2FSPROGS_DIR}/misc/blkid" ||
 545                         gen_die 'Could not strip blkid binary!'
 546                 bzip2 "${TEMP}/${E2FSPROGS_DIR}/misc/blkid" ||
 547                         gen_die 'bzip2 compression of blkid failed!'
 548                 mv "${TEMP}/${E2FSPROGS_DIR}/misc/blkid.bz2" "${BLKID_BINCACHE}" ||
 549                         gen_die 'Could not copy the blkid binary to the package directory, does the directory exist?'
 550
 551                 cd "${TEMP}"
 552                 rm -rf "${E2FSPROGS_DIR}" > /dev/null
 553         fi
 554 }