geninitrd

   1 #!/bin/sh
   2
   3 # geninitrd
   4 #
   5 #       by PLD Linux Team
   6 #
   7 # based on mkinitrd from RedHat Linux
   8 #
   9
  10 GENINITRD_RCSID='$Revision$ $Date::                            $'
  11 R=${GENINITRD_RCSID#* *}; VERSION=${R%% *}
  12 PROGRAM=${0##*/}
  13
  14 . /etc/rc.d/init.d/functions
  15 . /lib/geninitrd/functions
  16 . /etc/sysconfig/system
  17
  18 # list of geninitrd modules which need setup routine after commandline args parsing
  19 GENINITRD_MODS=""
  20 COMPRESS=yes
  21 STRIP=/usr/bin/strip
  22 target=""
  23 kernel=""
  24 force=""
  25 verbose=""
  26 MODULES=""
  27 img_vers=""
  28 fstab=/etc/fstab
  29 modext=.o
  30 rootdev_nr=0
  31 # device node for rootfs from fstab
  32 rootdev=""
  33
  34 # internal variables
  35 # is /dev on tmpfs
  36 dev_mounted=no
  37 # is /proc mounted
  38 proc_mounted=no
  39 # is /sys mounted
  40 sys_mounted=no
  41 # is /tmp mounted on tmpfs
  42 tmp_mounted=no
  43
  44 # are /dev nodes already created from /proc/devices info?
  45 proc_partitions=no
  46
  47 usage() {
  48         echo "Usage: $PROGRAM [--version] [-v] [-f] [--ifneeded] [--preload <module>]"
  49         echo "       [--with=<module>] [--image-version] [--fstab=<fstab>] [--nocompress]"
  50         echo "       [--compress=yes|xz|lzma|bzip2|gzip|lzo]"
  51         echo "       [--nostrip ] [--strip PATH/strip] [--strip=PATH/strip]"
  52         echo "       [--initrdfs=rom|initramfs|ext2|cram] [--modules-conf=<modules.conf>]"
  53         echo "       [--with-bootsplash] [--without-bootsplash]"
  54         echo "       [--with-fbsplash] [--without-fbsplash]"
  55         echo "       [--with-fbcondecor] [--without-fbcondecor]"
  56         echo "       [--lvmtoolsversion=1|2] [--with-udev] [--without-udev]"
  57         echo "       [--with-suspend] [--without-suspend]"
  58         echo "       [--with-tuxonice] [--without-tuxonice]"
  59         echo "       [--without-dmraid]"
  60         echo "       [--with-multipath=DEVPATH] [--without-multipath]"
  61         echo "       [--without-blkid] [--without-luks]"
  62         echo "       <initrd-image> <kernel-version>"
  63         echo ""
  64         echo "Example:"
  65
  66         local kdir kver dir=${target:-/boot}
  67         for kdir in /lib/modules/*; do
  68                 [ -d $kdir ] || continue
  69                 kver=${kdir##*/}
  70                 echo "  $0 -f --initrdfs=initramfs $dir/initrd-$kver.gz $kver $verbose"
  71         done | sort -V
  72 }
  73
  74 msg() {
  75         echo "$PROGRAM: $*"
  76 }
  77
  78 warn() {
  79         msg "WARNING: $*" >&2
  80 }
  81
  82 debug() {
  83         [ -n "$verbose" ] && msg "$*" >&2
  84 }
  85
  86 # aborts program abnormally
  87 die() {
  88         local rc=${2:-1}
  89         msg "ERROR: $1" >&2
  90         exit $rc
  91 }
  92
  93 # find program from specified paths
  94 find_tool() {
  95         local x
  96         for x in "$@"; do
  97                 if [ -x "$x" ]; then
  98                         echo $x
  99                         debug "find_tool: found $x"
 100                         return 0
 101                 fi
 102         done
 103         debug "find_tool: did not find any of: $@"
 104         return 1
 105 }
 106
 107 # loads geninitrd modules
 108 geninitrd_load_mods() {
 109         local mod
 110         for mod in "$@"; do
 111                 if [ ! -f /lib/geninitrd/mod-$mod.sh ]; then
 112                         die "$mod geninitrd module can't be loaded"
 113                 fi
 114                 . /lib/geninitrd/mod-$mod.sh
 115
 116                 GENINITRD_MODS="$GENINITRD_MODS $mod"
 117         done
 118 }
 119
 120 # setup geninitrd modules
 121 geninitrd_setup_mods() {
 122         local mod rcsid
 123
 124         for mod in $GENINITRD_MODS; do
 125                 eval rcsid=$(echo \$$mod | LC_ALL=C tr '[a-z]' '[A-Z]')_RCSID
 126                 debug "# $rcsid (mod-$mod)"
 127
 128                 # some mods want init
 129                 if type setup_mod_$mod > /dev/null; then
 130                         eval setup_mod_$mod
 131                 fi
 132         done
 133 }
 134
 135 # append text to /linuxrc
 136 # takes STDIN as input
 137 add_linuxrc() {
 138         cat >> "$RCFILE"
 139 }
 140
 141 # generate code to mount /dev on tmpfs and create initial nodes
 142 # can be called multiple times. /dev is cleaned up (umounted) automatically at
 143 # the end of script.
 144 mount_dev() {
 145         # we already generated tmpfs code; return
 146         if is_yes "$dev_mounted"; then
 147                 return
 148         fi
 149
 150         dev_mounted=yes
 151
 152         busybox_applet mount mknod mkdir
 153         add_linuxrc <<-EOF
 154                 : 'Creating /dev'
 155                 if ! mount -t devtmpfs -o mode=0755,nosuid devtmpfs /dev > /dev/null 2>&1; then
 156                         mount -o mode=0755,nosuid -t tmpfs tmpfs /dev
 157                         mknod /dev/console c 5 1
 158                         mknod /dev/null c 1 3
 159                         mknod /dev/zero c 1 5
 160                         mknod /dev/random c 1 8
 161                         mknod /dev/snapshot c 10 231
 162                         mknod /dev/urandom c 1 9
 163                         mknod /dev/ptmx c 5 2
 164                         mknod /dev/kmsg c 1 11
 165                 fi
 166                 mkdir /dev/pts
 167                 mkdir /dev/shm
 168         EOF
 169 }
 170
 171 # generate code to mount /proc on initrd
 172 # can be called multiple times
 173 mount_proc() {
 174         if is_yes "$proc_mounted"; then
 175                 return
 176         fi
 177
 178         proc_mounted=yes
 179     if [ "$INITRDFS" = "initramfs" ]; then
 180                 # /proc is mounted with initramfs 2.6.22.14 kernel
 181                 # XXX: remove when it is clear why proc was already mounted
 182                 echo "[ -f /proc/cmdline ] || mount -t proc none /proc" | add_linuxrc
 183         else
 184                 echo "mount -t proc none /proc" | add_linuxrc
 185         fi
 186 }
 187
 188 # generate code to mount /sys on initrd
 189 # can be called multiple times
 190 mount_sys() {
 191         if is_yes "$sys_mounted"; then
 192                 return
 193         fi
 194
 195         sys_mounted=yes
 196         echo "mount -t sysfs none /sys" | add_linuxrc
 197 }
 198
 199 # generate code to mount /tmp on initrd
 200 # can be called multiple times
 201 mount_tmp() {
 202     if [ "$INITRDFS" = "initramfs" ]; then
 203                 # initramfs is read-write filesystem, no need for tmpfs
 204                 return
 205         fi
 206
 207         if is_yes "$tmp_mounted"; then
 208                 return
 209         fi
 210
 211         tmp_mounted=yes
 212         echo "mount -t tmpfs none /tmp" | add_linuxrc
 213 }
 214
 215 # generate code to mount /run on initrd
 216 # can be called multiple times
 217 mount_run() {
 218         if is_yes "$run_mounted"; then
 219                 return
 220         fi
 221
 222         run_mounted=yes
 223         echo "mount -t tmpfs run /run" | add_linuxrc
 224 }
 225
 226 # unmount all mountpoints mounted by geninitrd
 227 umount_all() {
 228
 229         add_linuxrc <<-'EOF'
 230         : Last shell before umounting all and giving control over to real init.
 231         debugshell
 232         EOF
 233
 234         if is_yes "$run_mounted"; then
 235                 echo 'mount --bind /run /newroot/run' | add_linuxrc
 236                 echo 'umount /run' | add_linuxrc
 237                 run_mounted=no
 238         fi
 239         if is_yes "$dev_mounted"; then
 240                 echo 'umount /dev' | add_linuxrc
 241                 dev_mounted=no
 242         fi
 243         if is_yes "$sys_mounted"; then
 244                 echo 'umount /sys' | add_linuxrc
 245                 sys_mounted=no
 246         fi
 247         if is_yes "$tmp_mounted"; then
 248                 echo 'umount /tmp' | add_linuxrc
 249                 tmp_mounted=no
 250         fi
 251         if is_yes "$proc_mounted"; then
 252                 echo 'umount /proc' | add_linuxrc
 253                 proc_mounted=no
 254         fi
 255 }
 256
 257
 258 # Checks if busybox has support for APPLET(s)
 259 # Exits from geninitrd if the support is not present.
 260 #
 261 # NB! XXX do not output to STDOUT, it will appear in initrd images in some cases!
 262 busybox_applet() {
 263         local err=0 applet
 264
 265         if [ -z "$busybox_functions" ]; then
 266                 local tmp=$($busybox 2>&1)
 267
 268                 # BusyBox v1.1.3 says applet not found if it's not called 'busybox'.
 269                 if [[ "$tmp" = *applet\ not\ found* ]]; then
 270                         local t=$(mktemp -d)
 271                         ln -s $busybox $t/busybox
 272                         local tmp=$($t/busybox 2>&1)
 273                         rm -rf $t
 274                 fi
 275
 276                 busybox_functions=$(echo "$tmp" | \
 277                         sed -ne '/Currently defined functions:/,$p' | \
 278                         xargs | sed -e 's,.*Currently defined functions: ,,'
 279                 )
 280         fi
 281         for applet in $*; do
 282                 local have
 283                 # try cache
 284                 eval have='$'busybox_have_$applet
 285                 if [ -z "$have" ]; then
 286                         have=$(echo "$busybox_functions" | egrep -c "( |^)$applet(,|$)")
 287                         if [ "$have" = 0 ]; then
 288                                 warn "This setup requires busybox-initrd compiled with applet '$applet' support"
 289                                 err=1
 290                         fi
 291                         eval busybox_have_$applet=$have
 292                 fi
 293         done
 294         if [ $err = 1 ]; then
 295                 die "Aborted"
 296         fi
 297 }
 298
 299 # Extract the .config file from a kernel image
 300 # uses extract-ikconfig from kernel sources (scripts/extract-ikconfig)
 301 ikconfig() {
 302         local kofile=$(modinfo -k $kernel -n configs 2> /dev/null)
 303         if [ -n "$kofile" ]; then
 304                 /lib/geninitrd/extract-ikconfig $kofile
 305                 return
 306         fi
 307
 308         # see if config available as separate file
 309         if [ -f /boot/config-$kernel ]; then
 310            cat /boot/config-$kernel
 311            return
 312         fi
 313
 314         # finally try vmlinuz itself
 315         /lib/geninitrd/extract-ikconfig /boot/vmlinuz-$kernel
 316 }
 317
 318 # Finds module dependencies
 319 #
 320 # @param        $module
 321 #
 322 # Outputs full path to module and it's dependencies
 323 find_depmod() {
 324         local module="$1"
 325         local skiperrors=0
 326
 327         # if module is prefixed with dash, we should ignore errors if the module
 328         # can't be found.
 329         if [ ${module#-} != $module ]; then
 330                 skiperrors=1
 331                 module=${module#-}
 332         fi
 333
 334         # This works when user has module-init-tools installed even on 2.4 kernels
 335         local modprobe
 336         modprobe=$(modprobe --set-version $kernel --show-depends $module --ignore-install 2>&1)
 337
 338         if [ $? != 0 ]; then
 339                 if [ $skiperrors = 1 ]; then
 340                         return 0
 341                 fi
 342                 echo >&2 "$modprobe"
 343
 344                 if ! is_no "$EXIT_IF_MISSING"; then
 345                         die "$module: module not found for $kernel kernel"
 346                 fi
 347
 348                 warn "$module: module not found for $kernel kernel"
 349                 warn "If $module isn't compiled in kernel then this initrd may not start your system."
 350         fi
 351
 352         echo "$modprobe" | \
 353         while read insmod modpath options; do
 354                 [ "$insmod" = "insmod" ] && echo $modpath
 355         done
 356         return 0
 357 }
 358
 359 find_firmware() {
 360         local module="$1"
 361
 362         # no firmware support in 2.4 kernels
 363         if [ "$kernel_version_long" -lt "002005048" ]; then
 364                 return
 365         fi
 366         echo -n $(NEW_MODINFO=1 modinfo -k $kernel -F firmware $module 2>/dev/null | xargs)
 367 }
 368
 369 # @param        $module
 370 find_module() {
 371         local mod depmod module=$1
 372
 373         depmod=$(find_depmod $module) || exit 1
 374         for mod in $depmod; do
 375                 mod=${mod#/lib/modules/$kernel/}
 376
 377                 # add each module only once
 378                 local m have=0
 379                 for m in $MODULES; do
 380                         [ $m = $mod ] && have=1
 381                 done
 382                 if [ $have = 0 ]; then
 383                         MODULES="$MODULES $mod"
 384                 fi
 385         done
 386 }
 387
 388 # install a file to temporary mount image.
 389 # it will operate recursively (copying directories)
 390 # and will symlink destinations if source is symlink.
 391 inst() {
 392         if [ $# -lt 2 ]; then
 393                 die 'Usage: inst <file> [<file>] <destination>'
 394         fi
 395
 396         local src i=0 c=$(($# - 1))
 397         while [ $i -lt $c ]; do
 398                 src="$src $1"
 399                 i=$((i + 1))
 400                 shift
 401         done
 402         local dest=$1
 403         set -- $src
 404         local parentDir=$(dirname $DESTDIR$dest)
 405         [ ! -d "$parentDir" ] && (debug "+ mkdir -p $parentDir"; mkdir -p $parentDir)
 406         debug "+ cp $* $DESTDIR$dest"
 407         cp -HR "$@" "$DESTDIR$dest"
 408 }
 409
 410 inst_d() {
 411         if [ $# = 0 ]; then
 412                 die 'Usage: inst_d <destination> <destination>'
 413         fi
 414         for dir in "$@"; do
 415                 install -d "$DESTDIR$dir"
 416         done
 417 }
 418
 419 # install executable and it's shared libraries
 420 inst_exec() {
 421         if [ $# -lt 2 ]; then
 422                 die "Invalid params ($@), Usage: inst_exec <file>[, <file>] <destination>"
 423         fi
 424         local src i=0 c=$(($# - 1))
 425         while [ $i -lt $c ]; do
 426                 src="$src $1"
 427                 i=$((i + 1))
 428                 shift
 429         done
 430         local dest=$1
 431         set -- $src
 432
 433         inst "$@" $dest
 434
 435         local obj lib libs
 436         for obj in "$@"; do
 437                 case "$obj" in
 438                         /lib/ld-linux.so.2 | /lib64/ld-linux-x86-64.so.2)
 439                         continue
 440                 esac
 441
 442                 libs=$(ldd "$obj" | awk '/statically|linux-(gate|vdso)\.so/{next} NF == 2 {print $1} /=/{print $3}' | sort -u)
 443                 for lib in $libs; do
 444                         if [ ! -f "$DESTDIR/$_lib/${lib##*/}" ]; then
 445                                 inst_d /$_lib
 446                                 inst_exec $lib /$_lib
 447                         fi
 448                 done
 449         done
 450
 451         # hack for uclibc linked binaries requiring this fixed path
 452         # XXX: shouldn't rpath be used here instead so th
 453         if [ -f $DESTDIR/$_lib/libc.so.0 ]; then
 454                 local lib=$DESTDIR/$_lib/libc.so.0
 455                 lib=$(ldd "$lib" | awk '/statically|linux-(gate|vdso)\.so/{next} NF == 2 {print $1} /=/{print $3}' | sort -u)
 456                 local libdir=$(cd $(dirname "$lib"); pwd)
 457                 if [ ! -e $DESTDIR$libdir ]; then
 458                         libdir=$(dirname "$libdir")
 459                         inst_d $libdir
 460                         debug "+ ln -s /$_lib $DESTDIR$libdir"
 461                         ln -s /$_lib $DESTDIR$libdir
 462                 fi
 463         fi
 464 }
 465
 466 # output modules.conf / modprobe.conf
 467 modprobe_conf() {
 468         echo "$modprobe_conf_cache"
 469 }
 470
 471 # return options for MODULE
 472 # @param $1 module name
 473 modprobe_options() {
 474         local module=$1
 475         local options=$(modprobe_conf | awk -vmodule="$module" '{ if ($1 == "options" && $2 == module) { for(i=3;i<=NF;i++) printf("%s ",$i); }}')
 476         echo ${options# }
 477 }
 478
 479 #
 480 # defaults to modprobe -c if not told otherwise, this means include statements
 481 # work from there.
 482 cache_modprobe_conf() {
 483         if [ "$kernel_version" -lt "002005" ]; then
 484                 modulefile=/etc/modules.conf
 485                 if [ ! -f "$modulefile" -a -f /etc/conf.modules ]; then
 486                         modulefile=/etc/conf.modules
 487                 fi
 488         fi
 489
 490         if [ -n "$modulefile" ]; then
 491                 debug "Using $modulefile for modules config"
 492                 modprobe_conf_cache=$(cat $modulefile | awk '!/^[\t ]*#/ { print }')
 493
 494         else
 495                 debug "Using modprobe -c to get modules config"
 496                 modprobe_conf_cache=$(modprobe -c --set-version $kernel | awk '!/^[\t ]*#/ { print }')
 497         fi
 498 }
 499
 500 # find modules for $devpath
 501 find_modules_for_devpath() {
 502         local devpath="$1"
 503         if [ -z "$devpath" ]; then
 504                 die "No argument passed to find_modules_for_devpath() - is your /etc/fstab correct?"
 505         fi
 506
 507         if [[ "$devpath" = /dev/dm-* ]]; then
 508                 # /dev/dm-3 -> /dev/mapper/sil_ahbgadcbchfc3
 509                 devpath=$(dm_node "$devpath")
 510         fi
 511
 512         if [ -L "$devpath" ] && ! is_lvm "$devpath" && ! is_luks "$devpath"; then
 513                 # sanitize things like:
 514                 # /dev/block/104:2 -> /dev/cciss/c0d0p2
 515                 devpath=$(readlink -f "$devpath")
 516         fi
 517
 518         debug "Finding modules for device path $devpath"
 519
 520         if is_luks "$devpath"; then
 521                 find_modules_luks "$devpath"
 522                 return
 523         fi
 524
 525         if is_nfs "$devpath"; then
 526                 find_modules_nfs "$devpath"
 527                 return
 528         fi
 529
 530         if is_md "$devpath"; then
 531                 find_modules_md "$devpath"
 532                 return
 533         fi
 534
 535         if is_multipath "$devpath"; then
 536                 if find_modules_multipath "$devpath"; then
 537                         return
 538                 fi
 539
 540                 # fallback
 541         fi
 542
 543         if is_dmraid "$devpath"; then
 544                 if find_modules_dmraid "$devpath"; then
 545                         return
 546                 fi
 547                 # fallback
 548         fi
 549
 550         if is_scsi "$devpath"; then
 551                 find_modules_scsi "$devpath"
 552                 return
 553         fi
 554
 555         if is_ide "$devpath"; then
 556                 find_modules_ide "$devpath"
 557                 return
 558         fi
 559
 560         if [[ "$devpath" == /dev/rd/* ]]; then
 561                 find_module "DAC960"
 562                 rootdev_add=/dev/rd/
 563                 return
 564         fi
 565
 566         if [[ "$devpath" == /dev/ida/* ]]; then
 567                 find_module "cpqarray"
 568                 rootdev_add=/dev/ida/
 569                 return
 570         fi
 571
 572         if [[ "$devpath" == /dev/cciss/* ]]; then
 573                 rootdev_add=/dev/cciss/
 574
 575                 # load hpsa for future kernels, cciss for backwards compat
 576                 if [ "$kernel_version_long" -ge "003000000" ]; then
 577                         find_module "hpsa" "-cciss"
 578                         find_modules_scsi "$devpath"
 579                 else
 580                         find_module "cciss"
 581                 fi
 582
 583                 return
 584         fi
 585
 586         if [[ "$devpath" == /dev/ataraid/* ]]; then
 587                 find_modules_ide
 588                 find_module "ataraid"
 589                 ataraidmodules=$(modprobe_conf | awk '/ataraid_hostadapter/ { print $3 }')
 590                 if [ -n "$ataraidmodules" ]; then
 591                         # FIXME: think about modules compiled in kernel
 592                         die "ataraid_hostadapter alias not defined in modprobe.conf! Please set it and run $PROGRAM again."
 593                 fi
 594                 for n in $ataraidmodules; do
 595                         find_module "$n"
 596                 done
 597                 rootdev_add=/dev/ataraid/
 598                 return
 599         fi
 600
 601         # check to see if we need to set up a loopback filesystem
 602         if [[ "$devpath" == /dev/loop*  ]]; then
 603                 die "Sorry, root on loop device isn't supported."
 604                 # TODO: rewrite for bsp and make nfs ready
 605                 if [ ! -x /sbin/losetup ]; then
 606                         die "losetup is missing"
 607                 fi
 608                 key="^# $(echo $devpath | awk -F/ '{print($3);}' | tr '[a-z]' '[A-Z]'):"
 609                 if ! is_yes "`awk '/'$key'/ { print( "yes"); }' $fstab`"; then
 610                         die "The root filesystem is on a $devpath, but there is no magic entry in $fstab for this device. Consult the $PROGRAM man page for more information"
 611                 fi
 612
 613                 line="`awk '/'$key'/ { print $0; }' $fstab`"
 614                 loopDev="$(echo $line | awk '{print $3}')"
 615                 loopFs="$(echo $line | awk '{print $4}')"
 616                 loopFile="$(echo $line | awk '{print $5}')"
 617
 618                 BASICMODULES="$BASICMODULES -loop"
 619                 find_module "-$loopFs"
 620                 BASICMODULES="$BASICMODULES -${loopFs}"
 621                 return
 622         fi
 623
 624         if is_lvm "$devpath"; then
 625                 find_modules_lvm "$devpath"
 626                 return
 627         fi
 628 }
 629
 630 firmware_install_module() {
 631         local module="$1"
 632         local firmware_files="$2"
 633
 634         debug "Adding Firmwares ($firmware_files) to initrd for module $module"
 635         # firmware not yet installed
 636         if [ ! -f "$DESTDIR/lib/firmware/firmware.sh" ]; then
 637                 inst_d /lib/firmware
 638 cat << 'EOF' >> "$DESTDIR/lib/firmware/firmware.sh"
 639 #!/bin/sh -e
 640 echo 1 > /sys$DEVPATH/loading
 641 cat "/lib/firmware/$FIRMWARE" > /sys$DEVPATH/data
 642 echo 0 > /sys$DEVPATH/loading
 643 exit 0
 644 EOF
 645                 chmod 755 "$DESTDIR/lib/firmware/firmware.sh"
 646
 647                 # setup firmware loader agent
 648                 echo "echo -n "/lib/firmware/firmware.sh" > /proc/sys/kernel/hotplug" | add_linuxrc
 649         fi
 650
 651         for firmware in $firmware_files; do
 652                 if [ -f "/lib/firmware/$kernel/$firmware" ]; then
 653                         FIRMWAREDIR=${firmware%/*}
 654                         [ "$FIRMWAREDIR" != "$firmware" ] && inst_d /lib/firmware/$FIRMWAREDIR
 655                         inst /lib/firmware/$kernel/$firmware /lib/firmware/$firmware
 656                 elif [ -f "/lib/firmware/$firmware" ]; then
 657                         FIRMWAREDIR=${firmware%/*}
 658                         [ "$FIRMWAREDIR" != "$firmware" ] && inst_d /lib/firmware/$FIRMWAREDIR
 659                         inst /lib/firmware/$firmware /lib/firmware/$firmware
 660                 else
 661                         warn "Possible missing firmware file /lib/firmware/$firmware or /lib/firmware/$kernel/$firmware for module $module."
 662                 fi
 663         done
 664
 665         mount_sys
 666 }
 667
 668 modules_install() {
 669         local modules="$1"
 670         local mod
 671
 672         for mod in $modules; do
 673                 MODULEDIR=${mod%/*}
 674                 inst_d "/lib/modules/$kernel/$MODULEDIR"
 675                 cp -a "/lib/modules/$kernel/$mod" "$DESTDIR/lib/modules/$kernel/$mod"
 676                 gunzip "$DESTDIR/lib/modules/$kernel/$mod" 2> /dev/null
 677                 if [ "$STRIP" ] && [ -x "$STRIP" ]; then
 678                         $STRIP -g --remove-section=.comment "$DESTDIR/lib/modules/$kernel/${mod%.gz}"
 679                 fi
 680         done
 681 }
 682
 683 modules_add_linuxrc() {
 684         local mod modpath
 685
 686         for mod in "$@"; do
 687                 # module path without optional compression
 688                 modpath=${mod%.gz}
 689
 690                 # name of the module
 691                 local module=${modpath##*/}; module=${module%$modext}
 692                 local options=$(modprobe_options "$module")
 693                 local genericname=$(echo $module | tr - _)
 694                 local usleep=$(eval echo \$MODULE_${genericname}_USLEEP)
 695                 local firmware=$(eval echo \$MODULE_${genericname}_FIRMWARE)
 696
 697                 if [ "$module" = "scsi_mod" -a "$kernel_version_long" -ge "002006030" ]; then
 698                         options="scan=sync $options"
 699                 fi
 700
 701                 if [ -n "$verbose" ]; then
 702                         s=""
 703                         if [ "$options" ]; then
 704                                 s="$s with options [$options]"
 705                         fi
 706                         if [ "$usleep" ]; then
 707                                 s="$s and $usleep usleep"
 708                         fi
 709                         debug "Loading module [$module]$s"
 710                 fi
 711
 712                 if [ -n "$firmware" ]; then
 713                         firmware_install_module "$module" "$firmware"
 714                 else
 715                         for file in $(find_firmware "$module"); do
 716                                 firmware_install_module "$module" "$file"
 717                         done
 718                 fi
 719
 720                 echo "insmod /lib/modules/$kernel/$modpath $options" | add_linuxrc
 721                 if [ -n "$usleep" ]; then
 722                         echo "usleep $usleep" | add_linuxrc
 723                 fi
 724                 if [ "$module" = "scsi_wait_scan" ]; then
 725                         if [ "$(busybox_applet rmmod 2>/dev/null; echo $?)" = 0 ]; then
 726                                 echo "rmmod scsi_wait_scan" | add_linuxrc
 727                         fi
 728                 fi
 729
 730         done
 731 }
 732
 733 # Generates /dev nodes based on /proc/partitions information.
 734 # Needs /proc mounted.
 735 # Can be called multiple times.
 736 initrd_gen_devices() {
 737         if is_yes "$proc_partitions"; then
 738                 return
 739         fi
 740         proc_partitions=yes
 741
 742         mount_dev
 743         add_linuxrc <<-'EOF'
 744                 : 'Making device nodes'
 745                 cat /proc/partitions | (
 746                         # ignore first two lines: header, empty line
 747                         read b; read b
 748
 749                         while read major minor blocks dev rest; do
 750                                 node=/dev/$dev
 751                                 mkdir -p ${node%/*}
 752                                 [ -e $node ] || mknod $node b $major $minor
 753                         done
 754                 )
 755         EOF
 756 }
 757
 758
 759 initrd_gen_setrootdev() {
 760         debug "Adding rootfs finding based on kernel cmdline root= option support."
 761         busybox_applet ls
 762         add_linuxrc <<-'EOF'
 763                 if [ "${ROOT##/dev/}" != "${ROOT}" ]; then
 764                         rootnr="$(busybox awk -v rootnode="${ROOT##/dev/}" '$4 == rootnode { print 256 * $1 + $2 }' /proc/partitions)"
 765                         # fallback to ls
 766                         if [ -z "$rootnr" ]; then
 767                                 rootnr="$(busybox ls -lL ${ROOT} | busybox awk '{if (/^b/) { print 256 * $3 + $4; }}')"
 768                         fi
 769                         if [ -n "$rootnr" ]; then
 770                                 echo "$rootnr" > /proc/sys/kernel/real-root-dev
 771                         fi
 772                 fi
 773         EOF
 774 }
 775
 776 initrd_gen_initramfs_switchroot() {
 777         inst_d /newroot
 778         if [ "$rootdev" = "/dev/nfs" ]; then
 779                 echo "rootfs on NFS root=/dev/nfs"
 780         else
 781                 [ ! -e "$DESTDIR/$rootdev" ] && inst $rootdev $rootdev
 782         fi
 783
 784         # parse 'root=xxx' kernel commandline
 785         # We support passing root as hda3 /dev/hda3 0303 0x0303 and 303
 786         add_linuxrc <<-'EOF'
 787                 device=
 788                 eval "$(busybox awk -v c="$ROOT" '
 789                         BEGIN {
 790                                 num_pattern_short = "[0-9a-f][0-9a-f][0-9a-f]";
 791                                 num_pattern = "[0-9a-f]" num_pattern_short;
 792                                 dev_pattern = "[hms][a-z][a-z]([0-9])+";
 793                                 partition = "";
 794                                 min = -1; maj = -1;
 795
 796                                 sub("^0x", "", c);
 797                                 if (c ~ "^" num_pattern_short "$") sub("^", "0", c);
 798                                 if (c ~ "^" num_pattern  "$") {
 799                                         maj = sprintf("%d",substr(c,1,2));
 800                                         min = sprintf("%d",substr(c,3));
 801                                 }
 802                                 if (c ~ "^\/dev\/" dev_pattern "$") sub("^/dev/","", c);
 803                                 if (c ~ "^" dev_pattern "$") partition = c;
 804                         }
 805
 806                         partition && $4 == partition { maj = $1; min = $2; }
 807                         $1 == maj && $2 == min { partition = $4; }
 808
 809                         END {
 810                                 if (maj >= 0 && min >= 0) {
 811                                         printf("maj=%s; min=%s;\n", maj, min);
 812                                 }
 813                                 if (partition) {
 814                                         printf("device=/dev/%s;\n", partition);
 815                                 }
 816                         }
 817                         ' /proc/partitions)"
 818
 819                 if [ -z "$device" ]; then
 820                         device=$ROOT
 821                 fi
 822
 823                 if [ "$device" -a ! -b $device ]; then
 824                         mknod $device b $maj $min
 825                 fi
 826
 827                 [ -n "$ROOTFSFLAGS" ] && ROOTFSFLAGS="-o $ROOTFSFLAGS"
 828
 829                 mount -t $ROOTFS -r $device $ROOTFSFLAGS /newroot || echo "Mount of rootfs failed."
 830                 init=$INIT
 831                 if [ -z "$init" -o ! -x "/newroot$init" ]; then
 832                         init=/sbin/init
 833                 fi
 834         EOF
 835
 836         umount_all
 837         busybox_applet switch_root
 838         add_linuxrc <<-'EOF'
 839                 [ ! -e /newroot/dev/console ] && mknod -m 660 /newroot/dev/console c 5 1
 840                 exec switch_root /newroot $init ${1:+"$@"}
 841
 842                 echo "Error! initramfs should not reach this place."
 843                 echo "It probably means you've got old version of busybox, with broken"
 844                 echo "initramfs support. Trying to boot anyway, but won't promise anything."
 845
 846                 exec chroot /newroot $init ${1:+"$@"}
 847
 848                 echo "Failed to chroot!"
 849                 debugshell
 850         EOF
 851         # we need /init being real file, not symlink, otherwise the initramfs will
 852         # not be ran by pid 1 which is required for switch_root
 853         mv $DESTDIR/linuxrc $DESTDIR/init
 854         ln -s init $DESTDIR/linuxrc
 855 }
 856
 857 # find if $symbol exists in System.map $mapfile
 858 sym_exists() {
 859         local mapfile="$1"
 860         local symbol="$2"
 861         if [ ! -f $mapfile ]; then
 862                 # missing mapfile (not a pld kernel?)
 863                 return 1
 864         fi
 865
 866         awk -vc=1 -vsymbol="$symbol" '$2 == "T" && $3 == symbol {c = 0} END {exit c}' $mapfile
 867 }
 868
 869 # find best compressor (or forced one) for initrd
 870 find_compressor() {
 871         local mode="$1"
 872         # fastest initrd decompression speed is first
 873         local compressors='lzo gzip xz lzma bzip2'
 874
 875         # a specified one, take it
 876         if ! is_yes "$mode"; then
 877                 compressors="$mode"
 878         fi
 879
 880         debug "finding compressor: $compressors (via $mode)"
 881         # check for compressor validity
 882         local c prog map=/boot/System.map-$kernel
 883         for c in $compressors; do
 884                 case $c in
 885                 xz)
 886                         sym=unxz
 887                         prog=/usr/bin/xz
 888                         ;;
 889                 lzma)
 890                         sym=unlzma
 891                         prog=/usr/bin/xz
 892                         ;;
 893                 bzip2)
 894                         sym=bzip2
 895                         prog=/usr/bin/bzip2
 896                         ;;
 897                 gzip)
 898                         sym=gunzip
 899                         prog=/bin/gzip
 900                         ;;
 901                 lzo)
 902                         sym=unlzo
 903                         prog=/usr/bin/lzop
 904                         ;;
 905                 none|no)
 906                         # any existing sym will work
 907                         sym=initrd_load
 908                         prog=/bin/cat
 909                         ;;
 910                 *)
 911                         die "Unknown compressor $c"
 912                         ;;
 913                 esac
 914                 if sym_exists $map $sym && [ -x $prog ]; then
 915                         echo $c
 916                         return
 917                 fi
 918         done
 919
 920         debug "using gzip for compressor (fallback)"
 921         echo gzip
 922 }
 923
 924 # compresses kernel image image
 925 # in function so we could retry with other compressor on failure
 926 compress_image() {
 927         local compressor="$1" IMAGE="$2" target="$3" tmp
 928         tmp=$(mktemp "$target".XXXXXX) || die "mktemp failed"
 929
 930         case "$compressor" in
 931         xz)
 932                 # don't use -9 here since kernel won't understand it
 933                 xz --format=xz --check=crc32 --lzma2=preset=6e,dict=1MiB < "$IMAGE" > "$tmp" || return $?
 934                 ;;
 935         lzma)
 936                 xz --format=lzma -9 < "$IMAGE" > "$tmp" || return $?
 937                 ;;
 938         bzip2)
 939                 bzip2 -9 < "$IMAGE" > "$tmp" || return $?
 940                 ;;
 941         gzip)
 942                 gzip -9 < "$IMAGE" > "$tmp" || return $?
 943                 ;;
 944         lzo)
 945                 lzop -9 < "$IMAGE" > "$tmp" || return $?
 946                 ;;
 947         none|no)
 948                 cat < "$IMAGE" > "$tmp" || return $?
 949                 ;;
 950         esac
 951
 952         mv -f "$tmp" "$target"
 953 }
 954
 955 if [ -r /etc/sysconfig/geninitrd ]; then
 956         . /etc/sysconfig/geninitrd
 957 fi
 958
 959 if [ ! -f /proc/mounts ]; then
 960         warn "/proc filesystem not mounted, may cause wrong results or failure."
 961 fi
 962
 963 geninitrd_load_mods ide luks multipath dmraid lvm md blkid udev tuxonice suspend fbsplash condecor bootsplash uvesafb nfs sata scsi usbkbd
 964
 965 while [ $# -gt 0 ]; do
 966         case $1 in
 967         --fstab=*)
 968                 fstab=${1#--fstab=}
 969                 ;;
 970         --fstab)
 971                 fstab=$2
 972                 shift
 973                 ;;
 974         --modules-conf=*)
 975                 modulefile=${1#--modules-conf=}
 976                 ;;
 977         --modules-conf)
 978                 modulefile=$2
 979                 shift
 980                 ;;
 981         --with-bootsplash)
 982                 BOOT_SPLASH=yes
 983                 ;;
 984         --without-bootsplash)
 985                 BOOT_SPLASH=no
 986                 ;;
 987         --with-fbsplash)
 988                 FB_SPLASH=yes
 989                 ;;
 990         --without-fbsplash)
 991                 FB_SPLASH=no
 992                 ;;
 993         --with-fbcondecor)
 994                 FB_CON_DECOR=yes
 995                 ;;
 996         --without-fbcondecor)
 997                 FB_CON_DECOR=no
 998                 ;;
 999         --with-suspend)
1000                 USE_SUSPEND=yes
1001                 ;;
1002         --without-suspend)
1003                 USE_SUSPEND=no
1004                 ;;
1005         --with-suspend2 | --with-tuxonice)
1006                 USE_TUXONICE=yes
1007                 ;;
1008         --without-suspend2 | --without-tuxonice)
1009                 USE_TUXONICE=no
1010                 ;;
1011         --lvmversion=*)
1012                 LVMTOOLSVERSION=${1#--lvmversion=}
1013                 ;;
1014         --lvmtoolsversion=*)
1015                 LVMTOOLSVERSION=${1#--lvmtoolsversion=}
1016                 ;;
1017         --lvmtoolsversion|--lvmversion)
1018                 LVMTOOLSVERSION=$2
1019                 shift
1020                 ;;
1021         --without-udev)
1022                 USE_UDEV=no
1023                 ;;
1024         --with-udev)
1025                 USE_UDEV=yes
1026                 ;;
1027         --without-dmraid)
1028                 USE_DMRAID=no
1029                 ;;
1030         --without-multipath)
1031                 USE_MULTIPATH=no
1032                 ;;
1033         --with-multipath=*)
1034                 USE_MULTIPATH=${1#--with-multipath=}
1035                 ;;
1036         --without-blkid)
1037                 USE_BLKID=no
1038                 ;;
1039         --without-luks)
1040                 USE_LUKS=no
1041                 ;;
1042         --with=*)
1043                 BASICMODULES="$BASICMODULES ${1#--with=}"
1044                 ;;
1045         --with)
1046                 BASICMODULES="$BASICMODULES $2"
1047                 shift
1048                 ;;
1049         --version)
1050                 echo "$PROGRAM: version $VERSION"
1051                 exit 0
1052                 ;;
1053         -v)
1054                 verbose=-v
1055                 ;;
1056         --compress)
1057                 COMPRESS=$2
1058                 ;;
1059         --compress=*)
1060                 COMPRESS="${1#--compress=}"
1061                 ;;
1062         --nocompress)
1063                 COMPRESS=no
1064                 ;;
1065         --nostrip)
1066                 STRIP=
1067                 ;;
1068         --strip=*)
1069                 STRIP="${1#--strip=}"
1070                 ;;
1071         --strip)
1072                 STRIP=$2
1073                 shift
1074                 ;;
1075         --ifneeded)
1076                 ifneeded=1
1077                 ;;
1078         -f)
1079                 force=1
1080                 ;;
1081         --preload=*)
1082                 PREMODS="$PREMODS ${1#--preload=}"
1083                 ;;
1084         --preload)
1085                 PREMODS="$PREMODS $2"
1086                 shift
1087                 ;;
1088         --fs=* | --fs)
1089                 die "--fs option is obsoleted. Use --initrdfs instead"
1090                 ;;
1091         --initrdfs=*)
1092                 INITRDFS=${1#--initrdfs=}
1093                 ;;
1094         --initrdfs)
1095                 INITRDFS=$2
1096                 shift
1097                 ;;
1098         --image-version)
1099                 img_vers=yes
1100                 ;;
1101         --ide-only-root)
1102                 ide_only_root="yes"
1103                 ;;
1104         *)
1105                 if [ -z "$target" ]; then
1106                         target="$1"
1107                 elif [ -z "$kernel" ]; then
1108                         kernel="$1"
1109                 else
1110                         usage
1111                         exit 1
1112                 fi
1113                 ;;
1114         esac
1115
1116         shift
1117 done
1118
1119 if [ -z "$target" -o -z "$kernel" ]; then
1120         usage
1121         exit 1
1122 fi
1123
1124 # main()
1125 if [ "$(id -u)" != 0 ]; then
1126         die "You need to be root to generate initrd"
1127 fi
1128
1129 if [ -d /lib64 -a -d /usr/lib64 ]; then
1130         _lib=lib64
1131 else
1132         _lib=lib
1133 fi
1134
1135 initrd_dir=/usr/$_lib/initrd
1136 kernel_version=$(echo "$kernel" | awk -F. '{gsub(/[_-].*/, "", $0); print sprintf("%03d%03d",$1,$2)}')
1137 kernel_version_long=$(echo "$kernel" | awk -F. '{gsub(/[_-].*/, "", $0); print sprintf("%03d%03d%03d",$1,$2,$3)}')
1138
1139 debug "# $GENINITRD_RCSID (geninitrd)"
1140 debug "Using _lib: $_lib"
1141 debug "Using initrd_dir: $initrd_dir"
1142
1143 busybox=$(find_tool $initrd_dir/busybox $initrd_dir/initrd-busybox /bin/initrd-busybox) || die "Couldn't find busybox suitable for initrd"
1144
1145 # we setup mods after parsing command line args
1146 geninitrd_setup_mods
1147
1148 if [ ! -f /boot/vmlinuz-"$kernel" ]; then
1149         warn "/boot/vmlinuz-$kernel doesn't exist, is your /boot mounted?"
1150 fi
1151
1152 if [ -z "$INITRDFS" ]; then
1153         if [ -n "$FS" ]; then
1154                 # FS= can came only via /etc/sysconfig/geninitrd likely?
1155                 die "FS configuration option is obsoleted. Use INITRDFS instead"
1156         fi
1157
1158         # default value
1159         if [ "$kernel_version" -ge "002005" ]; then
1160                 INITRDFS="initramfs"
1161         else
1162                 INITRDFS="rom"
1163         fi
1164 fi
1165
1166 case "$INITRDFS" in
1167   ext2)
1168         [ -x /sbin/mke2fs ] || die "/sbin/mke2fs is missing"
1169         ;;
1170   rom|romfs)
1171         [ -x /sbin/genromfs ] || die "/sbin/genromfs is missing"
1172         ;;
1173   cram|cramfs)
1174         [ -x /sbin/mkcramfs ] || die "/sbin/mkcramfs is missing"
1175         ;;
1176   initramfs)
1177         [ -x /bin/cpio ] || die "/bin/cpio is missing"
1178         [ -x /usr/bin/find ] || die "/usr/bin/find is missing"
1179         ;;
1180   *)
1181         die "Filesystem $INITRDFS on initrd is not supported"
1182         ;;
1183 esac
1184
1185 if [ -L "$target" ]; then
1186         target=$(readlink -f "$target")
1187 fi
1188
1189 if [ -n "$img_vers" ]; then
1190         target="$target-$kernel"
1191 fi
1192
1193 if [ -z "$force" -a -f "$target" ]; then
1194         die "$target already exists."
1195 fi
1196
1197 if [ ! -d "/lib/modules/$kernel" ]; then
1198         die "/lib/modules/$kernel is not a directory."
1199 fi
1200
1201 if [ "$kernel_version" -ge "002005" ]; then
1202         modext=".ko"
1203 fi
1204
1205 cache_modprobe_conf
1206
1207 for n in $PREMODS; do
1208         find_module "$n"
1209 done
1210
1211 if [ "$FBMODULE" ]; then
1212         find_module "$FBMODULE"
1213 fi
1214
1215 # autodetect USB keyboards
1216 find_modules_usbkbd
1217
1218 # allow forcing loading SCSI and/or IDE modules
1219 # XXX: where ADDSCSI cames from? drop?
1220 if is_yes "$ADDSCSI"; then
1221         find_modules_scsi
1222 fi
1223
1224 # autodetect SATA modules
1225 find_modules_sata
1226
1227 # XXX: where ADDIDE cames from? drop?
1228 if is_yes "$ADDIDE"; then
1229         find_modules_ide
1230 fi
1231
1232 if is_yes "$USE_SUSPEND"; then
1233         find_modules_suspend
1234 fi
1235
1236 find_root "$fstab" || exit
1237 debug "Using $rootdev as device for rootfs"
1238
1239 find_modules_for_devpath "$rootdev"
1240
1241 # if USE_MULTIPATH is path to device, scan that too
1242 # this is to bootstrap multipath setup into initrd.
1243 if ! is_no "$USE_MULTIPATH" && ! is_yes "$USE_MULTIPATH"; then
1244         find_modules_multipath $USE_MULTIPATH
1245 fi
1246
1247 find_module "-$rootFs"
1248
1249 for n in $BASICMODULES; do
1250         find_module "$n"
1251 done
1252
1253 if is_yes "$USE_TUXONICE"; then
1254         find_module "-lzf"
1255 fi
1256
1257 find_modules_fbsplash
1258
1259 if [ -n "$ifneeded" -a -z "$MODULES" ]; then
1260         debug "No modules are needed -- not building initrd image."
1261         exit 0
1262 fi
1263
1264 debug "Building initrd..."
1265 DESTDIR=$(mktemp -d -t initrd.XXXXXX) || die "mktemp failed"
1266 RCFILE="$DESTDIR/linuxrc"
1267 > "$RCFILE"
1268 chmod a+rx "$RCFILE"
1269 ln -s linuxrc $DESTDIR/init
1270
1271 # create dirs that we really need
1272 inst_d /{lib,bin,etc,dev{,/pts,/shm},loopfs,var,proc,run,sys}
1273
1274 modules_install "$MODULES"
1275
1276 # mknod'ing the devices instead of copying them works both with and
1277 # without devfs...
1278 mknod "$DESTDIR/dev/console" c 5 1
1279 mknod "$DESTDIR/dev/null" c 1 3
1280 mknod "$DESTDIR/dev/zero" c 1 5
1281 mknod "$DESTDIR/dev/random" c 1 8
1282 mknod "$DESTDIR/dev/urandom" c 1 9
1283
1284 inst_exec $busybox /bin/busybox
1285 ln -s busybox $DESTDIR/bin/sh
1286 # for older busyboxes who had /bin/initrd-busybox as EXEPATH
1287 ln -s busybox $DESTDIR/bin/initrd-busybox
1288
1289 add_linuxrc <<EOF
1290 #!/bin/sh
1291 # initrd generated by:
1292 # $GENINITRD_RCSID
1293
1294 EOF
1295 mount_proc
1296 add_linuxrc <<-EOF
1297         # builtin defaults from geninitrd
1298         ROOT=$rootdev
1299         ROOTFS=$rootFs
1300 EOF
1301 add_linuxrc <<-'EOF'
1302         read CMDLINE < /proc/cmdline
1303
1304         for arg in $CMDLINE; do
1305                 if [ "${arg}" = "debuginitrd" ]; then
1306                         DEBUGINITRD=yes
1307                 fi
1308                 if [ "${arg##debuginitrd=}" != "${arg}" ]; then
1309                         DEBUGINITRD=${arg##debuginitrd=}
1310                 fi
1311                 if [ "${arg##root=}" != "${arg}" ]; then
1312                         ROOT=${arg##root=}
1313                 fi
1314                 if [ "${arg##rootfsflags=}" != "${arg}" ]; then
1315                         ROOTFSFLAGS=${arg##rootfsflags=}
1316                 fi
1317                 if [ "${arg##init=}" != "${arg}" ]; then
1318                         INIT=${arg##init=}
1319                 fi
1320         done
1321
1322         # make debugshell() invoke subshell if $DEBUGINITRD=sh
1323         if [ "$DEBUGINITRD" = "sh" ]; then
1324                 debugshell() {
1325 EOF
1326 if is_yes "$RUN_SULOGIN_ON_ERR"; then
1327 add_linuxrc <<-'EOF'
1328         echo "debug shell disabled by /etc/sysconfig/system: RUN_SULOGIN_ON_ERR setting"
1329 EOF
1330 else
1331 add_linuxrc <<-'EOF'
1332         sh
1333 EOF
1334 fi
1335 add_linuxrc <<-'EOF'
1336                 }
1337         else
1338                 debugshell() {
1339                         :
1340                 }
1341         fi
1342
1343         if [ "$DEBUGINITRD" ]; then
1344                 set -x
1345         fi
1346 EOF
1347
1348 modules_add_linuxrc $MODULES
1349
1350 # TODO: rewrite for busybox
1351 #if [ -n "$loopDev" ]; then
1352 #       if [ ! -d /initrd ]; then
1353 #               mkdir /initrd
1354 #       fi
1355 #
1356 #       cp -a "$loopDev" "$DESTDIR/dev"
1357 #       cp -a "$rootdev" "$DESTDIR/dev"
1358 #       echo "echo Mounting device containing loopback root filesystem" >> "$RCFILE"
1359 #       echo "mount -t $loopFs $loopDev /loopfs" >> "$RCFILE"
1360 #       echo "echo Setting up loopback device $rootdev" >> $RCFILE
1361 #       echo "losetup $rootdev /loopfs$loopFile" >> "$RCFILE"
1362 #fi
1363
1364 if is_yes "$USE_UDEV"; then
1365         initrd_gen_udev
1366 fi
1367
1368 find_modules_uvesafb
1369 initrd_gen_uvesafb
1370
1371 initrd_gen_luks
1372 initrd_gen_dmraid
1373 initrd_gen_multipath
1374 initrd_gen_blkid
1375
1376 if is_yes "$have_nfs"; then
1377         initrd_gen_nfs
1378 else
1379         initrd_gen_md
1380         initrd_gen_lvm
1381         initrd_gen_luks
1382         initrd_gen_setrootdev
1383 fi
1384
1385 initrd_gen_tuxonice
1386 initrd_gen_suspend
1387
1388 # additional devs always needed
1389 [ ! -e "$DESTDIR/$rootdev_add" ] && inst $rootdev_add /dev
1390
1391 initrd_gen_stop_udevd
1392 initrd_gen_stop_uvesafb
1393
1394 # clean up env
1395 add_linuxrc <<-'EOF'
1396         ifs=$IFS
1397         IFS="
1398         "
1399         for i in $(export -p); do
1400                 i=${i#declare -x } # ksh/bash
1401                 i=${i#export } # busybox
1402
1403                 case "$i" in
1404                 *=*)
1405                         : ;;
1406                 *)
1407                         continue ;;
1408                 esac
1409
1410                 i=${i%%=*}
1411
1412                 [ -z "$i" ] && continue
1413
1414                 case "$i" in
1415                         ROOT|PATH|HOME|TERM)
1416                                 :
1417                                 ;;
1418                         *)
1419                                 unset $i
1420                                 ;;
1421                 esac
1422         done
1423         IFS=$ifs
1424 EOF
1425
1426 if [ "$INITRDFS" = "initramfs" ]; then
1427         initrd_gen_initramfs_switchroot
1428 else
1429         umount_all
1430 fi
1431
1432 initrd_gen_fbsplash
1433 initrd_gen_fbcondecor
1434
1435 IMAGE=$(mktemp -t initrd.img-XXXXXX) || die "mktemp failed"
1436
1437 IMAGESIZE=$(du -ks $DESTDIR | awk '{print int(($1+1023+512)/1024)*1024}')
1438 debug "image size: $IMAGESIZE KiB ($DESTDIR)"
1439
1440 debug "Creating $INITRDFS image $IMAGE"
1441 case "$INITRDFS" in
1442   ext2)
1443         dd if=/dev/zero of="$IMAGE" bs=1k count="$IMAGESIZE" 2> /dev/null
1444         # NOTE: ext2 label is max 16 chars
1445         mke2fs -q -F -b 1024 -m 0 -L "PLD/$kernel" "$IMAGE" 2>/dev/null 1>&2
1446         tune2fs -i 0 "$IMAGE" >/dev/null 2>&1
1447
1448         local tmpmnt=$(mktemp -d -t initrd.mnt-XXXXXX)
1449         debug "Mounting ext2 image $IMAGE to $tmpmnt"
1450         mount -o loop -t ext2 "$IMAGE" "$tmpmnt" || die "mount failed, check dmesg(1)"
1451         # We don't need this directory, so let's save space
1452         rm -rf "$tmpmnt"/lost+found
1453
1454         debug "Copy recursively $DESTDIR -> $tmpmnt"
1455         cp -a $DESTDIR/* $tmpmnt
1456         umount "$IMAGE"
1457         rmdir "$tmpmnt"
1458
1459         ;;
1460   rom|romfs)
1461         genromfs -f "$IMAGE" -d "$DESTDIR" -V "PLD Linux/$kernel (geninitrd/$VERSION)"
1462         ;;
1463   cram|cramfs)
1464         mkcramfs "$DESTDIR" "$IMAGE"
1465         ;;
1466   initramfs)
1467         (cd $DESTDIR; find . | cpio --quiet -H newc -o > "$IMAGE")
1468         ;;
1469   *)
1470         die "Filesystem $INITRDFS not supported by $PROGRAM"
1471 esac
1472
1473 CONFIG_BLK_DEV_RAM_SIZE=$(ikconfig | awk -F= '/^CONFIG_BLK_DEV_RAM_SIZE/{print $2}')
1474 if [ -z "$CONFIG_BLK_DEV_RAM_SIZE" ]; then
1475         CONFIG_BLK_DEV_RAM_SIZE=4096
1476         warn "No CONFIG_BLK_DEV_RAM_SIZE detected, fallback to $CONFIG_BLK_DEV_RAM_SIZE"
1477 fi
1478
1479 if [ "$IMAGESIZE" -gt $CONFIG_BLK_DEV_RAM_SIZE ]; then
1480         warn "Your image size is larger than $CONFIG_BLK_DEV_RAM_SIZE, Be sure to boot kernel with ramdisk_size=$IMAGESIZE!"
1481 fi
1482
1483 if ! is_no "$COMPRESS"; then
1484         compressor=$(find_compressor "$COMPRESS")
1485         debug "Compressing $target with $compressor"
1486
1487         # TODO: the image name (specified from kernel.spec) already contains
1488         # extension, which is .gz most of the time.
1489         compress_image "$compressor" "$IMAGE" "$target" || {
1490                 if [ $compressor != gzip ]; then
1491                         warn "Could not compress with $compressor, retrying with gzip"
1492                         compress_image gzip "$IMAGE" "$target" || die "compress failed with gzip" $?
1493                 else
1494                         die "Could not compress image with $compressor"
1495                 fi
1496         }
1497 else
1498         cp -a "$IMAGE" "$target"
1499 fi
1500
1501 # XXX. check if bootsplash can output data to tmp dir not directly to initramfs image.
1502 initrd_gen_bootsplash "$target"
1503
1504 rm -rf "$DESTDIR" "$IMAGE"
1505
1506 # vim:ts=4:sw=4:noet:fdm=marker