#!/bin/bash # Common function for test # Expect should be installed for SSH Testing # To execute `runqemu`, NOPASSWD needs to be set in /etc/sudoers for user # For example, for user "builder", /etc/sudoers can be like following: # ######### # #Members of the admin group may gain root privileges # %builder ALL=(ALL) NOPASSWD: NOPASSWD: ALL # ######### # # Author: Jiajun Xu <jiajun.xu@intel.com> # # This file is licensed under the GNU General Public License, # Version 2. # TYPE="ext3" # The folder to hold all scripts running on targets TOOLS="$COREBASE/scripts/qemuimage-tests/tools" # The folder to hold all projects for toolchain testing TOOLCHAIN_PROJECTS="$COREBASE/scripts/qemuimage-tests/toolchain_projects" # Test Directory on target for testing TARGET_TEST_DIR="/opt/test" # Global variable for process id PID=0 # Global variable for target ip address TARGET_IPADDR=0 # Global variable for test project version during toolchain test # Version of cvs is 1.12.13 # Version of iptables is 1.4.11 # Version of sudoku-savant is 1.3 PROJECT_PV=0 # Global variable for test project download URL during toolchain test # URL of cvs is http://ftp.gnu.org/non-gnu/cvs/source/feature/1.12.13/cvs-1.12.13.tar.bz2 # URL of iptables is http://netfilter.org/projects/iptables/files/iptables-1.4.11.tar.bz2 # URL of sudoku-savant is http://downloads.sourceforge.net/project/sudoku-savant/sudoku-savant/sudoku-savant-1.3/sudoku-savant-1.3.tar.bz2 PROJECT_DOWNLOAD_URL=0 # SDK folder to hold toolchain tarball TOOLCHAIN_DIR="${DEPLOY_DIR}/sdk" # Toolchain test folder to hold extracted toolchain tarball TOOLCHAIN_TEST="/opt" # common function for information print Test_Error() { echo -e "\tTest_Error: $*" } Test_Info() { echo -e "\tTest_Info: $*" } # function to update target ip address # $1 is the process id of the process, which starts the qemu target # $2 is the ip address of the target Test_Update_IPSAVE() { local pid=$1 local ip_addr=$2 if [ "$TEST_SERIALIZE" -eq 1 ]; then echo "$pid $ip_addr" > $TARGET_IPSAVE fi } # function to copy files from host into target # $1 is the ip address of target # $2 is the files, which need to be copied into target # $3 is the path on target, where files are copied into Test_SCP() { local ip_addr=$1 local src=$2 local des=$3 local tmpfile=`mktemp` local timeout=60 local ret=0 # We use expect to interactive with target by ssh local exp_cmd=`cat << EOF eval spawn scp -o UserKnownHostsFile=$tmpfile "$src" root@$ip_addr:"$des" set timeout $time_out expect { "*assword:" { send "\r"; exp_continue} "*(yes/no)?" { send "yes\r"; exp_continue } eof { exit [ lindex [wait] 3 ] } } EOF` expect=`which expect` if [ ! -x "$expect" ]; then Test_Error "ERROR: Please install expect" return 1 fi expect -c "$exp_cmd" ret=$? rm -rf $tmpfile return $ret } # function to run command in $ip_addr via ssh Test_SSH() { local ip_addr=$1 shift local command=$@ local tmpfile=`mktemp` local timeout=60 local ret=0 local exp_cmd=`cat << EOF eval spawn ssh -o UserKnownHostsFile=$tmpfile root@$ip_addr "$command" set timeout $time_out expect { "*assword:" { send "\r"; exp_continue} "*(yes/no)?" { send "yes\r"; exp_continue } eof { exit [ lindex [wait] 3 ] } } EOF` expect=`which expect` if [ ! -x "$expect" ]; then Test_Error "ERROR: Please install expect" return 1 fi expect -c "$exp_cmd" ret=$? rm -rf $tmpfile return $ret } # function to check if ssh is up in $ip_addr Test_SSH_UP() { local ip_addr=$1 local timeout=$2 local interval=0 # If TEST_SERIALIZE is set, use existing running qemu for testing if [ ${TEST_SERIALIZE} -eq 1 -a -e ${TARGET_IPSAVE} ]; then timeout=50 fi while [ ${interval} -lt ${timeout} ] do Test_SSH ${ip_addr} "hostname" if [ $? -ne 0 ]; then interval=`expr $interval + 10` sleep 10 else Test_Info "We can ssh on ${ip_addr} within ${interval} seconds" return 0 fi done Test_Info "We can not ssh on ${ip_addr} in ${timeout} seconds" return 1 } # function to prepare target test environment # $1 is the ip address of target system # $2 is the files, which needs to be copied into target Test_Target_Pre() { local ip_addr=$1 local testscript=$2 # Create a pre-defined folder for test scripts Test_SSH $ip_addr "mkdir -p $TARGET_TEST_DIR" if [ $? -eq 0 ]; then # Copy test scripts into target Test_SCP $ip_addr $testscript $TARGET_TEST_DIR && return 0 else Test_Error "Fail to create $TARGET_TEST_DIR on target" return 1 fi return 1 } # function to record test result in $TEST_RESULT/testresult.log Test_Print_Result() { local PASS=0 local FAIL=0 local NORESULT=0 if [ $2 -eq 0 ]; then PASS=1 elif [ $2 -eq 1 ]; then FAIL=1 else NORESULT=1 fi # Format the output of the test result echo -e "$1 $PASS $FAIL $NORESULT" | awk '{printf("\t"); for(i=1;i<=NF;i++) printf("%-15s",$i); printf("\n");}' >> $TEST_RESULT/testresult.log } # Test_Kill_Qemu to kill child pid with parent pid given # $1 is qemu process id, which needs to be killed Test_Kill_Qemu() { local ret=0 local ppid=0 local i=0 local index=0 local total=0 declare local pid # Check if $1 pid exists and is a qemu process ps -fp $PID | grep -iq "qemu" # Find all children pid of the pid $1 if [ $? -eq 0 ]; then # Check if there is any child pid of the pid $PID ppid=$PID ps -f --ppid $ppid ret=$? while [ $ret -eq 0 ] do # If yes, get the child pid and check if the child pid has other child pid # Continue the while loop until there is no child pid found pid[$i]=`ps -f --ppid $ppid | awk '{if ($2 != "PID") print $2}'` ppid=${pid[$i]} i=$((i+1)) ps -f --ppid $ppid ret=$? done # When TEST_SERIALIZE is set, qemu process will not be # killed until all the cases are finished if [ ${TEST_SERIALIZE} -eq 1 -a -e ${TEST_STATUS} ]; then index=`sed -n 2p ${TEST_STATUS} | awk '{print $3}'` total=`sed -n 2p ${TEST_STATUS} | awk '{print $4}'` if [ ${index} != ${total} ]; then Test_Info "Do not kill the qemu process and use it for later testing" Test_Update_IPSAVE $PID $TARGET_IPADDR else # If it is the last case, let's kill it while [ $i -ne 0 ] do i=$((i-1)) kill ${pid[$i]} sleep 2 done # Kill the parent id kill $PID fi else # Kill these children pids from the last one while [ $i -ne 0 ] do i=$((i-1)) kill ${pid[$i]} sleep 2 done # Kill the parent id kill $PID fi fi return } # function to check if there is any qemu process Test_Check_Qemu_UP() { local count=`ps -eo command | cut -d " " -f 1 | grep -c "\(^qemu\|.*/qemu\)"` if [ ${count} -lt 1 ]; then Test_Info "There is no Qemu process" return 1 else Test_Info "There is at least one Qemu process running" return 0 fi } # function to check if network is up Test_Check_IP_UP() { ping -c1 $1 if [ $? -ne 0 ]; then Test_Info "IP $1 is not up" return 1 else Test_Info "IP $1 is up" return 0 fi } # function to find kernel/rootfs image Test_Find_Image() { where="" kernel="" arch="" target="" extension="" rootfs="" while getopts "l:k:a:t:" Option do case $Option in l) where="$OPTARG" ;; k) kernel="$OPTARG" extension="bin" ;; a) arch="$OPTARG" ;; t) target="$OPTARG" extension="ext3" ;; *) echo "invalid option: -$Option" && return 1 ;; esac done if [ ! -z $kernel ]; then if [ -L ${where}/${kernel}-${arch}.${extension} ]; then echo ${where}/${kernel}-${arch}.${extension} return 0 else for i in `dir ${where}` do # Exclude qemux86-64 when target is qemux86 echo $i | grep "${kernel}.*${arch}.*\.${extension}" | grep -qv "${kernel}.*${arch}-64.*\.${extension}" if [ $? -eq 0 ]; then echo ${where}/${i} return 0 fi done return 1 fi fi if [ ! -z $target ]; then if [ -L ${where}/${target}-${arch}.${extension} ]; then rootfs=`readlink -f ${where}/${target}-${arch}.${extension}` echo ${rootfs} return 0 else for i in `dir ${where}` do # Exclude qemux86-64 when target is qemux86 echo $i | grep "${target}-${arch}.*\.${extension}" | grep -qv "${target}-${arch}-64.*\.${extension}" if [ $? -eq 0 ]; then echo ${where}/${i} return 0 fi done return 1 fi fi return 1 } # function to parse IP address of target # $1 is the pid of qemu startup process Test_Fetch_Target_IP() { local opid=$1 local ppid=0 local ip_addr=0 local i=0 declare local pid # Check if $1 pid exists and contains ipaddr of target ps -fp $opid | grep -oq "192\.168\.7\.[0-9]*::" # Find all children pid of the pid $1 # and check if they contain ipaddr of target if [ $? -ne 0 ]; then # Check if there is any child pid of the pid $1 ppid=$opid ps -f --ppid $ppid > /dev/zero ret=$? while [ $ret -eq 0 ] do # If yes, get the child pid and check if the child pid has other child pid # Continue the while loop until there is no child pid found pid[$i]=`ps -f --ppid $ppid | awk '{if ($2 != "PID") print $2}'` ppid=${pid[$i]} i=$((i+1)) ps -f --ppid $ppid > /dev/zero ret=$? done # Check these children pids, if they have ipaddr included in command line while [ $i -ne 0 ] do i=$((i-1)) ps -fp ${pid[$i]} | grep -oq "192\.168\.7\.[0-9]*::" if [ $? -eq 0 ]; then ip_addr=`ps -fp ${pid[$i]} | grep -o "192\.168\.7\.[0-9]*::" | awk -F":" '{print $1}'` fi sleep 1 done else ip_addr=`ps -fp $opid | grep -o "192\.168\.7\.[0-9]*::" | awk -F":" '{print $1}'` fi echo $ip_addr return } # function to check if qemu and its network Test_Create_Qemu() { local timeout=$1 local ret=1 local up_time=0 which runqemu if [ $? -eq 0 ]; then RUNQEMU=`which runqemu` else Test_Error "Can not find runqemu in \$PATH, return fail" return 1 fi if [ "$QEMUARCH" = "qemux86" -o "$QEMUARCH" = "qemux86-64" ]; then KERNEL=$(Test_Find_Image -l ${DEPLOY_DIR}/images -k bzImage -a ${QEMUARCH}) elif [ "$QEMUARCH" = "qemuarm" -o "$QEMUARCH" = "spitz" -o "$QEMUARCH" = "borzoi" -o "$QEMUARCH" = "akita" -o "$QEMUARCH" = "nokia800" ]; then KERNEL=$(Test_Find_Image -l ${DEPLOY_DIR}/images -k zImage -a ${QEMUARCH}) elif [ "$QEMUARCH" = "qemumips" -o "$QEMUARCH" = "qemuppc" ]; then KERNEL=$(Test_Find_Image -l ${DEPLOY_DIR}/images -k vmlinux -a ${QEMUARCH}) fi # If there is no kernel image found, return failed directly if [ $? -eq 1 ]; then Test_Info "No kernel image file found under ${DEPLOY_DIR}/images for ${QEMUARCH}, pls. have a check" return $ret fi ROOTFS_IMAGE=$(Test_Find_Image -l ${DEPLOY_DIR}/images -t ${QEMUTARGET} -a ${QEMUARCH}) # If there is no rootfs image found, return failed directly if [ $? -eq 1 ]; then Test_Info "No ${QEMUTARGET} rootfs image file found under ${DEPLOY_DIR}/images for ${QEMUARCH}, pls. have a check" return $ret fi TEST_ROOTFS_IMAGE="${TEST_TMP}/${QEMUTARGET}-${QEMUARCH}-test.ext3" CP=`which cp` # When TEST_SERIALIZE is set, we use the existing image under tmp folder if [ ${TEST_SERIALIZE} -eq 1 -a -e "$TARGET_IPSAVE" ]; then # If TARGET_IPSAVE exists, check PID of the qemu process from it PID=`awk '{print $1}' $TARGET_IPSAVE` timeout=50 else rm -rf $TEST_ROOTFS_IMAGE echo "Copying rootfs $ROOTFS_IMAGE to $TEST_ROOTFS_IMAGE" $CP $ROOTFS_IMAGE $TEST_ROOTFS_IMAGE if [ $? -ne 0 ]; then Test_Info "Image ${ROOTFS_IMAGE} copy to ${TEST_ROOTFS_IMAGE} failed, return fail" return $ret fi export MACHINE=$QEMUARCH # Create Qemu in localhost VNC Port 1 echo "Running xterm -display ${DISPLAY} -e 'OE_TMPDIR=${OE_TMPDIR} ${RUNQEMU} ${KERNEL} ${TEST_ROOTFS_IMAGE} && /bin/sleep 60' &" xterm -display ${DISPLAY} -e "OE_TMPDIR=${OE_TMPDIR} ${RUNQEMU} ${KERNEL} ${TEST_ROOTFS_IMAGE} && /bin/sleep 60" & # Get the pid of the xterm processor, which will be used in Test_Kill_Qemu PID=$! fi while [ ${up_time} -lt 10 ] do Test_Check_Qemu_UP if [ $? -ne 0 ]; then Test_Info "Wait for qemu up..." up_time=`expr $up_time + 5` sleep 5 else Test_Info "Begin to check if qemu network is up" break fi done # Parse IP address of target from the qemu command line if [ ${up_time} -lt ${timeout} ]; then sleep 5 TARGET_IPADDR=`Test_Fetch_Target_IP $PID` # If IP address is 0, means there is no qemu process found if [ ${TARGET_IPADDR} == "0" ]; then Test_Info "There is no qemu process or qemu ip address found, return failed" return $ret fi fi while [ ${up_time} -lt ${timeout} ] do Test_Check_IP_UP ${TARGET_IPADDR} if [ $? -eq 0 ]; then Test_Info "Qemu Network is up, ping with ${TARGET_IPADDR} is OK within ${up_time} seconds" ret=0 break else Test_Info "Wait for Qemu Network up" up_time=`expr $up_time + 5` sleep 5 fi done if [ $ret -eq 0 ]; then Test_Info "Qemu and its network is up" return $ret else Test_Info "Qemu or its network is not up in ${timeout} seconds" Test_Update_IPSAVE $PID $TARGET_IPADDR return $ret fi } # Function to prepare test project for toolchain test # $1 is the folder holding test project file # $2 is the test project name Test_Project_Prepare() { local toolchain_dir=$1 local ret=1 if [ ! -d ${toolchain_dir} ]; then mkdir -p ${toolchain_dir} ret=$? if [ $ret -ne 0 ]; then Test_Info "Create ${toolchain_dir} fail, return" return $ret fi fi ret=0 # Download test project tarball if it does not exist if [ ! -f ${toolchain_dir}/${2}-${PROJECT_PV}.${suffix} ]; then wget -c -t 5 $PROJECT_DOWNLOAD_URL -O ${toolchain_dir}/${2}-${PROJECT_PV}.${suffix} ret=$? fi # Extract the test project into ${TEST_TMP} if [ $ret -eq 0 ]; then tar jxf ${toolchain_dir}/${2}-${PROJECT_PV}.${suffix} -C ${TEST_TMP} ret=$? if [ $ret -eq 0 ]; then Test_Info "Extract ${2}-${PROJECT_PV}.${suffix} into ${TEST_TMP} successfully" return $ret else Test_Info "Fail to extract ${2}-${PROJECT_PV}.${suffix} into ${TEST_TMP}" return $ret fi else Test_Info "Fail to download ${2}-${PROJECT_PV}.${suffix} from $PROJECT_DOWNLOAD_URL" rm -rf ${toolchain_dir}/${2}-${PROJECT_PV}.${suffix} return $ret fi } # Function to prepare toolchain environment # $1 is toolchain directory to hold toolchain tarball # $2 is prefix name for toolchain tarball Test_Toolchain_Prepare() { local toolchain_dir=$1 local sdk_name=$2 local ret=1 if [ ! -d ${toolchain_dir} ]; then Test_Info "No directory ${toolchain_dir}, which holds toolchain tarballs" return 1 fi # Check if there is any toolchain tarball under $toolchain_dir with prefix $sdk_name for i in `dir ${toolchain_dir}` do echo $i | grep "${sdk_name}-toolchain-gmae" if [ $? -eq 0 ]; then rm -rf ${TEST_TMP}/opt tar jxf ${toolchain_dir}/${i} -C ${TEST_TMP} ret=$? break fi done if [ $ret -eq 0 ]; then Test_Info "Check if /opt is accessible for non-root user" # Check if the non-root test user has write access of $TOOLCHAIN_TEST if [ -d ${TOOLCHAIN_TEST} ]; then touch ${TOOLCHAIN_TEST} if [ $? -ne 0 ]; then Test_Info "Has no right to modify folder $TOOLCHAIN_TEST, pls. chown it to test user" return 2 fi else mkdir -p ${TOOLCHAIN_TEST} if [ $? -ne 0 ]; then Test_Info "Has no right to create folder $TOOLCHAIN_TEST, pls. create it and chown it to test user" return 2 fi fi # If there is a toolchain folder under $TOOLCHAIN_TEST, let's remove it if [ -d ${TOOLCHAIN_TEST}/poky ]; then rm -rf ${TOOLCHAIN_TEST}/poky fi # Copy toolchain into $TOOLCHAIN_TEST cp -r ${TEST_TMP}/opt/poky ${TOOLCHAIN_TEST} ret=$? if [ $ret -eq 0 ]; then Test_Info "Successfully copy toolchain into $TOOLCHAIN_TEST" return $ret else Test_Info "Meet error when copy toolchain into $TOOLCHAIN_TEST" return $ret fi else Test_Info "No tarball named ${sdk_name}-toolchain-gmae under ${toolchain_dir}" return $ret fi } # Function to execute command and exit if run out of time # $1 is timeout value # $2 is the command to be executed Test_Time_Out() { local timeout=$1 shift local command=$* local date=0 local tmp=`mktemp` local ret=1 local pid=0 local ppid=0 local i=0 declare local pid_l # Run command in background ($command; echo $? > $tmp) & pid=$! while ps -e -o pid | grep -qw $pid; do if [ $date -ge $timeout ]; then Test_Info "$timeout Timeout when running command $command" rm -rf $tmp # Find all child processes of pid and kill them ppid=$pid ps -f --ppid $ppid ret=$? while [ $ret -eq 0 ] do # If yes, get the child pid and check if the child pid has other child pid # Continue the while loop until there is no child pid found pid_l[$i]=`ps -f --ppid $ppid | awk '{if ($2 != "PID") print $2}'` ppid=${pid_l[$i]} i=$((i+1)) ps -f --ppid $ppid ret=$? done # Kill these children pids from the last one while [ $i -ne 0 ] do i=$((i-1)) kill ${pid_l[$i]} sleep 2 done # Kill the parent id kill $pid return 1 fi sleep 5 date=`expr $date + 5` done ret=`cat $tmp` rm -rf $tmp return $ret } # Function to test toolchain # $1 is test project name # $2 is the timeout value Test_Toolchain() { local test_project=$1 local timeout=$2 local ret=1 local suffix="tar.bz2" local env_setup="" local pro_install="${TEST_TMP}/pro_install" # Set value for PROJECT_PV and PROJECT_DOWNLOAD_URL accordingly if [ $test_project == "cvs" ]; then PROJECT_PV=1.12.13 PROJECT_DOWNLOAD_URL="http://ftp.gnu.org/non-gnu/cvs/source/feature/1.12.13/cvs-1.12.13.tar.bz2" elif [ $test_project == "iptables" ]; then PROJECT_PV=1.4.11 PROJECT_DOWNLOAD_URL="http://netfilter.org/projects/iptables/files/iptables-1.4.11.tar.bz2" elif [ $test_project == "sudoku-savant" ]; then PROJECT_PV=1.3 PROJECT_DOWNLOAD_URL="http://downloads.sourceforge.net/project/sudoku-savant/sudoku-savant/sudoku-savant-1.3/sudoku-savant-1.3.tar.bz2" else Test_Info "Unknown test project name $test_project" return 1 fi # Download test project and extract it Test_Project_Prepare $TOOLCHAIN_PROJECTS $test_project if [ $? -ne 0 ]; then Test_Info "Prepare test project file failed" return 1 fi # Extract toolchain tarball into ${TEST_TMP} Test_Toolchain_Prepare $TOOLCHAIN_DIR $SDK_NAME ret=$? if [ $ret -ne 0 ]; then Test_Info "Prepare toolchain test environment failed" return $ret fi if [ ! -d ${pro_install} ]; then mkdir -p ${pro_install} fi # Begin to build test project in toolchain environment env_setup=`find ${TOOLCHAIN_TEST}/poky -name "environment-setup*"` source $env_setup if [ $test_project == "cvs" -o $test_project == "iptables" ]; then cd ${TEST_TMP}/${test_project}-${PROJECT_PV} Test_Time_Out $timeout ./configure ${CONFIGURE_FLAGS} || { Test_Info "configure failed with $test_project"; return 1; } Test_Time_Out $timeout make -j4 || { Test_Info "make failed with $test_project"; return 1; } Test_Time_Out $timeout make install DESTDIR=${pro_install} || { Test_Info "make failed with $test_project"; return 1; } cd - ret=0 elif [ $test_project == "sudoku-savant" ]; then cd ${TEST_TMP}/${test_project}-${PROJECT_PV} Test_Time_Out $timeout ./configure ${CONFIGURE_FLAGS} || { Test_Info "configure failed with $test_project"; return 1; } Test_Time_Out $timeout make -j4 || { Test_Info "make failed with $test_project"; return 1; } cd - ret=0 else Test_Info "Unknown test project $test_project" ret=1 fi return $ret }