[BACK]Return to t_swsensor.sh CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / tests / dev / sysmon

Annotation of src/tests/dev/sysmon/t_swsensor.sh, Revision 1.4

1.4     ! pgoyette    1: # $NetBSD: t_swsensor.sh,v 1.3 2010/12/30 04:01:59 pgoyette Exp $
1.1       pgoyette    2:
                      3: get_sensor_info() {
                      4:        rump.envstat -x | \
                      5:        sed -e "\;swsensor;,\;/array;p" -e "d"
                      6: }
                      7:
                      8: get_sensor_key() {
                      9:        get_sensor_info | grep -A1 $1 | grep integer | sed -e 's;<[/a-z]*>;;g'
                     10: }
                     11:
                     12: get_powerd_event_count() {
                     13:        grep "not running" powerd.log | wc -l
                     14: }
                     15:
                     16: check_powerd_event() {
                     17:        event=$(grep "not running" powerd.log | \
                     18:                sed -e "$1p" -e "d" )
                     19:        event=${event##*//}
                     20:        script=${event%% *}
                     21:        event=${event#* }
                     22:        device=${event%% *}
                     23:        event=${event#* }
                     24:        state=${event%% *}
                     25:        sensor=${event#* }
                     26:        sensor=${sensor% *}
                     27:
                     28:        if [ "${script}" != "sensor_indicator" ] ; then
                     29:                echo "Event uses wrong script: ${script}"
                     30:        elif [ "${device}" != "swsensor" ] ; then
                     31:                echo "Event uses wrong device: ${device}"
                     32:        elif [ "${sensor}" != "sensor" ] ; then
                     33:                echo "Event uses wrong sensor: ${sensor}"
                     34:        elif [ "${state}" != "$2" ] ; then
                     35:                echo "Event uses wrong state: ${state}"
                     36:        fi
                     37: }
                     38:
                     39: # Start the rump server, then load the swsensor module with the
                     40: # requested properties
                     41:
                     42: start_rump() {
1.4     ! pgoyette   43:        rump_server -l rumpvfs -l rumpdev -l rumpdev_sysmon ${RUMP_SERVER}
1.1       pgoyette   44:        if [ $( get_sensor_info | wc -l ) -ne 0 ] ; then
                     45:                rump.modunload swsensor
                     46:                rump.modload -f $1 swsensor
                     47:        else
                     48:                rump.modload $1 swsensor
                     49:        fi
                     50:        return $?
                     51: }
                     52:
                     53: common_head() {
                     54:        atf_set descr           "$1"
                     55:        atf_set timeout         60
1.4     ! pgoyette   56:        atf_set require.progs   rump.powerd rump.envstat rump.modload   \
        !            57:                                rump.halt   rump.sysctl  rump_server    \
1.1       pgoyette   58:                                sed         grep
                     59: }
                     60:
                     61: common_cleanup() {
                     62:        rump.modunload swsensor
                     63:        rump.halt
                     64: }
                     65:
                     66: create_envsys_conf_files() {
                     67:        cat << ENV0 > env0.conf
                     68:        swsensor {
                     69:                refresh-timeout = 2s;
                     70:        }
                     71: ENV0
                     72:        cat << ENV1 > env1.conf
                     73:        swsensor {
                     74:                sensor0 { critical-min = $(( $1 - $2 )); }
                     75:        }
                     76: ENV1
                     77:        cat << ENV2 > env2.conf
                     78:        swsensor {
                     79:                sensor0 { critical-min = $1; }
                     80:        }
                     81: ENV2
                     82: }
                     83:
                     84: # Test body common to all sensors
                     85: #      $1      sensor mode
                     86: #      $2      initial sensor value
                     87: #      $3      initial limit
                     88: #      $4      amount to lower limit
                     89: #      $5      difference from limit to trigger event
                     90:
                     91: common_body() {
                     92:        # Start the rump-server process and load the module
                     93:        start_rump "-i mode=$1 -i value=$2 -i limit=$3"
                     94:
                     95:        # create configuration files for updates
                     96:        create_envsys_conf_files $3 $4
                     97:
                     98:        if [ $? -ne 0 ] ; then
                     99:                atf_skip "Cannot set-up rump environment"
                    100:        fi
                    101:
                    102:        # start powerd so we can detect sensor events
                    103:        rump.powerd -n -d > powerd.log 2>&1 &
                    104:        if [ -z "$(jobs)" ] ; then
                    105:                skip_events=1
                    106:                echo "Skipping event sub-tests - powerd did not start"
                    107:        else
                    108:                skip_events=0
                    109:                expected_event=1
                    110:        fi
                    111:
                    112:        # Step 0 - verify that sensor is registered
                    113:        get_sensor_info | grep -q swsensor ||
                    114:                atf_fail "0: Device swsensor not registered"
                    115:
                    116:        # Step 1 - update the refresh-timeout and verify
                    117:        # (use $(( ... )) since the timeout is displayed in hex!)
                    118:        rump.envstat -c env0.conf
                    119:        if [ $(( $( get_sensor_key refresh-timeout ) )) -ne 2 ] ; then
                    120:                atf_fail "1: Could not set refresh-timout to 2s"
                    121:        fi
                    122:
                    123:        # Step 2 - verify that we can read sensor's value
                    124:        if [ $1 -ne 0 -a $( get_sensor_key cur-value ) -ne $2 ] ; then
                    125:                atf_fail "2: Value not available"
                    126:        fi
                    127:
                    128:        # Step 3 - verify that changes in sensor value are seen
                    129:        rump.sysctl -w hw.swsensor.cur_value=$(( $2 + 1 ))
                    130:        if [ $( get_sensor_key cur-value ) -ne $(( $2 + 1 )) ] ; then
                    131:                atf_fail "3: Value not updated"
                    132:        fi
                    133:
                    134:        # Step 4 - if sensor provides hw limit, make sure we can read it
                    135:        if [ $1 -ne 0 ] ; then
                    136:                if [ $( get_sensor_key critical-min ) -ne $3 ] ; then
                    137:                        atf_fail "4: Limit not set by device"
                    138:                fi
                    139:        fi
                    140:
                    141:        # Step 5 - if sensor provides hw limit, make sure it works
                    142:        if [ $1 -ne 0 -a ${skip_events} -eq 0 ] ; then
                    143:                rump.sysctl -w hw.swsensor.cur_value=$(( $3 - $5 ))
1.3       pgoyette  144:                sleep 5
1.1       pgoyette  145:                cnt=$(get_powerd_event_count)
                    146:                if [ ${cnt} -lt ${expected_event} ] ; then
                    147:                        atf_fail "5: No event triggered"
                    148:                elif [ ${cnt} -gt ${expected_event} ] ; then
                    149:                        atf_fail "5: Multiple events triggered"
                    150:                fi
                    151:                evt=$( check_powerd_event ${cnt} "critical-under")
                    152:                if [ -n "${evt}" ] ; then
                    153:                        atf_fail "5: ${evt}"
                    154:                fi
                    155:                expected_event=$(( 1 + ${expected_event} ))
                    156:        fi
                    157:
                    158:        # Step 6 - verify that we return to normal state
                    159:        if [ $1 -ne 0 -a ${skip_events} -eq 0 ] ; then
                    160:                rump.sysctl -w hw.swsensor.cur_value=$(( $3 + $5 ))
                    161:                sleep 5
                    162:                cnt=$(get_powerd_event_count)
                    163:                if [ ${cnt} -lt ${expected_event} ] ; then
                    164:                        atf_fail "6: No event triggered"
                    165:                elif [ ${cnt} -gt ${expected_event} ] ; then
                    166:                        atf_fail "6: Multiple events triggered"
                    167:                fi
                    168:                evt=$( check_powerd_event ${cnt} "normal")
                    169:                if [ -n "${evt}" ] ; then
                    170:                        atf_fail "6: ${evt}"
                    171:                fi
                    172:                expected_event=$(( 1 + ${expected_event} ))
                    173:        fi
                    174:
                    175:        # Step 7 - verify that we can set our own limit
                    176:        rump.envstat -c env1.conf
                    177:        if [ $( get_sensor_key critical-min ) -ne $(( $3 - $4 )) ] ; then
                    178:                atf_fail "7: Limit not set by envstat -c"
                    179:        fi
                    180:
                    181:        # Step 8 - make sure user-set limit works
                    182:        if [ ${skip_events} -eq 0 ] ; then
                    183:                rump.sysctl -w hw.swsensor.cur_value=$(( $3 - $4 - $5 ))
                    184:                sleep 5
                    185:                cnt=$(get_powerd_event_count)
                    186:                if [ ${cnt} -lt ${expected_event} ] ; then
                    187:                        atf_fail "8: No event triggered"
                    188:                elif [ ${cnt} -gt ${expected_event} ] ; then
                    189:                        atf_fail "8: Multiple events triggered"
                    190:                fi
                    191:                evt=$( check_powerd_event ${cnt} "critical-under")
                    192:                if [ -n "${evt}" ] ; then
                    193:                        atf_fail "8: ${evt}"
                    194:                fi
                    195:                expected_event=$(( 1 + ${expected_event} ))
                    196:        fi
                    197:
                    198:        # Step 9 - verify that we return to normal state
                    199:        if [ ${skip_events} -eq 0 ] ; then
                    200:                rump.sysctl -w hw.swsensor.cur_value=$(( $3 - $4 + $5 ))
                    201:                sleep 5
                    202:                cnt=$(get_powerd_event_count)
                    203:                if [ ${cnt} -lt ${expected_event} ] ; then
                    204:                        atf_fail "9: No event triggered"
                    205:                elif [ ${cnt} -gt ${expected_event} ] ; then
                    206:                        atf_fail "9: Multiple events triggered"
                    207:                fi
                    208:                evt=$( check_powerd_event ${cnt} "normal")
                    209:                if [ -n "${evt}" ] ; then
                    210:                        atf_fail "9: ${evt}"
                    211:                fi
                    212:                expected_event=$(( 1 + ${expected_event} ))
                    213:        fi
                    214:
                    215:        # Step 10 - reset to defaults
                    216:        rump.envstat -S
                    217:        if [ $1 -eq 0 ] ; then
                    218:                get_sensor_info | grep -q critical-min &&
                    219:                        atf_fail "10: Failed to clear a limit with envstat -S"
                    220:        else
                    221:                if [ $( get_sensor_key critical-min ) -ne $3 ] ; then
                    222:                        atf_fail "10: Limit not reset to initial value"
                    223:                fi
                    224:        fi
                    225:
                    226:        # Step 11 - see if more events occur
                    227:        if [ ${skip_events} -eq 0 ] ; then
                    228:                rump.envstat -c env0.conf
                    229:                rump.sysctl -w hw.swsensor.cur_value=$(( $3 - $4 - $5 ))
                    230:                sleep 5
                    231:                cnt=$(get_powerd_event_count)
                    232:                if [ ${cnt} -ge ${expected_event} ] ; then
1.2       pgoyette  233:                        if [ $1 -ne 2 ] ; then
                    234:                                atf_fail "11b Event triggered after reset"
                    235:                        fi
                    236:                        evt=$( check_powerd_event ${cnt} "critical-under")
                    237:                        if [ -n "${evt}" ] ; then
                    238:                                atf_fail "11a: ${evt}"
                    239:                        fi
1.1       pgoyette  240:                fi
                    241:        fi
                    242:
                    243:        # Step 12 - make sure we can set new limits once more
                    244:        rump.envstat -c env2.conf
                    245:        if [ $( get_sensor_key critical-min ) -ne $3 ] ; then
                    246:                atf_fail "12a: Limit not reset to same value"
                    247:        fi
                    248:        rump.envstat -c env1.conf
                    249:        if [ $( get_sensor_key critical-min ) -ne $(( $3 - $4 )) ] ; then
                    250:                atf_fail "12b: Limit not reset to new value"
                    251:        fi
                    252: }
                    253:
                    254: atf_test_case simple_sensor cleanup
                    255: simple_sensor_head() {
                    256:        common_head "Test a simple sensor"
                    257: }
                    258:
                    259: simple_sensor_body() {
                    260:        common_body 0 50 30 10 1
                    261: }
                    262:
                    263: simple_sensor_cleanup() {
                    264:        common_cleanup
                    265: }
                    266:
                    267: atf_test_case limit_sensor cleanup
                    268: limit_sensor_head() {
                    269:        common_head "Test a sensor with internal limit"
                    270: }
                    271:
                    272: limit_sensor_body() {
                    273:        common_body 1 45 25 8 2
                    274: }
                    275:
                    276: limit_sensor_cleanup() {
                    277:        common_cleanup
                    278: }
                    279:
                    280: atf_test_case alarm_sensor cleanup
                    281: alarm_sensor_head() {
                    282:        common_head "Test a sensor with internal checking"
                    283: }
                    284:
                    285: alarm_sensor_body() {
                    286:        common_body 2 40 20 6 3
                    287: }
                    288:
                    289: alarm_sensor_cleanup() {
                    290:        common_cleanup
                    291: }
                    292:
                    293: atf_init_test_cases() {
1.2       pgoyette  294:        RUMP_SERVER="unix://t_swsensor_socket" ; export RUMP_SERVER
1.1       pgoyette  295:        atf_add_test_case simple_sensor
                    296:        atf_add_test_case limit_sensor
                    297:        atf_add_test_case alarm_sensor
                    298: }

CVSweb <webmaster@jp.NetBSD.org>