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
  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 found 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                 if [ "$obj" != "/lib/ld-linux.so.2" ] && [ "$obj" != "/lib64/ld-linux-x86-64.so.2" ]; then
 438                         libs=$(ldd "$obj" | awk '/statically|linux-(gate|vdso)\.so/{next} NF == 2 {print $1} /=/{print $3}' | sort -u)
 439                 fi
 440         done
 441         for lib in $libs; do
 442                 if [ ! -f "$DESTDIR/$_lib/${lib##*/}" ]; then
 443                         inst_d /$_lib
 444                         inst_exec $lib /$_lib
 445                 fi
 446         done
 447
 448         # hack for uclibc linked binaries requiring this fixed path
 449         # XXX: shouldn't rpath be used here instead so th
 450         if [ -f $DESTDIR/$_lib/libc.so.0 ]; then
 451                 local lib=$DESTDIR/$_lib/libc.so.0
 452                 lib=$(ldd "$lib" | awk '/statically|linux-(gate|vdso)\.so/{next} NF == 2 {print $1} /=/{print $3}' | sort -u)
 453                 local libdir=$(cd $(dirname "$lib"); pwd)
 454                 if [ ! -e $DESTDIR$libdir ]; then
 455                         libdir=$(dirname "$libdir")
 456                         inst_d $libdir
 457                         debug "+ ln -s /$_lib $DESTDIR$libdir"
 458                         ln -s /$_lib $DESTDIR$libdir
 459                 fi
 460         fi
 461 }
 462
 463 # output modules.conf / modprobe.conf
 464 modprobe_conf() {
 465         echo "$modprobe_conf_cache"
 466 }
 467
 468 #
 469 # defaults to modprobe -c if not told otherwise, this means include statements
 470 # work from there.
 471 cache_modprobe_conf() {
 472         if [ "$kernel_version" -lt "002005" ]; then
 473                 modulefile=/etc/modules.conf
 474                 if [ ! -f "$modulefile" -a -f /etc/conf.modules ]; then
 475                         modulefile=/etc/conf.modules
 476                 fi
 477         fi
 478
 479         if [ -n "$modulefile" ]; then
 480                 debug "Using $modulefile for modules config"
 481                 modprobe_conf_cache=$(cat $modulefile)
 482         else
 483                 debug "Using modprobe -c to get modules config"
 484                 modprobe_conf_cache=$(modprobe -c --set-version $kernel)
 485         fi
 486 }
 487
 488 # find modules for $devpath
 489 find_modules_for_devpath() {
 490         local devpath="$1"
 491         if [ -z "$devpath" ]; then
 492                 die "No argument passed to find_modules_for_devpath() - is your /etc/fstab correct?"
 493         fi
 494
 495         if [[ "$devpath" = /dev/dm-* ]]; then
 496                 # /dev/dm-3 -> /dev/mapper/sil_ahbgadcbchfc3
 497                 devpath=$(dm_node "$devpath")
 498         fi
 499
 500         if [ -L "$devpath" ] && ! is_lvm "$devpath" && ! is_luks "$devpath"; then
 501                 # sanitize things like:
 502                 # /dev/block/104:2 -> /dev/cciss/c0d0p2
 503                 devpath=$(readlink -f "$devpath")
 504         fi
 505
 506         debug "Finding modules for device path $devpath"
 507
 508         if is_luks "$devpath"; then
 509                 find_modules_luks "$devpath"
 510                 return
 511         fi
 512
 513         if is_nfs "$devpath"; then
 514                 find_modules_nfs "$devpath"
 515                 return
 516         fi
 517
 518         if is_md "$devpath"; then
 519                 find_modules_md "$devpath"
 520                 return
 521         fi
 522
 523         if is_multipath "$devpath"; then
 524                 if find_modules_multipath "$devpath"; then
 525                         return
 526                 fi
 527
 528                 # fallback
 529         fi
 530
 531         if is_dmraid "$devpath"; then
 532                 if find_modules_dmraid "$devpath"; then
 533                         return
 534                 fi
 535                 # fallback
 536         fi
 537
 538         if is_scsi "$devpath"; then
 539                 find_modules_scsi "$devpath"
 540                 return
 541         fi
 542
 543         if is_ide "$devpath"; then
 544                 find_modules_ide "$devpath"
 545                 return
 546         fi
 547
 548         if [[ "$devpath" == /dev/rd/* ]]; then
 549                 find_module "DAC960"
 550                 rootdev_add=/dev/rd/
 551                 return
 552         fi
 553
 554         if [[ "$devpath" == /dev/ida/* ]]; then
 555                 find_module "cpqarray"
 556                 rootdev_add=/dev/ida/
 557                 return
 558         fi
 559
 560         if [[ "$devpath" == /dev/cciss/* ]]; then
 561                 find_module "cciss"
 562                 rootdev_add=/dev/cciss/
 563                 return
 564         fi
 565
 566         if [[ "$devpath" == /dev/ataraid/* ]]; then
 567                 find_modules_ide
 568                 find_module "ataraid"
 569                 ataraidmodules=$(modprobe_conf | awk '/ataraid_hostadapter/ && ! /^[\t ]*#/ { print $3; }')
 570                 if [ -n "$ataraidmodules" ]; then
 571                         # FIXME: think about modules compiled in kernel
 572                         die "ataraid_hostadapter alias not defined in modprobe.conf! Please set it and run $PROGRAM again."
 573                 fi
 574                 for n in $ataraidmodules; do
 575                         find_module "$n"
 576                 done
 577                 rootdev_add=/dev/ataraid/
 578                 return
 579         fi
 580
 581         # check to see if we need to set up a loopback filesystem
 582         if [[ "$devpath" == /dev/loop*  ]]; then
 583                 die "Sorry, root on loop device isn't supported."
 584                 # TODO: rewrite for bsp and make nfs ready
 585                 if [ ! -x /sbin/losetup ]; then
 586                         die "losetup is missing"
 587                 fi
 588                 key="^# $(echo $devpath | awk -F/ '{print($3);}' | tr '[a-z]' '[A-Z]'):"
 589                 if ! is_yes "`awk '/'$key'/ { print( "yes"); }' $fstab`"; then
 590                         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"
 591                 fi
 592
 593                 line="`awk '/'$key'/ { print $0; }' $fstab`"
 594                 loopDev="$(echo $line | awk '{print $3}')"
 595                 loopFs="$(echo $line | awk '{print $4}')"
 596                 loopFile="$(echo $line | awk '{print $5}')"
 597
 598                 BASICMODULES="$BASICMODULES -loop"
 599                 find_module "-$loopFs"
 600                 BASICMODULES="$BASICMODULES -${loopFs}"
 601                 return
 602         fi
 603
 604         if is_lvm "$devpath"; then
 605                 find_modules_lvm "$devpath"
 606                 return
 607         fi
 608 }
 609
 610 firmware_install_module() {
 611         local module="$1"
 612         local firmware_files="$2"
 613
 614         debug "Adding Firmwares ($firmware_files) to initrd for module $module"
 615         # firmware not yet installed
 616         if [ ! -f "$DESTDIR/lib/firmware/firmware.sh" ]; then
 617                 inst_d /lib/firmware
 618 cat << 'EOF' >> "$DESTDIR/lib/firmware/firmware.sh"
 619 #!/bin/sh -e
 620 echo 1 > /sys$DEVPATH/loading
 621 cat "/lib/firmware/$FIRMWARE" > /sys$DEVPATH/data
 622 echo 0 > /sys$DEVPATH/loading
 623 exit 0
 624 EOF
 625                 chmod 755 "$DESTDIR/lib/firmware/firmware.sh"
 626         fi
 627
 628         for firmware in $firmware_files; do
 629                 if [ -f "/lib/firmware/$kernel/$firmware" ]; then
 630                         FIRMWAREDIR=${firmware%/*}
 631                         [ "$FIRMWAREDIR" != "$firmware" ] && inst_d /lib/firmware/$FIRMWAREDIR
 632                         inst /lib/firmware/$kernel/$firmware /lib/firmware/$firmware
 633                 elif [ -f "/lib/firmware/$firmware" ]; then
 634                         FIRMWAREDIR=${firmware%/*}
 635                         [ "$FIRMWAREDIR" != "$firmware" ] && inst_d /lib/firmware/$FIRMWAREDIR
 636                         inst /lib/firmware/$firmware /lib/firmware/$firmware
 637                 else
 638                         warn "Possible missing firmware file /lib/firmware/$firmware or /lib/firmware/$kernel/$firmware for module $module."
 639                 fi
 640         done
 641
 642         mount_sys
 643         echo "echo -n "/lib/firmware/firmware.sh" > /proc/sys/kernel/hotplug" | add_linuxrc
 644 }
 645
 646 modules_install() {
 647         local modules="$1"
 648         local mod
 649
 650         for mod in $modules; do
 651                 MODULEDIR=${mod%/*}
 652                 inst_d "/lib/modules/$kernel/$MODULEDIR"
 653                 cp -a "/lib/modules/$kernel/$mod" "$DESTDIR/lib/modules/$kernel/$mod"
 654                 gunzip "$DESTDIR/lib/modules/$kernel/$mod" 2> /dev/null
 655                 if [ "$STRIP" ] && [ -x "$STRIP" ]; then
 656                         $STRIP -g --remove-section=.comment "$DESTDIR/lib/modules/$kernel/${mod%.gz}"
 657                 fi
 658         done
 659 }
 660
 661 modules_add_linuxrc() {
 662         local mod modpath
 663
 664         for mod in "$@"; do
 665                 # module path without optional compression
 666                 modpath=${mod%.gz}
 667
 668                 # name of the module
 669                 local module=${modpath##*/}; module=${module%$modext}
 670                 local options=$(modprobe_conf | awk -vmodule="$module" '{ if ($1 == "options" && $2 == module) { for(i=3;i<=NF;i++) printf("%s ",$i); }}' | xargs)
 671                 local genericname=$(echo $module | tr - _)
 672                 local usleep=$(eval echo \$MODULE_${genericname}_USLEEP)
 673                 local firmware=$(eval echo \$MODULE_${genericname}_FIRMWARE)
 674
 675                 if [ "$module" = "scsi_mod" -a "$kernel_version_long" -ge "002006030" ]; then
 676                         options="scan=sync $options"
 677                 fi
 678
 679                 if [ -n "$verbose" ]; then
 680                         s=""
 681                         if [ "$options" ]; then
 682                                 s="$s with options [$options]"
 683                         fi
 684                         if [ "$usleep" ]; then
 685                                 s="$s and $usleep usleep"
 686                         fi
 687                         debug "Loading module [$module]$s"
 688                 fi
 689
 690                 if [ -n "$firmware" ]; then
 691                         firmware_install_module "$module" "$firmware"
 692                 else
 693                         for file in $(find_firmware "$module"); do
 694                                 firmware_install_module "$module" "$file"
 695                         done
 696                 fi
 697
 698                 echo "insmod /lib/modules/$kernel/$modpath $options" | add_linuxrc
 699                 if [ -n "$usleep" ]; then
 700                         echo "usleep $usleep" | add_linuxrc
 701                 fi
 702                 if [ "$module" = "scsi_wait_scan" ]; then
 703                         if [ "$(busybox_applet rmmod 2>/dev/null; echo $?)" = 0 ]; then
 704                                 echo "rmmod scsi_wait_scan" | add_linuxrc
 705                         fi
 706                 fi
 707
 708         done
 709 }
 710
 711 # Generates /dev nodes based on /proc/partitions information.
 712 # Needs /proc mounted.
 713 # Can be called multiple times.
 714 initrd_gen_devices() {
 715         if is_yes "$proc_partitions"; then
 716                 return
 717         fi
 718         proc_partitions=yes
 719
 720         mount_dev
 721         add_linuxrc <<-'EOF'
 722                 : 'Making device nodes'
 723                 cat /proc/partitions | (
 724                         # ignore first two lines: header, empty line
 725                         read b; read b
 726
 727                         while read major minor blocks dev rest; do
 728                                 node=/dev/$dev
 729                                 mkdir -p ${node%/*}
 730                                 [ -e $node ] || mknod $node b $major $minor
 731                         done
 732                 )
 733         EOF
 734 }
 735
 736
 737 initrd_gen_setrootdev() {
 738         debug "Adding rootfs finding based on kernel cmdline root= option support."
 739         busybox_applet ls
 740         add_linuxrc <<-'EOF'
 741                 if [ "${ROOT##/dev/}" != "${ROOT}" ]; then
 742                         rootnr="$(busybox awk -v rootnode="${ROOT##/dev/}" '$4 == rootnode { print 256 * $1 + $2 }' /proc/partitions)"
 743                         # fallback to ls
 744                         if [ -z "$rootnr" ]; then
 745                                 rootnr="$(busybox ls -lL ${ROOT} | busybox awk '{if (/^b/) { print 256 * $3 + $4; }}')"
 746                         fi
 747                         if [ -n "$rootnr" ]; then
 748                                 echo "$rootnr" > /proc/sys/kernel/real-root-dev
 749                         fi
 750                 fi
 751         EOF
 752 }
 753
 754 initrd_gen_initramfs_switchroot() {
 755         inst_d /newroot
 756         if [ "$rootdev" = "/dev/nfs" ]; then
 757                 echo "rootfs on NFS root=/dev/nfs"
 758         else
 759                 [ ! -e "$DESTDIR/$rootdev" ] && inst $rootdev $rootdev
 760         fi
 761
 762         # parse 'root=xxx' kernel commandline
 763         # We support passing root as hda3 /dev/hda3 0303 0x0303 and 303
 764         add_linuxrc <<-'EOF'
 765                 device=/dev/no_partition_found
 766                 eval "$(busybox awk -v c="$ROOT" '
 767                         BEGIN {
 768                                 num_pattern_short = "[0-9a-f][0-9a-f][0-9a-f]";
 769                                 num_pattern = "[0-9a-f]" num_pattern_short;
 770                                 dev_pattern = "[hms][a-z][a-z]([0-9])+";
 771                                 partition = "no_partition_found";
 772                                 min = -1; maj = -1;
 773
 774                                 sub("^0x", "", c);
 775                                 if (c ~ "^" num_pattern_short "$") sub("^", "0", c);
 776                                 if (c ~ "^" num_pattern  "$") {
 777                                         maj = sprintf("%s",substr(c,1,2));
 778                                         min = sprintf("%s",substr(c,3));
 779                                 }
 780                                 if (c ~ "^\/dev\/" dev_pattern "$") sub("^/dev/","", c);
 781                                 if (c ~ "^" dev_pattern "$") partition = c;
 782                         }
 783
 784                         $4 ~ partition { maj = $1; min = $2; }
 785                         $1 ~ maj && $2 ~ min { partition = $4; }
 786
 787                         END {
 788                                 if (maj >= 0 && min >= 0) {
 789                                         printf("device=/dev/%s; maj=%s; min=%s;\n", partition, maj, min);
 790                                 }
 791                         }
 792                         ' /proc/partitions)"
 793                 if [ "$device" != '/dev/no_partition_found' -a ! -b $device ]; then
 794                         mknod $device b $maj $min
 795                 fi
 796         EOF
 797
 798         add_linuxrc <<-EOF
 799                 rootdev=$rootdev
 800                 rootfs=$rootFs
 801         EOF
 802
 803         add_linuxrc <<-'EOF'
 804                 if [ "$device" = '/dev/no_partition_found' ]; then
 805                         device=$rootdev
 806                 fi
 807
 808                 [ -n "$ROOTFSFLAGS" ] && ROOTFSFLAGS="-o $ROOTFSFLAGS"
 809
 810                 mount -t $rootfs -r $device $ROOTFSFLAGS /newroot || echo "Mount of rootfs failed."
 811                 init="$(echo "$CMDLINE" | busybox awk '/init=\// { gsub(/.*init=/,NIL,$0); gsub(/ .*/,NIL,$0); print }')"
 812                 if [ -z "$init" -o ! -x "/newroot$init" ]; then
 813                         init=/sbin/init
 814                 fi
 815         EOF
 816
 817         umount_all
 818         busybox_applet switch_root
 819         add_linuxrc <<-'EOF'
 820                 exec switch_root /newroot $init ${1:+"$@"}
 821
 822                 echo "Error! initramfs should not reach this place."
 823                 echo "It probably means you've got old version of busybox, with broken"
 824                 echo "initramfs support. Trying to boot anyway, but won't promise anything."
 825
 826                 exec chroot /newroot $init ${1:+"$@"}
 827
 828                 echo "Failed to chroot!"
 829                 debugshell
 830         EOF
 831         # we need /init being real file, not symlink, otherwise the initramfs will
 832         # not be ran by pid 1 which is required for switch_root
 833         mv $DESTDIR/linuxrc $DESTDIR/init
 834         ln -s init $DESTDIR/linuxrc
 835 }
 836
 837 # find if $symbol exists in System.map $mapfile
 838 sym_exists() {
 839         local mapfile="$1"
 840         local symbol="$2"
 841         if [ ! -f $mapfile ]; then
 842                 # missing mapfile (not a pld kernel?)
 843                 return 1
 844         fi
 845
 846         awk -vc=1 -vsymbol="$symbol" '$2 == "T" && $3 == symbol {c = 0} END {exit c}' $mapfile
 847 }
 848
 849 # find best compressor (or forced one) for initrd
 850 find_compressor() {
 851         local mode="$1"
 852         # fastest initrd decompression speed is first
 853         local compressors='lzo gzip xz lzma bzip2'
 854
 855         # a specified one, take it
 856         if ! is_yes "$mode"; then
 857                 compressors="$mode"
 858         fi
 859
 860         debug "finding compressor: $compressors (via $mode)"
 861         # check for compressor validity
 862         local c prog map=/boot/System.map-$kernel
 863         for c in $compressors; do
 864                 case $c in
 865                 xz)
 866                         sym=unxz
 867                         prog=/usr/bin/xz
 868                         ;;
 869                 lzma)
 870                         sym=unlzma
 871                         prog=/usr/bin/xz
 872                         ;;
 873                 bzip2)
 874                         sym=bzip2
 875                         prog=/usr/bin/bzip2
 876                         ;;
 877                 gzip)
 878                         sym=gunzip
 879                         prog=/bin/gzip
 880                         ;;
 881                 lzo)
 882                         sym=unlzo
 883                         prog=/usr/bin/lzop
 884                         ;;
 885                 none|no)
 886                         # any existing sym will work
 887                         sym=initrd_load
 888                         prog=/bin/cat
 889                         ;;
 890                 *)
 891                         die "Unknown compressor $c"
 892                         ;;
 893                 esac
 894                 if sym_exists $map $sym && [ -x $prog ]; then
 895                         echo $c
 896                         return
 897                 fi
 898         done
 899
 900         debug "using gzip for compressor (fallback)"
 901         echo gzip
 902 }
 903
 904 # compresses kernel image image
 905 # in function so we could retry with other compressor on failure
 906 compress_image() {
 907         local compressor="$1" IMAGE="$2" target="$3" tmp
 908         tmp=$(mktemp "$target".XXXXXX) || die "mktemp failed"
 909
 910         case "$compressor" in
 911         xz)
 912                 # don't use -9 here since kernel won't understand it
 913                 xz --format=xz --check=crc32 --lzma2=preset=6e,dict=1MiB < "$IMAGE" > "$tmp" || return $?
 914                 ;;
 915         lzma)
 916                 xz --format=lzma -9 < "$IMAGE" > "$tmp" || return $?
 917                 ;;
 918         bzip2)
 919                 bzip2 -9 < "$IMAGE" > "$tmp" || return $?
 920                 ;;
 921         gzip)
 922                 gzip -9 < "$IMAGE" > "$tmp" || return $?
 923                 ;;
 924         lzo)
 925                 lzop -9 < "$IMAGE" > "$tmp" || return $?
 926                 ;;
 927         none|no)
 928                 cat < "$IMAGE" > "$tmp" || return $?
 929                 ;;
 930         esac
 931
 932         mv -f "$tmp" "$target"
 933 }
 934
 935 if [ -r /etc/sysconfig/geninitrd ]; then
 936         . /etc/sysconfig/geninitrd
 937 fi
 938
 939 if [ ! -f /proc/mounts ]; then
 940         warn "/proc filesystem not mounted, may cause wrong results or failure."
 941 fi
 942
 943 geninitrd_load_mods ide luks multipath dmraid lvm md blkid udev tuxonice suspend fbsplash condecor bootsplash uvesafb nfs sata scsi usbkbd
 944
 945 while [ $# -gt 0 ]; do
 946         case $1 in
 947         --fstab=*)
 948                 fstab=${1#--fstab=}
 949                 ;;
 950         --fstab)
 951                 fstab=$2
 952                 shift
 953                 ;;
 954         --modules-conf=*)
 955                 modulefile=${1#--modules-conf=}
 956                 ;;
 957         --modules-conf)
 958                 modulefile=$2
 959                 shift
 960                 ;;
 961         --with-bootsplash)
 962                 BOOT_SPLASH=yes
 963                 ;;
 964         --without-bootsplash)
 965                 BOOT_SPLASH=no
 966                 ;;
 967         --with-fbsplash)
 968                 FB_SPLASH=yes
 969                 ;;
 970         --without-fbsplash)
 971                 FB_SPLASH=no
 972                 ;;
 973         --with-fbcondecor)
 974                 FB_CON_DECOR=yes
 975                 ;;
 976         --without-fbcondecor)
 977                 FB_CON_DECOR=no
 978                 ;;
 979         --with-suspend)
 980                 USE_SUSPEND=yes
 981                 ;;
 982         --without-suspend)
 983                 USE_SUSPEND=no
 984                 ;;
 985         --with-suspend2 | --with-tuxonice)
 986                 USE_TUXONICE=yes
 987                 ;;
 988         --without-suspend2 | --without-tuxonice)
 989                 USE_TUXONICE=no
 990                 ;;
 991         --lvmversion=*)
 992                 LVMTOOLSVERSION=${1#--lvmversion=}
 993                 ;;
 994         --lvmtoolsversion=*)
 995                 LVMTOOLSVERSION=${1#--lvmtoolsversion=}
 996                 ;;
 997         --lvmtoolsversion|--lvmversion)
 998                 LVMTOOLSVERSION=$2
 999                 shift
