OSDN Git Service

init: support Xen hypervisor device
[android-x86/bootable-newinstaller.git] / initrd / init
index 817bd2d..b204c27 100755 (executable)
 #!/bin/busybox sh
 #
 # By Chih-Wei Huang <cwhuang@linux.org.tw>
-# Last updated 2009/07/18
+# and Thorsten Glaser <tg@mirbsd.org>
 #
 # License: GNU Public License
 # We explicitely grant the right to use the scripts
 # with Android-x86 project.
 #
 
-if [ -n "$DEBUG" ]; then
+PATH=/sbin:/bin:/system/bin:/system/xbin; export PATH
+
+# auto installation
+[ -n "$AUTO_INSTALL" ] && INSTALL=1
+
+# configure debugging output
+if [ -n "$DEBUG" -o -n "$INSTALL" ]; then
        LOG=/tmp/log
        set -x
 else
        LOG=/dev/null
-       [ -e $LOG ] || busybox mknod $LOG c 1 3
+       test -e "$LOG" || busybox mknod $LOG c 1 3
 fi
-exec 2> $LOG
-
-busybox mount -t proc proc /proc
-busybox mount -t sysfs sys /sys
-
-busybox --install -s
-
-export PATH=$PATH:/system/bin
-
-if [ -n "$DEBUG" ]; then
-       mknod /dev/tty2 c 4 2 && openvt
-       mknod /dev/tty3 c 4 3 && openvt
+exec 2>> $LOG
+
+# early boot
+if test x"$HAS_CTTY" != x"Yes"; then
+       # initialise /proc and /sys
+       busybox mount -t proc proc /proc
+       busybox mount -t sysfs sys /sys
+       # let busybox install all applets as symlinks
+       busybox --install -s
+       # spawn shells on tty 2 and 3 if debug or installer
+       if test -n "$DEBUG" || test -n "$INSTALL"; then
+               # ensure they can open a controlling tty
+               mknod /dev/tty c 5 0
+               # create device nodes then spawn on them
+               mknod /dev/tty2 c 4 2 && openvt
+               mknod /dev/tty3 c 4 3 && openvt
+       fi
+       if test -z "$DEBUG" || test -n "$INSTALL"; then
+               echo 0 0 0 0 > /proc/sys/kernel/printk
+       fi
+       # initialise /dev (first time)
+       mkdir -p /dev/block
+       echo /sbin/mdev > /proc/sys/kernel/hotplug
+       mdev -s
+       # re-run this script with a controlling tty
+       exec env HAS_CTTY=Yes setsid cttyhack /bin/sh "$0" "$@"
 fi
 
-echo -n Detecting Android...
-
-while [ 1 ]; do
-       mdev -s
+# now running under a controlling tty; debug output from stderr into log file
+# boot up Android
+
+error()
+{
+       echo $*
+       return 1
+}
+
+try_mount()
+{
+       RW=$1; shift
+       if [ "${ROOT#*:/}" != "$ROOT" ]; then
+               # for NFS roots, use nolock to avoid dependency to portmapper
+               mount -o $RW,noatime,nolock $@
+               return $?
+       fi
+       case $(blkid $1) in
+               *TYPE=*ntfs*)
+                       mount.ntfs-3g -o rw,force $@
+                       ;;
+               *TYPE=*)
+                       mount -o $RW,noatime $@
+                       ;;
+               *)
+                       return 1
+                       ;;
+       esac
+}
+
+check_root()
+{
+       if [ "`dirname $1`" = "/dev" ]; then
+               [ -e $1 ] || return 1
+               blk=`basename $1`
+               [ ! -e /dev/block/$blk ] && ln $1 /dev/block
+               dev=/dev/block/$blk
+       else
+               dev=$1
+       fi
+       try_mount ro $dev /mnt || return 1
+       if [ -n "$iso" -a -e /mnt/$iso ]; then
+               mount --move /mnt /iso
+               mkdir /mnt/iso
+               mount -o loop /iso/$iso /mnt/iso
+       fi
+       if [ -e /mnt/$SRC/$RAMDISK ]; then
+               zcat /mnt/$SRC/$RAMDISK | cpio -id > /dev/null
+       elif [ -b /dev/$RAMDISK ]; then
+               zcat /dev/$RAMDISK | cpio -id > /dev/null
+       else
+               return 1
+       fi
+       if [ -e /mnt/$SRC/system.sfs ]; then
+               mount -o loop,noatime /mnt/$SRC/system.sfs /sfs
+               mount -o loop,noatime /sfs/system.img system
+       elif [ -e /mnt/$SRC/system.img ]; then
+               remount_rw
+               mount -o loop,noatime /mnt/$SRC/system.img system
+       elif [ -s /mnt/$SRC/system/build.prop ]; then
+               remount_rw
+               mount --bind /mnt/$SRC/system system
+       elif [ -z "$SRC" -a -s /mnt/build.prop ]; then
+               mount --bind /mnt system
+       else
+               rm -rf *
+               return 1
+       fi
+       mkdir -p mnt
+       echo " found at $1"
+       rm /sbin/mke2fs
+       hash -r
+}
+
+remount_rw()
+{
+       # "foo" as mount source is given to workaround a Busybox bug with NFS
+       # - as it's ignored anyways it shouldn't harm for other filesystems.
+       mount -o remount,rw foo /mnt
+}
+
+debug_shell()
+{
+       if [ -x system/bin/sh ]; then
+               echo Running MirBSD Korn Shell...
+               USER="($1)" system/bin/sh -l 2>&1
+               [ $? -ne 0 ] && /bin/sh 2>&1
+       else
+               echo Running busybox ash...
+               sh 2>&1
+       fi
+}
+
+echo -n Detecting Android-x86...
+
+[ -z "$SRC" -a -n "$BOOT_IMAGE" ] && SRC=`dirname $BOOT_IMAGE`
+[ -z "$RAMDISK" ] && RAMDISK=ramdisk.img || RAMDISK=${RAMDISK##/dev/}
+
+for c in `cat /proc/cmdline`; do
+       case $c in
+               iso-scan/filename=*)
+                       SRC=iso
+                       eval `echo $c | cut -b1-3,18-`
+                       ;;
+               *)
+                       ;;
+       esac
+done
 
