[HD2 Android Q&A, Help & Troubleshooting and Genera] HypoTurtle:
From the looks of that there's no /sdcard/ROM_NAME.zip (I've probably unmounted /sdcard somewhere (is recovery using mmcblk0p1 or /data/media as /sdcard) - try mounting sdcard using the buttons in recovery first and see if it runs )

The code below is more or less the same but with yet another way to tell the script what to do, run it without any additional options and you'll see what I mean (it will also list all the .zips on /sdcard so should show if thats the issue)

#!/sbin/sh
#set -u
set -o verbose
testing() {
busybox printf "%s\n" "TESTING MODE"
sdpart=/dev/block/mmcblk0p1
### [ -d /sys/block/mmcblk0/mmcblk0p1 ] && sdpart=/dev/block/mmcblk0p1
types="NAND DataOnExt NativeSD DirectSD porta-o "
optslist desc
if [ $# -gt 0 ]; then
typecheck=` echo "$types" | grep "$1 " `
if [ -z "${typecheck}" ]; then
echo "$1 is not a valid type - choices are $types"
echo "checking if $1 is a command"
optioncheck=` echo "$options" | grep "$1 " `
if [ -z "${optioncheck}" ]; then
busybox printf "%b\n" "${1} is not a valid option - choices are:"
for i in ${options}
do
opts="$i"
echo "$opts to $(eval echo \$$opts)"
done
echo "script stopping here"
exit 0
else
typecheck=` echo "$types" | grep "$2 " `
systemunzip=${5:-n}
if [ -n "${typecheck}" -a -n "${optioncheck}" ]; then
if echo ${2} | grep -q "porta"; then
systemunzip=${5:-y}
fi
type=${2}; ROM_NAME=${3}; data_NAME=${4:-$3}; install_type=` busybox expr index "Axvco" "${2}" `; systemunzip=${systemunzip}
printf "Install Type is $type\nRomName is $ROM_NAME\nDataName is $data_NAME\ninstall no is $install_type\nsystem install is $systemunzip\n"
optslist functs
if [ ${1} = "ins" ]; then
systemunzip=y
fi
eval "\$"${1} ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${install_type} ${systemunzip}
else
printf "neither $1 or $2 is a valid install type"
fi
fi
else
systemunzip=${4:-n}
if echo ${1} | grep -q "porta"; then
systemunzip=${4:-y}
fi
type=${1}; ROM_NAME=${2}; data_NAME=${3:-$2}; install_type=` busybox expr index "Axvro" "${1}" `; systemunzip=${systemunzip}
runn ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${install_type} ${systemunzip}
fi
else
printf "no commands sent to script\nchecking /sdcard/installtype.prop\n"
if [ ${checkprop:-false} = "false" ]; then
getpropfile
else
if [ ${userasked:-no} = "no" ]; then
echo "Requesting user input"
printf "Enter an option if you want to do anything other than full script run\nOptions are `for i in ${options}; do opts="$i"; echo "$opts to $(eval echo \\$$opts)"; done`:"
read optional
printf "Enter install type\nOptions are ${types}:"
read type
printf "Enter ROM-NAME\nPossible options are ` busybox find /sdcard -name *.zip | cut -d "." -f "1" ` :"
read ROM_NAME
printf "Enter DATA-NAME\nLeave blank to use ${ROM_NAME}:"
read data_NAME
printf "Do you want the script to install system y/n:"
read systemunzip
userasked=yes
testing ${optional:-runn} ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${systemunzip}
else
echo "No conditions found or given\nNo installtype.prop on sdcard\nNo type or ROM name specified\nusage sh hytmb.sh {options} [type] [ROM_NAME]\ntype can be ${types}\nROM_NAME to be taken from ROM_NAMEadb123.zip"
for i in ${options}
do
opts="$i"
echo "$opts to $(eval echo \$$opts)"
done
exit 0
fi
fi
fi
}
optslist() {
options="m ins mr fb runn "
if [ $1 = "desc" ]; then
m="mount partitions"; ins="install system"; mr="modify the ramdisk"; fb="andthis"; runn="runn"
else
m="mntstuff"; ins="installsystem"; mr="modifyramdisk"; fb="andthis"; runn="runn"
fi
}
cleanup() {
echo "cleaning"
rm -rf /tmp/zI.txt /tmp/bootimg.txt /tmp/umountloop.sh /tmp/6MB /tmp/initrd.gz
}
partnames() {
firstpart=/dev/block/mmcblk0p2
secondpart=/dev/block/mmcblk0p3
busybox printf "%b\n" "setting partitions with ` echo ${firstpart} | busybox cut -d "/" -f "4" ` format"
}
looppartnames() {
firstpart=/dev/block/loop1
secondpart=/dev/block/loop2
thirdpart=/dev/block/loop3
busybox printf "%b\n" "setting partitions with ` echo ${firstpart} | busybox cut -d "/" -f "4" ` format"
}
mkloopdev() {
echo "" >> /sdcard/porta.txt
fls=` cat /sdcard/porta.txt | busybox cut -d " " -f "1" `
syssize=` cat /sdcard/porta.txt | busybox cut -d " " -f "2" `
romsize=${romsize:-20000}
datasize=` cat /sdcard/porta.txt | busybox cut -d " " -f "3" `
#datasz=256000
datasz=20000
cachesize=` cat /sdcard/porta.txt | busybox cut -d " " -f "4" `
#cachesz=32000
cachesz=20000
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4} bs=4096 count=${syssize:-$romsize}
newsys=yes
fi
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4} bs=4096 count=${datasize:-$datasz}
newdata=yes
fi
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4} bs=4096 count=${cachesize:-$cachesz}
newcache=yes
fi
losetup ${firstpart} /sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4}
losetup ${secondpart} /sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4}
losetup ${thirdpart} /sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4}
if [ ${newsys:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${firstpart}
fi
if [ ${newdata:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${secondpart}
tune2fs -o journal_data_writeback ${secondpart}
fi
if [ ${newcache:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${thirdpart}
tune2fs -o journal_data_writeback ${thirdpart}
fi
loopdevready=yes
}
getpropfile() {
checkprop=true
if [ -f "/tmp/installtype.prop" ]; then
echo "installtype.prop found"
testing "$(cat installtype.prop)"
else
echo "no prop file found - will need user input"
testing
fi

}
bootloadercheck() {
busybox printf "%b\n" "checking bootloader"
bootloader=MAGLDR
if grep -iq "clk" /proc/cmdline; then
bootloader=cLK
fi
if grep -iq "haret" /proc/cmdline; then
bootloader=haret
fi
####For testing
#bootloader=haret
}
bootloader() {
bootloader=MAGLDR
}
mkdirs() {
busybox printf "%b\n" "creating directories"
mkdir -p /NativeSD 2> /dev/null
mkdir -p /DirectSD 2> /dev/null
mkdir -p /boot_dir 2> /dev/null
mkdir -p /boot 2> /dev/null
mkdir -p /system 2> /dev/null
mkdir -p /data 2> /dev/null
mkdir -p /cache 2> /dev/null
mkdir -p /sdcard/NativeSD/"${2}"_"${1}" 2> /dev/null
}
mountpart() {
busybox printf "%s\n" "mounting files"
sdmounted=` mount | grep "${sdpart} on /sdcard" `
sdfile=` ls -la | grep "sdcard" `
if [ -z "${sdmounted:-$sdfile}" ]; then
mount -t auto ${sdpart} /sdcard
fi
if [ ${mountedalready:-nope} = "nope" ]; then
mount --bind /sdcard/NativeSD /boot_dir
mount --bind /sdcard/NativeSD/${2}_${1} /boot
mountedalready=yes
fi
if echo ${1} | grep -q porta; then
if [ ${loopdevready:-not} = "yes" ]; then
mount ${firstpart} /system
mount ${secondpart} /data
mount ${thirdpart} /cache
printf "#!/sbin/sh\nlosetup -d ${firstpart}\nlosetup -d ${secondpart}\nlosetup -d ${thirdpart}\n" > /tmp/	umountloop.sh
fi
else
if [ -b "${firstpart}" ]; then
mount -t auto ${firstpart} /NativeSD
if [ ${1} = "NativeSD" -o ${1} = "DataOnExt" ]; then
mkdir -p /NativeSD/${2}/data 2> /dev/null
mount --bind /NativeSD/${3}/data /data
fi
if [ ${install_type} -gt '2' ]; then
mkdir -p /NativeSD/${2}/system 2> /dev/null
mount --bind /NativeSD/${2}/system /system
fi
fi
if [ -b "${secondpart}" ]; then
mount -t auto ${secondpart} /DirectSD
if [ ${1} = "DirectSD" ]; then
mkdir -p /DirectSD/${3}/data > /dev/null
mount --bind /DirectSD/${3}/data /data
fi
fi
fi
}
bootorig() {
busybox printf "%b\n" "saving original boot.img to boot-orig folder"
mkdir /boot_dir/boot-orig/
#chmod 0777 /tmp/dump_image
cd /tmp
./dump_image boot /boot/boot-orig/boot.img
cd /
}
systeminstall() {
#cp /tmp/inc.lst inc.lst > /dev/null
#cp /tmp/exc.lst exc.lst > /dev/null
local romzip=` ls /sdcard/${2}*.zip | busybox head -n1 `
busybox printf "Reading $romzip\n"
cd /
# rm -rf /system/*
local systemlocat=` mount | grep /system | busybox cut -d ' ' -f '1' `; local datalocat=` mount | grep /data | busybox cut -d ' ' -f '1' `
printf "system mounted at ... ${systemlocat}\ndata mounted at ... ${datalocat}\n"
if [ ${alreadyran:-no} = no ]; then
printf "ROM zip is found at ... ${romzip}\nDuplicating so the original remains untouched\nThis may take a while ...\n"
cp -rf ${romzip} /sdcard/${2}_${1}.zip
fi
chmod 0777 /tmp/7za
if [ -n "$systemlocat" ]; then
rm -rf /${2}_${1}
mkdir -p /${2}_${1}/META-INF/com/android/google/
echo META-INF/*aroma* > exc.lst
printf "initrd.gz\nzImage\nboot.img\n" > inc.lst
bootstuff=done
###### Including haret stuff ###
if [ ${bootloader} = "haret" ]; then
printf "haret.exe\nclrcad.exe\n" >> inc.lst
fi
/tmp/7za x /sdcard/${2}_${1}.zip META-INF -o/${2}_${1} '-xr@exc.lst' -y > /dev/null
/tmp/7za x /sdcard/${2}_${1}.zip '-ir@inc.lst' -o/inc -y > /dev/null
if [ ${5} = "y" ]; then
echo "installing system"
/tmp/7za x /sdcard/${2}_${1}.zip data -o/ -y > /dev/null
/tmp/7za x /sdcard/${2}_${1}.zip system -o/ -y > /dev/null
fi
local ubi=` find /${2}_${1} -name update-binary-installer -print0 `
local ub=` find /${2}_${1} -name update-binary -print0 `
local ups=` find /${2}_${1} -name updater-script -print0 `
echo "UBI location is ${ubi:-$ub} UPS is ${ups}"
cp /${ubi:-$ub} /${2}_${1}/META-INF/com/google/android/update-binary
printf "package_extract_file(\"multi\", \"/tmp/multi.sh\");\nset_perm(0, 0, 0777, \"/tmp/multi.sh\");\nrun_program(\"/tmp/multi.sh\", \"m\" \"${1}\" \"${2}\" \"${3}\")\n" > /${2}_${1}/META-INF/com/google/android/updater-script2
if [ ${5} = "y" ]; then
cat /$ups | busybox sed -e '/^symlink/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
else
printf "package_extract_dir(\"system\", \"/system\");\npackage_extract_dir(\"data\", \"/data\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
cat /$ups | busybox sed -e '/^symlink/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
fi
cat /$ups | busybox sed -e '/^set_perm/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
cat /$ups | busybox sed -e '/^setmetadata/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
echo "modifying updater-script"
printf "unmount (\"/NativeSD\");\nunmount (\"/DirectSD\");\nunmount (\"/system\");\nunmount (\"/data\");\nunmount (\"/boot\");\nunmount (\"/boot_dir\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
if echo ${1} | grep -q porta; then
cp /tmp/umountloop.sh /${2}_${1}/umountloop.sh
printf "package_extract_file(\"umountloop.sh\", \"/tmp/umountloop.sh\");\nset_perm(0, 0, 0777, \"/tmp/multi.sh\");\nrun_program(\"/tmp/umountloop.sh\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
fi
cp /${2}_${1}/META-INF/com/google/android/updater-script2 /${2}_${1}/META-INF/com/google/android/updater-script
rm /${2}_${1}/META-INF/com/google/android/updater-script2; rm /${2}_${1}/META-INF/com/google/android/updater-script~
dd if=$0 of=/${2}_${1}/multi
/tmp/7za u /sdcard/${2}_${1}.zip /${2}_${1}/* > /dev/null
else
if echo ${type} | grep -q porta; then
echo "creating system, data and cache blocks on /sdcard first"
romsize=$((` /tmp/7za l /sdcard/${2}_${1}.zip | busybox tail -1 | busybox awk '{print $(NF-5)}' `/4096))
fls=` cat /sdcard/porta.txt | busybox cut -d " " -f "1" `
if [ ${5} = "y" ]; then
rm -rf /sdcard/NativeSD/${2}_${1}/system.${fls:-ext4}
fi
mntstuff "$@"
mt1=` blkid /sdcard/NativeSD/${2}_${1}/system.${fls:-ext4} | cut -d '"' -f '4' `
mt2=` blkid /sdcard/NativeSD/${2}_${1}/data.${fls:-ext4} | cut -d '"' -f '4' `
fi
if [ ${alreadyran:-no} != yes ]; then
alreadyran=yes
systeminstall "$@"
else
echo "system isn't mounted"
fi
fi
}
bootingred() {
busybox printf "%s\n" "obtaining an initrd.gz and zImage to work with"
local installsystem=` busybox find /sdcard -name *.zip | grep ${2}`
if [ -n "${installsystem}" -a ${bootstuff:-notdone} = "notdone" ]; then
local romzip=` ls /sdcard/${2}*.zip | busybox head -n1 `
cp -rf ${romzip} /sdcard/${2}_${1}.zip
chmod 0777 /tmp/7za
printf "initrd.gz\nzImage\nboot.img\n" > inc.lst
/tmp/7za x /sdcard/${2}_${1}.zip '-ir@inc.lst' -o/inc -y
rm -rf /sdcard/${2}_${1}.zip
###### Copying zImage and initrd.gz from /boot_dir when one wasn't in the zip
else
if [ ! -e "/tmp/boot.img" ]; then
local nandinitrd=` busybox find /inc -name initrd.gz -print0 | busybox xargs -0 ls -s | busybox sort -nr | busybox awk '{print $(NF)}' | busybox tail -n 1 `
local zImagelocat=` busybox find /tmp -name zImage `
if [ -n "${zImagelocat}" ]; then
printf "%b\n" "zImage is at ... ${zImagelocat}"
cp ${zImagelocat} /tmp/zImage
fi
if [ -n "${nandinitrd}" ]; then
printf "%b\n" "nand ramdisk is at ... ${nandinitrd}"
cp ${nandinitrd} /tmp/initrd.gz
fi
else
chmod 0777 /tmp/unmkbootimg
cp /ramds/boot.img /tmp/boot.img
mkdir -p /tmp/boot 2> /dev/null
cd /tmp
./unmkbootimg /tmp/boot.img /tmp/boot
cd /
cp /tmp/boot/boot.img-ramdisk.gz /tmp/initrd.gz
cp /tmp/boot/boot.img-zImage /tmp/zImage
fi
fi
if [ ${runonce:-once} = "once" ]; then
if [ -f "/sdcard/zImage" ]; then
cp /sdcard/zImage /tmp/zImage
cp /sdcard/modules/* /system/lib/modules/ 2> /dev/null
fi
if [ -f "/sdcard/initrd.gz" ]; then
cp /sdcard/initrd.gz /tmp/initrd.gz
fi
local runonce=twice
if [ -f "/sdcard/useit/boot.img" ]; then
cp /sdcard/useit/boot.img /tmp/boot.img
bootstuff=notdone
bootingred "$@"
fi
fi
if [ ! -f "/tmp/initrd.gz" ]; then
echo "no ramdisk found - Exitting"
exit 0
fi
}
usecurrentboot() {
chmod 0777 /tmp/dump_image
cd /tmp
./dump_image boot /tmp/boot.img
./unpackbootimg /tmp/boot.img /tmp > /tmp/bootimg.txt
cd /
cp /tmp/boot.img-ramdisk.gz /tmp/initrd.gz
cp /tmp/boot.img-zImage /tmp/zImage
}
mkmountfsloop() {
if [ ${type} = "porta-o" ]; then
printf "#!/bin/busybox sh\n# mount\necho Mounting /proc\nmount -t proc proc /proc\necho Mounting /sys\nmount -t sysfs sys /sys\n# make devices\necho \"Making devices\"\nmkdir -m 0777 /dev/block\nmknod -m 0666 /dev/block/mmcblk0 b 179 0\nmknod -m 0666 /dev/block/mmcblk0p1 b 179 1\nmknod -m 0666 /dev/block/mmcblk0p2 b 179 2\nmknod -m 0666 /dev/block/mmcblk0p3 b 179 3\nmknod -m 0666 /dev/block/mmcblk0p4 b 179 4\nmkdir -m 0777 /dev/input\nmknod -m 0644 /dev/input/event0 c 13 64\nmknod -m 0644 /dev/input/event1 c 13 65\nmknod -m 0644 /dev/input/event2 c 13 66\nmknod -m 0644 /dev/input/event3 c 13 67\nmknod -m 0666 /dev/null c 1 3\nmknod -m 0444 /dev/zero c 1 5\nmknod -m 0644 /dev/ppp0 c 108 0\nmknod -m 0644 /dev/smd0 c 253 0\nmknod -m 0644 /dev/smd1 c 253 1\nwhile [ ! -b ${sdpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2\n/bin/e2fsck -p /sdcard/${ROM_NAME}/system.${fls:-ext4} > e2fsck.log\n/bin/e2fsck -p /sdcard/${ROM_NAME}/data.${fls:-ext4} >> e2fsck.log\n/bin/e2fsck -p /sdcard/${ROM_NAME}/cache.${fls:-ext4} >> e2fsck.log\nlosetup ${firstpart} /sdcard/${ROM_NAME}/system.${fls:-ext4}\nlosetup ${secondpart} /sdcard/${ROM_NAME}/data.${fls:-ext4}\nlosetup ${thirdpart} /sdcard/${ROM_NAME}/cache.${fls:-ext4}\n/bin/busybox mkdir /system\n/bin/busybox mkdir /data\n/bin/busybox mkdir /cache\n/bin/busybox mount ${firstpart} /system\n/bin/busybox mount ${secondpart} /data\n/bin/busybox mount ${thirdpart} /cache\n" > /tmp/mountfs-"${1}".sh
if [ ${fls:-ext4} = "ext4" ]; then
printf "tune2fs -O dir_index,has_journal,uninit_bg ${firstpart}\ntune2fs -O dir_index,has_journal,uninit_bg ${secondpart}\ntune2fs -O dir_index,has_journal,uninit_bg ${thirdpart}\n" >> /tmp/mountfs-"${1}".sh
else
printf "tune2fs -o journal_data_writeback ${secondpart}\ntune2fs -o journal_data_writeback ${thirdpart}\n" >> /tmp/mountfs-"${1}".sh
fi
printf "#by KAI 25.11.2011 always dual mount\necho /dev/block/mmcblk0 > /sys/devices/platform/usb_mass_storage/lun0/file\n# move init files to /system\ninit_files=\"init.rc init.htcleo.rc bootcomplete.htcleo.rc shutdown.htcleo.rc default.prop ueventd.rc\"\nfor init_file in \$init_files; do\nif [ -f /\$init_file ]; then\ncp -a /\$init_file /system/\$init_file\nfi\nif [ -f /system/\$init_file ]; then\n[ -f /\$init_file ] && rm -f /\$init_file\nln -s /system/\$init_file /\$init_file\nfi\ndone\n#cleanup - delete /bin to free ram\n/bin/busybox rm -rf /bin\n" >> /tmp/mountfs-"${1}".sh
fi
}
mkmountfs() {
busybox printf "%b\n" "creating mountfs.sh"
if [ ${4} -gt '1' ]; then
printf "#!/bin/busybox sh\nwhile [ ! -b ${firstpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2" > /tmp/mountfs-"${1}".sh
if [ ${1} = DirectSD ]; then
echo "Modifying for ${type}"
printf "while [ ! -b ${secondpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2" >> /tmp/mountfs-"${1}".sh
fi
mt1=` blkid ${firstpart} | cut -d '"' -f '4' `
mt2="${mt1}"
if [ ${mt1:-f2fs} = ext4 ]; then
printf "# check the ext4 fs\n/bin/e2fsck -p ${firstpart} > /e2fsck.log" >> /tmp/mountfs-"${1}".sh
else
printf "# check the f2fs fs\n/bin/fsck.f2fs -p ${firstpart} > /fsckf2fs.log" >> /tmp/mountfs-"${1}".sh
fi
if [ ${1} = DirectSD ]; then
if [ -b ${secondpart} ]; then
mt2=` blkid ${secondpart} | busybox cut -d '"' -f '4' `
else
echo "No 2nd ext partition present, format one and run script again"
fi
if [ ${mt2:-f2fs} = ext4 ]; then
printf "# check the ext4 fs\n/bin/e2fsck -p ${secondpart} > /e2fsck2.log\n" >> /tmp/mountfs-"${1}".sh
else
printf "# check the f2fs fs\n/bin/fsck.f2fs -p ${secondpart} > /fsckf2fs2.log\n" >> /tmp/mountfs-"${1}".sh
fi
fi
printf "/bin/busybox mkdir -p /NativeSD\n/bin/busybox mount -t ${mt1:-f2fs} -o noatime,nodiratime,barrier=0 ${firstpart} /NativeSD\n# mount the data dir\n" >> /tmp/mountfs-"${1}".sh
if [ ${1} = DataOnExt ]; then
echo "Modifying for ${1}"
printf "/bin/busybox mount --bind /NativeSD/${2}/data /data\n" >> /tmp/mountfs-"${1}".sh
fi
if [ ${4} -gt '2' ]; then
printf "/bin/busybox mount --bind /NativeSD/${2}/system /system\n" >> /tmp/mountfs-"${1}".sh
if [ ${1} = NativeSD ]; then
echo "Modifying for ${1}"
printf "/bin/busybox mount --bind /NativeSD/${3}/data /data\n" >> /tmp/mountfs-"${1}".sh
else
printf "/bin/busybox mkdir -p /DirectData\n/bin/busybox mount -t ${mt2:-f2fs} -o noatime,nodiratime,nosuid,nodev,discard ${secondpart} /DirectData\n/bin/busybox mount --bind /DirectData/${3}/data /data\n" >> /tmp/mountfs-"${1}".sh
fi
fi
printf "%b\n" "##/system/bin/logcat -d -f /sdcard/logcat.log *:V\n# cleanup deleting /bin to free ram\n## /bin/busybox rm -rf /bin\n" >> /tmp/mountfs-"${1}".sh
fi
}
mkinitrd() {
busybox printf "%b\n" "modifying ramdisk"
###### Setting up working directory
#cp /tmp/initrd.gz /tmp/initrd_"${2}".gz
mkdir -p /tmp/work
cd /tmp/work
cp /tmp/initrd.gz /tmp/initrd_o.gz
###### Unzipping nand kernel
gzip -d -c ../initrd.gz | busybox cpio -i -d
if [ ! -d bin ]; then
mkdir bin
fi
cp /tmp/busybox /tmp/work/bin/busybox
cp /tmp/e2fsck /tmp/work/bin/e2fsck
cp /tmp/mountfs-${1}.sh /tmp/work/mountfs-${1}.sh

if [ ${mt1:-f2fs} = f2fs -o ${mt2:-f2fs} = f2fs ]; then
busybox printf "%b\n" "copying fsck for f2fs"
cp /tmp/mkfs.f2fs /tmp/work/bin/mkfs.f2fs ; cp /tmp/mkfs.f2fs /system/bin/mkfs.f2fs
cp /tmp/fsck.f2fs /tmp/work/bin/fsck.f2fs ; cp /tmp/fsck.f2fs /system/bin/fsck.f2fs
chmod 0777 /tmp/work/bin/mkfs.f2fs; chmod 0777 /system/bin/mkfs.f2fs
chmod 0777 /tmp/work/bin/fsck.f2fs; chmod 0777 /system/bin/fsck.f2fs
fi
chmod 0777 /tmp/work/mountfs-${1}.sh
chmod 0777 /tmp/work/bin/busybox
chmod 0777 /tmp/work/bin/e2fsck

###### Modifying ramdisk to not use yaffs, and use sd partitions instead.
if [ "${4}" -gt '2' ]; then
busybox sed -i '/mtd@misc/s/^/#/' /tmp/work/ueventd.*.rc
busybox sed -i '/mount yaffs2/s/^/#/
s/# #/# /g' /tmp/work/*.rc
fi
###### Checking for anything other than nand is to be installed
if [ "${4}" -gt '1' ]; then
busybox sed -i "/on fs/ a exec /mountfs-${1}.sh" /tmp/work/*.rc
chmod 0750 /tmp/work/init*.rc
chmod 0644 /tmp/work/ueventd.*.rc
fi
###### Building new ramdisk
busybox find . | busybox cpio -o -H newc | gzip -9 > /tmp/initrd-done.gz
}
mkinitrdduo() {
mkdir -p /tmp/work/ing
mkdir -p /tmp/work/ramd
cd /tmp
./unpackbootimg /tmp/boot.img /tmp/work/
cd /tmp/work/ing
## Setting up working directory
cp /tmp/boot.img-ramdisk.gz /tmp/work/initrd.gz
## Unzipping nand kernel
gzip -d -c ../initrd.gz | busybox cpio -i -d
chmod 777 sbin
chmod 777 sbin/ramdisk.cpio
cp /tmp/work/ing/sbin/ramdisk.cpio /tmp/work/ramd
cd /tmp/work/ramd
busybox cpio -i -d < ramdisk.cpio
rm ramdisk.cpio
mkdir bin
cp /tmp/busybox bin/busybox
cp /tmp/e2fsck bin/e2fsck
cp /tmp/mountfs.sh /tmp/work/ramd/
chmod 0777 mountfs.sh
chmod 0777 bin/busybox
chmod 0777 bin/e2fsck
## Modifying ramdisk to not use fstab, and use mountfs.sh instead.
busybox sed -i '/mount_all/s/^/#/' init*.rc
busybox sed -i "s/rOm/$ROM_NAME/g" mountfs-${type}.sh
busybox sed -i '/on fs/ a exec /mountfs.sh' init*.rc
chmod 0750 init*.rc
busybox find .| busybox cpio -o -H newc > newramdisk.cpio
cp /tmp/ramd/newramdisk.cpio /tmp/work/ing/sbin/ramdisk.cpio
chmod 750 /tmp/work/ing/sbin/ramdisk.cpio
chmod 750 /tmp/work/ing/sbin
cd /tmp/work/ing
# Building new ramdisk
busybox find .| busybox cpio -o -H newc | gzip -9 > ../boot.img-ramd.gz
cd /
}
initrdcp() {
busybox printf "%b\n" "copying ramdisk"
###### Checking bootloader
if [ ${bootloader} != cLK ]; then
###### Checking zImage type
if [ -f /tmp/zImage ]; then
`hexdump /tmp/zImage | grep '1f 8b 08'` > /tmp/zI.txt
if grep -q 00003f80 "/tmp/zI.txt"; then
dd if=/dev/zero of=/tmp/6MB bs=1M count=6
fi
fi
cat /tmp/initrd-done.gz >> /tmp/6MB; cp /tmp/6MB /tmp/initrd.gz
else
cp /tmp/initrd-done.gz /tmp/initrd.gz
fi
cp /tmp/initrd.gz /boot/initrd.gz; cp /tmp/zImage /boot/zImage; cp /tmp/initrd.gz /boot_dir/initrd.gz; cp /tmp/zImage /boot_dir/zImage
}
bootflash() {
busybox printf "%b\n" "flashing boot"
chmod 0755 /tmp/mkbootimg
base=` cat /tmp/boot.img-base `
base=${base:-0x11800000}
cd /tmp
./mkbootimg --base "${base}" --cmdline "`cat /tmp/boot.img-cmdline`" --kernel /boot/zImage --ramdisk /boot/initrd.gz -o /tmp/boot.img
cd /
cp /tmp/boot.img /boot_dir/boot.img
if [ ${install_type} -gt '2' ] && [ -b /sboot ]; then
boot=sboot
else
boot=boot
fi
chmod 0777 /tmp/flash_image
cd /tmp
./flash_image "${boot}" /tmp/boot.img
cd /
}
revertinitrd() {
busybox printf "%b\n" "reverting ramdisk in /tmp"
cp /tmp/initrd_o.gz /tmp/initrd.gz
}
showresult() {
busybox printf "Ramdisk successfully modified for ${ROM_NAME} running as ${type}\non ${mt1:-f2fs} with data on ${mt2:-f2fs}\nThe install folder is ${2}_${1}\n"
if [ -f /tmp/zI.txt ]; then
if grep -q 00003f80 /tmp/zI.txt; then
busybox printf "%b\n" "Kernel is a 3.0.x kernel"
else
busybox printf "%b\n" "Kernel is a 2.x kernel"
fi
fi
if [ -f /sdcard/${2}_${1}.zip ]; then
busybox printf "%b\n" "Please flash ${2}_${1}.zip in recovery"
fi
}
exiterr() {
echo "command failed" ; exit 1;
}
runn() {
bootloadercheck || exiterr
mntstuff "$@"
if [ "${bootloader}" = cLK ]; then
bootorig || exiterr
fi
installsystem=` busybox find /sdcard -name *.zip | grep ${2}`
if [ -n "${installsystem}" ]; then
systeminstall "$@" || exiterr
fi
if [ "$bootloader" = "haret" ]; then
###not sure on this ###
haretstuff < clrcad.exe haret.exe || exiterr
fi
if [ ! -f /tmp/initrd.gz ]; then
bootingred "$@" || exiterr
fi
mkmountcheck "$@"
mkinitrd "$@" || exiterr
initrdcp || exiterr
if [ ${bootloader} = cLK ]; then
bootflash
fi
# revertinitrd || exiterr
showresult "$@" || exiterr
}
mkmountcheck() {
if [ ! -f /tmp/mountfs-"${1}".sh ]; then
echo "making mountfs.sh for $type"
if echo ${1} | grep -q porta; then
mkmountfsloop "$@" || exiterr
else
mkmountfs "$@" || exiterr
fi
fi
}
mntstuff() {
mkdirs $@
if echo ${1} | grep -q "porta"; then
looppartnames $@
mkloopdev $@
else
partnames $@
fi
if [ ${1} != "NAND" ]; then
mountpart $@
fi
}
modifyramdisk() {
if grep -q Ubuntu /proc/version; then
bootloader
else
bootloadercheck
fi
mntstuff $@
bootingred $@
mkmountcheck $@
mkinitrd $@
initrdcp $@
}
flashbootpart() {
bootingred $@
bootflash $@
}
findit() {
busybox find $1 -name $2
}
remtxt() {
rmfile=` cat /tmp/removerc.txt | busybox awk '{print $(NF)}' `
startrm=` cat /tmp/removerc.txt | busybox awk '{print $(NF-1)}' `
endrm=` cat /tmp/removerc.txt | busybox awk '{print $(NF-2)}' `
grep -lrIZ $p $currdir/$rmfile | busybox xargs -0 busybox sed --in-place "/$startrm/,/$endrm/d"
}
haretstuff() {
for i in $@; do zz=`findit inc $i`; sdsd=`findit tmp $i`
hrtstff=${zz:-$sdsd}
if [ -n ${hrtstff} ]; then
cp ${hrtstff} /boot_dir
fi
done
printf "set mtype 2524\nset ramaddr 0x11800000\nset ramsize 0x1e400000\nset initrd_offset 0x00a00000\nset KERNEL zImage\nset initrd initrd.gz\nset cmdline \"rel_path=NativeSD bootloader=haret\"\nboot\n" > /boot_dir/startup.txt
bootloader=MAGLDR
}
redir() {
if [ $# -gt 0 ]; then
nil="> /dev/null"; err="2> /dev/null"; logg=">> /tmp/` echo ${0} | busybox cut -d \".\" -f \"1\" `run.log"
eval ${1}
fi
}
installsystem() {
systeminstall ${@}
}
umountstuff() {
if [ ${alreadyranums:-no} = "no" ]; then
if echo ${@} | grep -q "porta"; then
umount /data
umount /system
umount /cache
looppartnames
losetup -d ${firstpart}
losetup -d ${secondpart}
losetup -d ${thirdpart}
alreadyranums=yes
fi
else
if [ ${systemunzip} != "y" ]; then
umount /boot
umount /boot_dir
umount /NativeSD
umount /DirectData
umount /system
umount /data
umount /cache
if echo ${type} | grep -q "porta"; then
losetup -d ${firstpart}
losetup -d ${secondpart}
losetup -d ${thirdpart}
fi
fi
fi
}
desktopcheck() {
if [ ${alreadyrandc:-no} = "no" ]; then
if grep -q Ubuntu /proc/version; then
ln -s ${currdir}/sdcard /
ln -s ${currdir}/tmp /
else
mkdir /tmp
fi
alreadyrandc=yes
else
if grep -q Ubuntu /proc/version; then
rm -rf /tmp/work/*
rm -rf /sdcard
fi
fi
}
currdir=$(pwd)
desktopcheck
cleanup "$@"
chmod 0777 /sdcard/bins/*
cp /sdcard/bins/* /tmp
umountstuff "$@"
testing "$@"
umountstuff "$@"
desktopcheck
exit 0

Yea I've seen your edits. I'm convinced that /sdcard isn't mounted. The porta stuff is running fine (for testing I set the size to 20000 count (~80MB) If the sdcard was mounted it would be set to the unzipped size of the zip).

And just a heads up as the script exited early the porta loops might still be attached - may only be an issue if you run the script with a different type, running porta again (rebooting the device) or manually removing them should clear them ( run mount if loops are attached to to /data then umount /data and losetup -d /dev/block/loop2 )