1000                 ;;
1001         --without-udev)
1002                 USE_UDEV=no
1003                 ;;
1004         --with-udev)
1005                 USE_UDEV=yes
1006                 ;;
1007         --without-dmraid)
1008                 USE_DMRAID=no
1009                 ;;
1010         --without-multipath)
1011                 USE_MULTIPATH=no
1012                 ;;
1013         --with-multipath=*)
1014                 USE_MULTIPATH=${1#--with-multipath=}
1015                 ;;
1016         --without-blkid)
1017                 USE_BLKID=no
1018                 ;;
1019         --without-luks)
1020                 USE_LUKS=no
1021                 ;;
1022         --with=*)
1023                 BASICMODULES="$BASICMODULES ${1#--with=}"
1024                 ;;
1025         --with)
1026                 BASICMODULES="$BASICMODULES $2"
1027                 shift
1028                 ;;
1029         --version)
1030                 echo "$PROGRAM: version $VERSION"
1031                 exit 0
1032                 ;;
1033         -v)
1034                 verbose=-v
1035                 ;;
1036         --compress)
1037                 COMPRESS=$2
1038                 ;;
1039         --compress=*)
1040                 COMPRESS="${1#--compress=}"
1041                 ;;
1042         --nocompress)
1043                 COMPRESS=no
1044                 ;;
1045         --nostrip)
1046                 STRIP=
1047                 ;;
1048         --strip=*)
1049                 STRIP="${1#--strip=}"
1050                 ;;
1051         --strip)
1052                 STRIP=$2
1053                 shift
1054                 ;;
1055         --ifneeded)
1056                 ifneeded=1
1057                 ;;
1058         -f)
1059                 force=1
1060                 ;;
1061         --preload=*)
1062                 PREMODS="$PREMODS ${1#--preload=}"
1063                 ;;
1064         --preload)
1065                 PREMODS="$PREMODS $2"
1066                 shift
1067                 ;;
1068         --fs=* | --fs)
1069                 die "--fs option is obsoleted. Use --initrdfs instead"
1070                 ;;
1071         --initrdfs=*)
1072                 INITRDFS=${1#--initrdfs=}
1073                 ;;
1074         --initrdfs)
1075                 INITRDFS=$2
1076                 shift
1077                 ;;
1078         --image-version)
1079                 img_vers=yes
1080                 ;;
1081         --ide-only-root)
1082                 ide_only_root="yes"
1083                 ;;
1084         *)
1085                 if [ -z "$target" ]; then
1086                         target="$1"
1087                 elif [ -z "$kernel" ]; then
1088                         kernel="$1"
1089                 else
1090                         usage
1091                         exit 1
1092                 fi
1093                 ;;
1094         esac
1095
1096         shift
1097 done
1098
1099 if [ -z "$target" -o -z "$kernel" ]; then
1100         usage
1101         exit 1
1102 fi
1103
1104 # main()
1105 if [ "$(id -u)" != 0 ]; then
1106         die "You need to be root to generate initrd"
1107 fi
1108
1109 if [ -d /lib64 -a -d /usr/lib64 ]; then
1110         _lib=lib64
1111 else
1112         _lib=lib
1113 fi
1114
1115 initrd_dir=/usr/$_lib/initrd
1116 kernel_version=$(echo "$kernel" | awk -F. '{gsub(/[_-].*/, "", $0); print sprintf("%03d%03d",$1,$2)}')
1117 kernel_version_long=$(echo "$kernel" | awk -F. '{gsub(/[_-].*/, "", $0); print sprintf("%03d%03d%03d",$1,$2,$3)}')
1118
1119 debug "# $GENINITRD_RCSID (geninitrd)"
1120 debug "Using _lib: $_lib"
1121 debug "Using initrd_dir: $initrd_dir"
1122
1123 busybox=$(find_tool $initrd_dir/busybox $initrd_dir/initrd-busybox /bin/initrd-busybox) || die "Couldn't find busybox suitable for initrd"
1124
1125 # we setup mods after parsing command line args
1126 geninitrd_setup_mods
1127
1128 if [ ! -f /boot/vmlinuz-"$kernel" ]; then
1129         warn "/boot/vmlinuz-$kernel doesn't exist, is your /boot mounted?"
1130 fi
1131
1132 if [ -z "$INITRDFS" ]; then
1133         if [ -n "$FS" ]; then
1134                 # FS= can came only via /etc/sysconfig/geninitrd likely?
1135                 die "FS configuration option is obsoleted. Use INITRDFS instead"
1136         fi
1137
1138         # default value
1139         if [ "$kernel_version" -ge "002005" ]; then
1140                 INITRDFS="initramfs"
1141         else
1142                 INITRDFS="rom"
1143         fi
1144 fi
1145
1146 case "$INITRDFS" in
1147   ext2)
1148         [ -x /sbin/mke2fs ] || die "/sbin/mke2fs is missing"
1149         ;;
1150   rom|romfs)
1151         [ -x /sbin/genromfs ] || die "/sbin/genromfs is missing"
1152         ;;
1153   cram|cramfs)
1154         [ -x /sbin/mkcramfs ] || die "/sbin/mkcramfs is missing"
1155         ;;
1156   initramfs)
1157         [ -x /bin/cpio ] || die "/bin/cpio is missing"
1158         [ -x /usr/bin/find ] || die "/usr/bin/find is missing"
1159         ;;
1160   *)
1161         die "Filesystem $INITRDFS on initrd is not supported"
1162         ;;
1163 esac
1164
1165 if [ -L "$target" ]; then
1166         target=$(readlink -f "$target")
1167 fi
1168
1169 if [ -n "$img_vers" ]; then
1170         target="$target-$kernel"
1171 fi
1172
1173 if [ -z "$force" -a -f "$target" ]; then
1174         die "$target already exists."
1175 fi
1176
1177 if [ ! -d "/lib/modules/$kernel" ]; then
1178         die "/lib/modules/$kernel is not a directory."
1179 fi
1180
1181 if [ "$kernel_version" -ge "002005" ]; then
1182         modext=".ko"
1183 fi
1184
1185 cache_modprobe_conf
1186
1187 for n in $PREMODS; do
1188         find_module "$n"
1189 done
1190
1191 if [ "$FBMODULE" ]; then
1192         find_module "$FBMODULE"
1193 fi
1194
1195 # autodetect USB keyboards
1196 find_modules_usbkbd
1197
1198 # allow forcing loading SCSI and/or IDE modules
1199 # XXX: where ADDSCSI cames from? drop?
1200 if is_yes "$ADDSCSI"; then
1201         find_modules_scsi
1202 fi
1203
1204 # autodetect SATA modules
1205 find_modules_sata
1206
1207 # XXX: where ADDIDE cames from? drop?
1208 if is_yes "$ADDIDE"; then
1209         find_modules_ide
1210 fi
1211
1212 if is_yes "$USE_SUSPEND"; then
1213         find_modules_suspend
1214 fi
1215
1216 find_root "$fstab" || exit
1217 debug "Using $rootdev as device for rootfs"
1218
1219 find_modules_for_devpath "$rootdev"
1220
1221 # if USE_MULTIPATH is path to device, scan that too
1222 # this is to bootstrap multipath setup into initrd.
1223 if ! is_no "$USE_MULTIPATH" && ! is_yes "$USE_MULTIPATH"; then
1224         find_modules_multipath $USE_MULTIPATH
1225 fi
1226
1227 find_module "-$rootFs"
1228
1229 for n in $BASICMODULES; do
1230         find_module "$n"
1231 done
1232
1233 if is_yes "$USE_TUXONICE"; then
1234         find_module "-lzf"
1235 fi
1236
1237 find_modules_fbsplash
1238
1239 if [ -n "$ifneeded" -a -z "$MODULES" ]; then
1240         debug "No modules are needed -- not building initrd image."
1241         exit 0
1242 fi
1243
1244 debug "Building initrd..."
1245 DESTDIR=$(mktemp -d -t initrd.XXXXXX) || die "mktemp failed"
1246 RCFILE="$DESTDIR/linuxrc"
1247 > "$RCFILE"
1248 chmod a+rx "$RCFILE"
1249 ln -s linuxrc $DESTDIR/init
1250
1251 # create dirs that we really need
1252 inst_d /{lib,bin,etc,dev{,/pts,/shm},loopfs,var,proc,run,sys}
1253
1254 modules_install "$MODULES"
1255
1256 # mknod'ing the devices instead of copying them works both with and
1257 # without devfs...
1258 mknod "$DESTDIR/dev/console" c 5 1
1259 mknod "$DESTDIR/dev/null" c 1 3
1260 mknod "$DESTDIR/dev/zero" c 1 5
1261 mknod "$DESTDIR/dev/random" c 1 8
1262 mknod "$DESTDIR/dev/urandom" c 1 9
1263
1264 inst_exec $busybox /bin/busybox
1265 ln -s busybox $DESTDIR/bin/sh
1266 # for older busyboxes who had /bin/initrd-busybox as EXEPATH
1267 ln -s busybox $DESTDIR/bin/initrd-busybox
1268
1269 add_linuxrc <<EOF
1270 #!/bin/sh
1271 # initrd generated by:
1272 # $GENINITRD_RCSID
1273
1274 EOF
1275 mount_proc
1276 add_linuxrc <<-'EOF'
1277         read CMDLINE < /proc/cmdline; export CMDLINE
1278
1279         for arg in $CMDLINE; do
1280                 if [ "${arg}" = "debuginitrd" ]; then
1281                         DEBUGINITRD=yes
1282                 fi
1283                 if [ "${arg##debuginitrd=}" != "${arg}" ]; then
1284                         DEBUGINITRD=${arg##debuginitrd=}
1285                 fi
1286                 if [ "${arg##root=}" != "${arg}" ]; then
1287                         ROOT=${arg##root=}
1288                 fi
1289                 if [ "${arg##rootfsflags=}" != "${arg}" ]; then
1290                         ROOTFSFLAGS=${arg##rootfsflags=}
1291                 fi
1292         done
1293
1294         # make debugshell() invoke subshell if $DEBUGINITRD=sh
1295         if [ "$DEBUGINITRD" = "sh" ]; then
1296                 debugshell() {
1297 EOF
1298 if is_yes "$RUN_SULOGIN_ON_ERR"; then
1299 add_linuxrc <<-'EOF'
1300         echo "debug shell disabled by /etc/sysconfig/system:RUN_SULOGIN_ON_ERR setting"
1301 EOF
1302 else
1303 add_linuxrc <<-'EOF'
1304         sh
1305 EOF
1306 fi
1307 add_linuxrc <<-'EOF'
1308                 }
1309         else
1310                 debugshell() {
1311                         :
1312                 }
1313         fi
1314
1315         if [ "$DEBUGINITRD" ]; then
1316                 set -x
1317         fi
1318 EOF
1319
1320 modules_add_linuxrc $MODULES
1321
1322 # TODO: rewrite for busybox
1323 #if [ -n "$loopDev" ]; then
1324 #       if [ ! -d /initrd ]; then
1325 #               mkdir /initrd
1326 #       fi
1327 #
1328 #       cp -a "$loopDev" "$DESTDIR/dev"
1329 #       cp -a "$rootdev" "$DESTDIR/dev"
1330 #       echo "echo Mounting device containing loopback root filesystem" >> "$RCFILE"
1331 #       echo "mount -t $loopFs $loopDev /loopfs" >> "$RCFILE"
1332 #       echo "echo Setting up loopback device $rootdev" >> $RCFILE
1333 #       echo "losetup $rootdev /loopfs$loopFile" >> "$RCFILE"
1334 #fi
1335
1336 if is_yes "$USE_UDEV"; then
1337         initrd_gen_udev
1338 fi
1339
1340 find_modules_uvesafb
1341 initrd_gen_uvesafb
1342
1343 initrd_gen_luks
1344 initrd_gen_dmraid
1345 initrd_gen_multipath
1346 initrd_gen_blkid
1347
1348 if is_yes "$have_nfs"; then
1349         initrd_gen_nfs
1350 else
1351         initrd_gen_md
1352         initrd_gen_lvm
1353         initrd_gen_luks
1354         initrd_gen_setrootdev
1355 fi
1356
1357 initrd_gen_tuxonice
1358 initrd_gen_suspend
1359
1360 # additional devs always needed
1361 [ ! -e "$DESTDIR/$rootdev_add" ] && inst $rootdev_add /dev
1362
1363 initrd_gen_stop_udevd
1364 initrd_gen_stop_uvesafb
1365
1366 if [ "$INITRDFS" = "initramfs" ]; then
1367         initrd_gen_initramfs_switchroot
1368 else
1369         umount_all
1370 fi
1371
1372 initrd_gen_fbsplash
1373 initrd_gen_fbcondecor
1374
1375 IMAGE=$(mktemp -t initrd.img-XXXXXX) || die "mktemp failed"
1376
1377 IMAGESIZE=$(du -ks $DESTDIR | awk '{print int(($1+1023+512)/1024)*1024}')
1378 debug "image size: $IMAGESIZE KiB ($DESTDIR)"
1379
1380 debug "Creating $INITRDFS image $IMAGE"
1381 case "$INITRDFS" in
1382   ext2)
1383         dd if=/dev/zero of="$IMAGE" bs=1k count="$IMAGESIZE" 2> /dev/null
1384         # NOTE: ext2 label is max 16 chars
1385         mke2fs -q -F -b 1024 -m 0 -L "PLD/$kernel" "$IMAGE" 2>/dev/null 1>&2
1386         tune2fs -i 0 "$IMAGE" >/dev/null 2>&1
1387
1388         local tmpmnt=$(mktemp -d -t initrd.mnt-XXXXXX)
1389         debug "Mounting ext2 image $IMAGE to $tmpmnt"
1390         mount -o loop -t ext2 "$IMAGE" "$tmpmnt" || die "mount failed, check dmesg(1)"
1391         # We don't need this directory, so let's save space
1392         rm -rf "$tmpmnt"/lost+found
1393
1394         debug "Copy recursively $DESTDIR -> $tmpmnt"
1395         cp -a $DESTDIR/* $tmpmnt
1396         umount "$IMAGE"
1397         rmdir "$tmpmnt"
1398
1399         ;;
1400   rom|romfs)
1401         genromfs -f "$IMAGE" -d "$DESTDIR" -V "PLD Linux/$kernel (geninitrd/$VERSION)"
1402         ;;
1403   cram|cramfs)
1404         mkcramfs "$DESTDIR" "$IMAGE"
1405         ;;
1406   initramfs)
1407         (cd $DESTDIR; find . | cpio --quiet -H newc -o > "$IMAGE")
1408         ;;
1409   *)
1410         die "Filesystem $INITRDFS not supported by $PROGRAM"
1411 esac
1412
1413 CONFIG_BLK_DEV_RAM_SIZE=$(ikconfig | awk -F= '/^CONFIG_BLK_DEV_RAM_SIZE/{print $2}')
1414 if [ -z "$CONFIG_BLK_DEV_RAM_SIZE" ]; then
1415         CONFIG_BLK_DEV_RAM_SIZE=4096
1416 fi
1417
1418 if [ "$IMAGESIZE" -gt $CONFIG_BLK_DEV_RAM_SIZE ]; then
1419         warn "Your image size is larger than $CONFIG_BLK_DEV_RAM_SIZE, Be sure to boot kernel with ramdisk_size=$IMAGESIZE!"
1420 fi
1421
1422 if ! is_no "$COMPRESS"; then
1423         compressor=$(find_compressor "$COMPRESS")
1424         debug "Compressing $target with $compressor"
1425
1426         # TODO: the image name (specified from kernel.spec) already contains
1427         # extension, which is .gz most of the time.
1428         compress_image "$compressor" "$IMAGE" "$target" || {
1429                 if [ $compressor != gzip ]; then
1430                         warn "Could not compress with $compressor, retrying with gzip"
1431                         compress_image gzip "$IMAGE" "$target" || die "compress failed with gzip" $?
1432                 else
1433                         die "Could not compress image with $compressor"
1434                 fi
1435         }
1436 else
1437         cp -a "$IMAGE" "$target"
1438 fi
1439
1440 # XXX. check if bootsplash can output data to tmp dir not directly to initramfs image.
1441 initrd_gen_bootsplash "$target"
1442
1443 rm -rf "$DESTDIR" "$IMAGE"
1444
1445 # vim:ts=4:sw=4:noet:fdm=marker