-       for device in /dev/sr* /dev/sd[a-z]*; do
-               mount -o ro $device /mnt || continue
-               cd /mnt/$SRC
-               if [ ! -e ramdisk.img -o ! \( -e system.img -o -e system.sfs \) ]; then
-                       umount /mnt
-                       continue
-               fi
-               mount -t tmpfs tmpfs /android
-               cd /android
-               zcat /mnt/$SRC/ramdisk.img | cpio -id > /dev/null
-               if [ -e /mnt/$SRC/system.sfs ]; then
-                       mount -o loop /mnt/$SRC/system.sfs /sfs
-                       mount -o loop /sfs/system.img system
-               else
-                       mount -o loop /mnt/$SRC/system.img system
-               fi
-               mkdir cache sdcard
-               mount -t tmpfs tmpfs cache
-               echo " found at $device"
-               break
+mount -t tmpfs tmpfs /android
+cd /android
+while :; do
+       for device in ${ROOT:-/dev/[hmnsvx][dmrv][0-9a-z]*}; do
+               check_root $device && break 2
+               mountpoint -q /mnt && umount /mnt
        done
-       mountpoint -q /android && break
        sleep 1
        echo -n .
 done
 
+ln -s mnt/$SRC /src
 ln -s android/system /
-
 ln -s ../system/lib/firmware ../system/lib/modules /lib
 
-if [ -n "$DEBUG" -o -n "$BUSYBOX" ]; then
-       mv /bin /lib .
-       system/bin/ln -s android/lib /lib
-       system/bin/ln -s android/bin /bin
-       sed -i 's|\(PATH *\)\(/sbin\)|\1/bin:\2|;s|\(/system\)\(/bin/sh\)|\2|' init.rc
-       mv /sbin/* sbin
-       rmdir /sbin
-       ln -s android/sbin /
+if [ -n "$INSTALL" ]; then
+       zcat /src/install.img | ( cd /; cpio -iud > /dev/null )
 fi
 
-if [ -n "$DEBUG" ]; then
-       echo -e "\nType 'exit' to continue booting...\n"
-       sh
+if [ -x system/bin/ln -a -n "$BUSYBOX" ]; then
+       mv -f /bin /lib .
+       sed -i 's|\( PATH.*\)|\1:/bin|' init.environ.rc
+       rm /sbin/modprobe
+       busybox mv /sbin/* sbin
+       rmdir /sbin
+       ln -s android/bin android/lib android/sbin /
+       hash -r
 fi
 
 # load scripts
-for s in `ls /scripts/* /mnt/$SRC/scripts/*`; do
-       source $s
+for s in `ls /scripts/* /src/scripts/*`; do
+       test -e "$s" && source $s
 done
 
-load_modules
+# ensure keyboard driver is loaded
+if [ -n "$INSTALL" -o -n "$DEBUG" ]; then
+       busybox modprobe -a atkbd hid-apple
+       auto_detect &
+fi
 
-[ -n "$INSTALL" ] && install_hd
+if [ 0$DEBUG -gt 0 ]; then
+       echo -e "\nType 'exit' to continue booting...\n"
+       debug_shell debug-found
+fi
 
+# A target should provide its detect_hardware function.
+# On success, return 0 with the following values set.
+# return 1 if it wants to use auto_detect
+[ "$AUTO" != "1" ] && detect_hardware && FOUND=1
+
+[ -n "$INSTALL" ] && do_install
+
+load_modules
 mount_data
 mount_sdcard
+setup_tslib
+setup_dpi
+post_detect
 
-if [ -n "$DEBUG" ]; then
+if [ 0$DEBUG -gt 1 ]; then
        echo -e "\nUse Alt-F1/F2/F3 to switch between virtual consoles"
        echo -e "Type 'exit' to enter Android...\n"
 
-       # FIXME: all error messages in the shell are sent to $LOG
-       sh
-       chroot /android /init
-else
-       exec switch_root /android /init
+       debug_shell debug-late
+       SETUPWIZARD=${SETUPWIZARD:-0}
 fi
 
-sh # aviod kernel panic
+[ "$SETUPWIZARD" = "0" ] && echo "ro.setupwizard.mode=DISABLED" >> default.prop
+
+[ -n "$DEBUG" ] && SWITCH=${SWITCH:-chroot}
+
+# We must disable mdev before switching to Android
+# since it conflicts with Android's init
+echo > /proc/sys/kernel/hotplug
+
+export ANDROID_ROOT=/system
+
+exec ${SWITCH:-switch_root} /android /init
+
+# avoid kernel panic
+while :; do
+       echo
+       echo '  Android-x86 console shell. Use only in emergencies.'
+       echo
+       debug_shell fatal-err
+done