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