[HD2 Android Q&A, Help & Troubleshooting and Genera] HypoTurtle:
Personally I would steer clear of f2fs with /system for the moment - I'm not sure how it plays with the added security stuff with KK, especially as extended flags don't seem to working at the moment (could be due to the f2fs stuff being backported from 3.2+).

The original code setup was that: ROM.zip duplicated to ROM-test.zip - zip extracted (system to mounted /system; data to mounted /data META-INF to /META-INF ...) then updater-script scanned for symlink entries, (I may have overlooked setperms.) and setmetadata - to create a new updater-script (essentially to strip it of aroma stuff). And then this added to the ROM-test.zip replacing the original updater-script and system and data folders removed to reduce size. With the ROM-test.zip needed to create symlinks/permissions.

The last one I posted (which I believe you used) - has : ROM.zip copied to ROM-test.zip data and system folders removed, then unzipped (to get the META-INF folder), again scanned for symlink/metadata stuff. ROM.zip copied again to ROM-test.zip, then updater-script added to replace the original. With the final ROM-test.zip extracting system, data and sets perms/symlinks as before.

Probably should remove the first ROM-test.zip, as that might be whats causing a clash with the two wildcards **

systeminstall() {
echo "installing system"
cd /
# rm -rf /system/*
cp /sdcard/*"${1}"*.zip /sdcard/"${1}"test.zip
/tmp/7za d /sdcard/"${1}"test.zip system/*
/tmp/7za d /sdcard/"${1}"test.zip data/*
chmod 0777 /tmp/7za
/tmp/7za x /sdcard/"${1}"test.zip -y > /dev/null
cp /sdcard/"${1}"test.zip /sdcard/IsThis10MB.zip
rm /sdcard/"${1}"test.zip
cp /sdcard/*"${1}"*.zip /sdcard/"${1}"test.zip
cp /META-INF/com/google/android/update-binary-installer /META-INF/com/google/android/update-binary
echo "package_extract_dir("system", "/system");
package_extract_dir("data", "/data");" > /tmp/updater-script
##cat '/META-INF/com/google/android/updater-script' | sed -e '/assert(/,/);/!d' > /tmp/updater-script
cat '/META-INF/com/google/android/updater-script' | sed -e '/symlink(/,/);/!d' >> /tmp/updater-script
cat '/META-INF/com/google/android/updater-script' | sed -e '/setmetadata(/,/);/!d' >> /tmp/updater-script
echo "modifying updater-script"
echo "umount /NativeSD\
umount /DirectSD\
umount /system\
umount /data\
umount /boot\
umount /system\
umount /boot_dir" >> /tmp/updater-script
cp /tmp/updater-script /META-INF/com/google/android/updater-script
/tmp/7za a /sdcard/"${1}"test.zip META-INF/
}

Edit. I think the $1 was causing the problem here actually.

#!/sbin/sh
testing() {
echo "TESTING MODE"
types="NAND DataOnExt NativeSD DirectSD"
typecheck=`echo "$types" | grep $1`
if [ -z "${typecheck}" ]; then
echo "$1 is not a valid type - choices are $types"
exit 0
fi
if [ -z "$2" ]; then
echo "no type or ROM name specified"
echo "usage sh multiboot.sh [type] [ROM_NAME]"
echo "type can be ${types}, ROM_NAME to be taken from rOm.zip"
exit 0
else
echo "ROM_NAME=$2"
fi
cp /sdcard/bins/* /tmp
}
cleanup() {
echo "cleaning"
rm -rf mt2.txt zI.txt bootimg.txt updater-script "$1"test.zip
}
partnames() {
sdpart=/dev/block/mmcblk0p1
firstpart=/dev/block/mmcblk0p2
secondpart=/dev/block/mmcblk0p3
echo "setting partitions with ${firstpart} format"
}
looppartnames() {
sdpart=/dev/block/platform/msm_sdcc.1/by-name/userdata/media/0
firstpart=/dev/block/loop1
secondpart=/dev/block/loop2
echo "setting partitions with ${firstpart} format"
}
getpropfile() {
if [ ! -d /tmp/sdcard ]; then
mkdir /tmp/sdcard
fi
mount ${sdpart} /tmp/sdcard
if [ -f "/tmp/sdcard/installtype.prop" ]; then
if [ -z `cut -d ' ' -f '3' /tmp/sdcard/installtype.prop` ]; then
type=` cat /tmp/sdcard/installtype.prop | awk '{print $(NF)}' | sed 's/\(\[\|\]\)//g' `
ROM_NAME=` cat /tmp/sdcard/installtype.prop | awk '{print $(NF-1)}' | sed 's/\(\[\|\]\)//g' `
data_NAME=${ROM_NAME}
else
data_NAME=` cat /tmp/sdcard/installtype.prop | awk '{print $(NF)}' | sed 's/\(\[\|\]\)//g' `
type=` cat /tmp/sdcard/installtype.prop | awk '{print $(NF-1)}' | sed 's/\(\[\|\]\)//g' `
ROM_NAME=` cat /tmp/sdcard/installtype.prop | awk '{print $(NF-2)}' | sed 's/\(\[\|\]\)//g' `
fi
else
echo "no installtype.prop on sdcard - exitting"
exit 0
fi
umount /tmp/sdcard
}
bootloadercheck() {
echo "checking bootloader"
bootloader=MAGLDR
output=`grep -i "clk" /proc/cmdline`
if [ -n "${output}" ]; then
bootloader=cLK
fi
}
bootloader() {
bootloader=cLK
}
exportvar() {
echo "allocating numbered value"
## Changing install_type to numbered value
if [ $1 = NAND ]; then
install_type=1
fi
if [ $1 = DataOnExt ]; then
install_type=2
fi
if [ $1 = NativeSD ]; then
install_type=3
fi
if [ $1 = DirectSD ]; then
install_type=4
fi
}
mkdirs() {
echo "creating directories"
if [ ! -d /NativeSD ]; then
mkdir -p /NativeSD
fi
if [ ! -d /DirectSD ]; then
mkdir -p /DirectSD
fi
if [ ! -d /boot_dir ]; then
mkdir -p /boot_dir
fi
if [ ! -d /boot ]; then
mkdir -p /boot
fi
if [ ! -d /system ]; then
mkdir -p /system
fi
if [ ! -d /data ]; then
mkdir -p /data
fi
if [ ! -d /sdcard/NativeSD/"${ROM_NAME}" ]; then
mkdir -p /sdcard/NativeSD/"${ROM_NAME}"
fi
if [ ! -d /sdcard/NativeSD/"${ROM_NAME}"-new ]; then
mkdir -p /sdcard/NativeSD/"${ROM_NAME}"-new
fi
}
mountpart() {
A=$1
B=$2
C=$3
echo "mounting files"
if [ -b '${firstpart}' ]; then
busybox mount -t auto ${firstpart} /NativeSD
if [ $A = NativeSD ] || [ $A = DataOnExt ]; then
if [ ! -d /NativeSD/$C/data ]; then
mkdir -p /NativeSD/$C/data
fi
busybox mount --bind /NativeSD/$C/data /data
fi
if [ ${install_type} -gt '2' ]; then
if [ ! -d /NativeSD/$B/system ]; then
mkdir -p /NativeSD/$B/system
fi
busybox mount --bind /NativeSD/$B/system /system
fi
fi
sdmounted=`mount | grep "${sdpart} on /sdcard"`
if [ -z '${sdmounted}' ]; then
busybox mount -t auto ${sdpart} /sdcard
fi
busybox mount --bind /sdcard/NativeSD /boot_dir
busybox mount --bind /sdcard/NativeSD/$B-new /boot
if [ -b '${secondpart}' ]; then
busybox mount -t auto ${secondpart} /DirectSD
if [ $A = DirectSD ]; then
if [ ! -d /DirectSD/$C/data ]; then
mkdir -p /DirectSD/$C/data
fi
busybox mount --bind /DirectSD/$C/data /data
fi
fi
}
bootorig() {
echo "saving original boot.img to boot-orig folder"
mkdir /boot_dir/boot-orig/
chmod 0777 /tmp/dump_image
/tmp/dump_image boot /boot/boot-orig/boot.img
}
systeminstall() {
A=$1
echo "installing system"
cd /
# rm -rf /system/*
cp /sdcard/*"${A}"*.zip /sdcard/"${A}"test.zip
/tmp/7za d /sdcard/"${A}"test.zip system/*
/tmp/7za d /sdcard/"${A}"test.zip data/*
chmod 0777 /tmp/7za
/tmp/7za x /sdcard/"${A}"test.zip -y > /dev/null
cp /sdcard/"${A}"test.zip /sdcard/IsThis10MB.zip
rm /sdcard/"${A}"test.zip
cp /sdcard/*"${A}"*.zip /sdcard/"${A}"test.zip
cp /META-INF/com/google/android/update-binary-installer /META-INF/com/google/android/update-binary
echo "package_extract_dir("system", "/system");
package_extract_dir("data", "/data");" > /tmp/updater-script
##cat '/META-INF/com/google/android/updater-script' | sed -e '/assert(/,/);/!d' > /tmp/updater-script
cat '/META-INF/com/google/android/updater-script' | sed -e '/symlink(/,/);/!d' >> /tmp/updater-script
cat '/META-INF/com/google/android/updater-script' | sed -e '/setmetadata(/,/);/!d' >> /tmp/updater-script
echo "modifying updater-script"
echo "umount /NativeSD\
umount /DirectSD\
umount /system\
umount /data\
umount /boot\
umount /system\
umount /boot_dir" >> /tmp/updater-script
cp /tmp/updater-script /META-INF/com/google/android/updater-script
/tmp/7za a /sdcard/"${A}"test.zip META-INF/
}
bootingred() {
echo "obtaining an initrd.gz and zImage to work with"
###### Copying zImage and initrd.gz from /boot_dir when one wasn't in the zip
if [ ! -e "boot.img" ]; then
cp zImage /tmp/zImage
cp initrd.gz /tmp/initrd.gz
else
chmod 0777 /tmp/unpackbootimg
cp boot.img /tmp/boot.img
/tmp/unpackbootimg /tmp/boot.img /tmp > /tmp/bootimg.txt
cp /tmp/boot.img-ramdisk.gz /tmp/initrd.gz
fi
if [ -f /sdcard/zImage ]; then
cp /sdcard/zImage /tmp/zImage
cp /sdcard/modules/* /system/lib/modules/
fi
if [ -f /sdcard/initrd.gz ]; then
cp /sdcard/initrd.gz /tmp/initrd.gz
fi
}
usecurrentboot() {
chmod 0777 /tmp/dump_image
/tmp/dump_image boot /tmp/boot.img
/tmp/unpackbootimg /tmp/boot.img /tmp > /tmp/bootimg.txt
cp /tmp/boot.img-ramdisk.gz /tmp/initrd.gz
cp /tmp/boot.img-zImage /tmp/zImage
}
mkmountfs() {
A=$1
B=$2
C=$3
D=$4
echo "creating mountfs.sh"
if [ ${B} -gt '1' ]; then
echo "#!/bin/busybox sh
# wait for 2nd partition ready
wait ${firstpart}
wait ${firstpart}
wait ${firstpart}
wait ${firstpart}
wait ${firstpart}" > /tmp/mountfs-'${type}'.sh
if [ ${A} = DirectSD ]; then
echo "Modifying for ${type}"
echo "# wait for 3rd partition ready
wait ${secondpart}
wait ${secondpart}
wait ${secondpart}
wait ${secondpart}
wait ${secondpart}" >> /tmp/mountfs-'${type}'.sh
fi
mt1=` blkid ${firstpart} | cut -d '"' -f '4' `
# mt1=` hexdump -C ${firstpart} | head -30 | grep 'f2fs' `
if [ -n "${mt1}" ]; then
mot1=f2fs
else
mot1=ext4
fi
if [ ${mot1} = ext4 ]; then
echo "# check the ext4 fs
/bin/e2fsck -p ${firstpart} > /e2fsck.log" >> /tmp/mountfs-'${A}'.sh
else
echo "# check the f2fs fs
/bin/fsck.f2fs -p ${firstpart} > /fsckf2fs.log" >> /tmp/mountfs-'${A}'.sh
fi
if [ ${A} = DirectSD ]; then
if [ -b ${secondpart} ]; then
# mt2=` hexdump -C ${secondpart} | head -30 | grep 'f2fs' `
mt2=` blkid ${secondpart} | cut -d '"' -f '4' `
else
echo "No 2nd ext partition present, format one and run script again"
fi
if [ -n "${mt2}" ]; then
mot2=f2fs
else
mot2=ext4
fi
if [ ${mot2} = ext4 ]; then
echo "# check the ext4 fs
/bin/e2fsck -p ${secondpart} > /e2fsck.log" >> /tmp/mountfs-'${A}'.sh
else
echo "# check the f2fs fs
/bin/fsck.f2fs -p ${secondpart} > /fsckf2fs.log" >> /tmp/mountfs-'${A}'.sh
fi
fi
echo "/bin/busybox mkdir -p /NativeSD
/bin/busybox mount -t ${mot1} -o ro,noatime,nodiratime,barrier=0 ${firstpart} /NativeSD
# mount the system data app dir" >> /tmp/mountfs-'${A}'.sh
if [ ${A} = DataOnExt ]; then
echo "Modifying for ${A}"
echo "/bin/busybox mount --bind /NativeSD/${C}/data /data" >> /tmp/mountfs-'${A}'.sh
fi
if [ ${B} -gt '2' ]; then
echo "/bin/busybox mount --bind /NativeSD/${C}/system /system" >> /tmp/mountfs-'${A}'.sh
if [ ${A} = NativeSD ]; then
echo "Modifying for ${A}"
echo "/bin/busybox mount --bind /NativeSD/${D}/data /data" >> /tmp/mountfs-'${A}'.sh
else
echo "/bin/busybox mkdir -p /DirectData
/bin/busybox mount -t ${mot2} -o noatime,nodiratime,nosuid,nodev,discard ${secondpart} /DirectData
/bin/busybox mount --bind /DirectData/${D}/data /data" >> /tmp/mountfs-'${A}'.sh
fi
fi
echo "# cleanup\
# delete /bin to free ram
/bin/busybox rm -rf /bin" >> /tmp/mountfs-'${A}'.sh
fi
}
mkinitrd() {
echo "modifying ramdisk"
###### Setting up working directory
cp /tmp/initrd.gz /tmp/initrd-${ROM_NAME}.gz
mkdir -p /tmp/work
cd /tmp/work

###### Unzipping nand kernel
gzip -d -c ../initrd-${ROM_NAME}.gz | cpio -i -d
if [ ! -d bin ]; then
mkdir bin
fi
cp /sbin/busybox /tmp/work/bin/busybox
cp /sbin/e2fsck /tmp/work/bin/e2fsck
cp /tmp/mountfs-'${type}'.sh /tmp/work/mountfs-'${type}'.sh

if [ ${mot1} = f2fs ] || [ ${mot2} = f2fs ]; then
echo "copying fsck for f2fs"
cp /sbin/fsck.f2fs /tmp/work/bin/fsck.f2fs
chmod 0777 /tmp/work/bin/fsck.f2fs
fi
chmod 0777 /tmp/work/mountfs-'${type}'.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 [ "${install_type}" -gt '2' ]; then
sed -i '/mtd@misc/s/^/#/' /tmp/work/ueventd.*.rc
sed -i '/mount yaffs2/s/^/#/
s/# #/# /g' /tmp/work/*.rc
fi
###### Checking for anything other than nand is to be installed
if [ "${install_type}" -gt '1' ]; then
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
find . | cpio -o -H newc | gzip -9 > /tmp/initrd-done.gz
}
mkinitrdduo() {
mkdir -p /tmp/work/ing
mkdir -p /tmp/work/ramd
/tmp/unpackbootimg /tmp/boot.img /tmp/work/
## Setting up working directory
cp /tmp/boot.img-ramdisk.gz /tmp/work/initrd.gz
## Unzipping nand kernel
gzip -d -c ../initrd.gz | 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
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.
sed -i '/mount_all/s/^/#/' init*.rc
sed -i "s/rOm/$ROM_NAME/g" mountfs-${type}.sh
sed -i '/on fs/ a exec /mountfs.sh' init*.rc
chmod 0750 init*.rc
find .| 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
find .| cpio -o -H newc | gzip -9 > ../boot.img-ramd.gz
}
initrdcp() {
echo "copying ramdisk"
###### Checking bootloader
cd /tmp
if [ ${bootloader} != cLK ]; then
###### Checking zImage type
if [ -f zImage ]; then
hexdump -C zImage | grep '1f 8b 08' > zI.txt
if grep -q 00003f80 "zI.txt"; then
dd if=/dev/zero of=/tmp/6MB bs=1M count=6
fi
fi
cat /tmp/initrd-done.gz >> 6MB
cp 6MB /boot_dir/"${ROM_NAME}"-new/initrd.gz
cp zImage /boot_dir/"${ROM_NAME}"-new/zImage
else
cp /tmp/initrd-done.gz /tmp/initrd.gz
if [ "${install_type}" -gt '2' ]; then
cp /tmp/initrd.gz /boot/initrd.gz
cp /tmp/zImage /boot/zImage
fi
fi
}
bootflash() {
echo "flashing boot"
cd /tmp
chmod 0755 mkbootimg
base=`cat /tmp/bootimg.txt | grep 'base' | cut -d ' ' -f '9'`
/tmp/mkbootimg --base "${base}" --cmdline "`cat /tmp/boot.img-cmdline`" --kernel /boot_dir/${ROM_NAME}-new/zImage --ramdisk /boot_dir/${ROM_NAME}-new/initrd.gz -o /tmp/boot.img
if [ ${install_type} -gt '2' ] && [ -b /sboot ]; then
boot=sboot
else
boot=boot
fi
chmod 0777 /tmp/flash_image
/tmp/flash_image "${boot}" /tmp/boot.img
}
revertinitrd() {
echo "reverting ramdisk in /tmp"
cd /
cp /tmp/initrd-"${ROM_NAME}".gz /tmp/initrd.gz
}
showresult() {
echo "Ramdisk successfully modified for ${ROM_NAME} running as ${type} on ${mot1}"
if [ -n "$mot2" ]; then
echo "with data on ${mot2}"
fi
echo "The install folder is ${ROM_NAME}-new"
if [ -f tmp/zI.txt ]; then
if grep -q 00003f80 tmp/zI.txt; then
echo "kernel used is a 3.0.x kernel"
else
echo "kernel used is a 2.x kernel"
fi
fi
if [ -f /sdcard/"${ROM_NAME}"test.zip ]; then
echo "Please flash "${ROM_NAME}"test.zip in recovery"
fi
}
exiterr() {
echo "command failed"; exit 1;
}
runn() {
if [ -n $1 ]; then
testing $type $ROM_NAME || exiterr
else
getpropfile || exiterr
fi
cleanup $ROM_NAME || exiterr
partnames || exiterr
echo "0 0 0 0 0 0 0 0 0x11800000" > /tmp/bootimg.txt
bootloadercheck || exiterr
exportvar $type || exiterr
mkdirs || exiterr
if [ "${install_type}" -gt '1' ]; then
mountpart $type $ROM_NAME $data_NAME || exiterr
fi
if [ "${bootloader}" = cLK ]; then
bootorig || exiterr
fi
installsystem=`find '/sdcard' -name '*.zip' | grep ${ROM_NAME}`
if [ -n "${installsystem}" ]; then
systeminstall $ROM_NAME || exiterr
fi
if [ ! -f /tmp/initrd.gz ]; then
bootingred || exiterr
fi
if [ ! -f /tmp/mountfs-'${1}'.sh ]; then
mkmountfs $type $installtype $ROM_NAME $data_NAME || exiterr
fi
mkinitrd $type || exiterr
initrdcp || exiterr
if [ ${bootloader} = cLK ]; then
bootflash || exiterr
fi
# revertinitrd || exiterr
showresult || exiterr
}
type=${1}
ROM_NAME=${2}
data_NAME=${3}
if [ -z ${data_NAME} ]; then
data_NAME=${2}
fi
set -u
runn ${type}
cp /tmp/mountfs-'${type}'.sh /sdcard/testrun.txt
cat /tmp/work/init.rc >> /sdcard/testrun.txt
exit 0