tools/perf/tests/shell/daemon.sh

   1 #!/bin/bash
   2 # daemon operations
   3 # SPDX-License-Identifier: GPL-2.0
   4
   5 check_line_first()
   6 {
   7         local line=$1
   8         local name=$2
   9         local base=$3
  10         local output=$4
  11         local lock=$5
  12         local up=$6
  13
  14         local line_name=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $2 }'`
  15         local line_base=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $3 }'`
  16         local line_output=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $4 }'`
  17         local line_lock=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $5 }'`
  18         local line_up=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $6 }'`
  19
  20         if [ "${name}" != "${line_name}" ]; then
  21                 echo "FAILED: wrong name"
  22                 error=1
  23         fi
  24
  25         if [ "${base}" != "${line_base}" ]; then
  26                 echo "FAILED: wrong base"
  27                 error=1
  28         fi
  29
  30         if [ "${output}" != "${line_output}" ]; then
  31                 echo "FAILED: wrong output"
  32                 error=1
  33         fi
  34
  35         if [ "${lock}" != "${line_lock}" ]; then
  36                 echo "FAILED: wrong lock"
  37                 error=1
  38         fi
  39
  40         if [ "${up}" != "${line_up}" ]; then
  41                 echo "FAILED: wrong up"
  42                 error=1
  43         fi
  44 }
  45
  46 check_line_other()
  47 {
  48         local line=$1
  49         local name=$2
  50         local run=$3
  51         local base=$4
  52         local output=$5
  53         local control=$6
  54         local ack=$7
  55         local up=$8
  56
  57         local line_name=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $2 }'`
  58         local line_run=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $3 }'`
  59         local line_base=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $4 }'`
  60         local line_output=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $5 }'`
  61         local line_control=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $6 }'`
  62         local line_ack=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $7 }'`
  63         local line_up=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $8 }'`
  64
  65         if [ "${name}" != "${line_name}" ]; then
  66                 echo "FAILED: wrong name"
  67                 error=1
  68         fi
  69
  70         if [ "${run}" != "${line_run}" ]; then
  71                 echo "FAILED: wrong run"
  72                 error=1
  73         fi
  74
  75         if [ "${base}" != "${line_base}" ]; then
  76                 echo "FAILED: wrong base"
  77                 error=1
  78         fi
  79
  80         if [ "${output}" != "${line_output}" ]; then
  81                 echo "FAILED: wrong output"
  82                 error=1
  83         fi
  84
  85         if [ "${control}" != "${line_control}" ]; then
  86                 echo "FAILED: wrong control"
  87                 error=1
  88         fi
  89
  90         if [ "${ack}" != "${line_ack}" ]; then
  91                 echo "FAILED: wrong ack"
  92                 error=1
  93         fi
  94
  95         if [ "${up}" != "${line_up}" ]; then
  96                 echo "FAILED: wrong up"
  97                 error=1
  98         fi
  99 }
 100
 101 daemon_exit()
 102 {
 103         local config=$1
 104
 105         local line=`perf daemon --config ${config} -x: | head -1`
 106         local pid=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $1 }'`
 107
 108         # Reset trap handler.
 109         trap - SIGINT SIGTERM
 110
 111         # stop daemon
 112         perf daemon stop --config ${config}
 113
 114         # ... and wait for the pid to go away
 115         tail --pid=${pid} -f /dev/null
 116 }
 117
 118 daemon_start()
 119 {
 120         local config=$1
 121         local session=$2
 122
 123         perf daemon start --config ${config}
 124
 125         # Clean up daemon if interrupted.
 126         trap "echo 'FAILED: Signal caught'; daemon_exit ${config}; exit 1" SIGINT SIGTERM
 127
 128         # wait for the session to ping
 129         local state="FAIL"
 130         local retries=0
 131         while [ "${state}" != "OK" ]; do
 132                 state=`perf daemon ping --config ${config} --session ${session} | awk '{ print $1 }'`
 133                 sleep 0.05
 134                 retries=$((${retries} +1))
 135                 if [ ${retries} -ge 600 ]; then
 136                         echo "FAILED: Timeout waiting for daemon to ping"
 137                         daemon_exit ${config}
 138                         exit 1
 139                 fi
 140         done
 141 }
 142
 143 test_list()
 144 {
 145         echo "test daemon list"
 146
 147         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 148         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 149
 150         cat <<EOF > ${config}
 151 [daemon]
 152 base=BASE
 153
 154 [session-size]
 155 run = -e cpu-clock -m 1 sleep 10
 156
 157 [session-time]
 158 run = -e task-clock -m 1 sleep 10
 159 EOF
 160
 161         sed -i -e "s|BASE|${base}|" ${config}
 162
 163         # start daemon
 164         daemon_start ${config} size
 165
 166         # check first line
 167         # pid:daemon:base:base/output:base/lock
 168         local line=`perf daemon --config ${config} -x: | head -1`
 169         check_line_first ${line} daemon ${base} ${base}/output ${base}/lock "0"
 170
 171         # check 1st session
 172         # pid:size:-e cpu-clock:base/size:base/size/output:base/size/control:base/size/ack:0
 173         local line=`perf daemon --config ${config} -x: | head -2 | tail -1`
 174         check_line_other "${line}" size "-e cpu-clock -m 1 sleep 10" ${base}/session-size \
 175                          ${base}/session-size/output ${base}/session-size/control \
 176                          ${base}/session-size/ack "0"
 177
 178         # check 2nd session
 179         # pid:time:-e task-clock:base/time:base/time/output:base/time/control:base/time/ack:0
 180         local line=`perf daemon --config ${config} -x: | head -3 | tail -1`
 181         check_line_other "${line}" time "-e task-clock -m 1 sleep 10" ${base}/session-time \
 182                          ${base}/session-time/output ${base}/session-time/control \
 183                          ${base}/session-time/ack "0"
 184
 185         # stop daemon
 186         daemon_exit ${config}
 187
 188         rm -rf ${base}
 189         rm -f ${config}
 190 }
 191
 192 test_reconfig()
 193 {
 194         echo "test daemon reconfig"
 195
 196         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 197         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 198
 199         # prepare config
 200         cat <<EOF > ${config}
 201 [daemon]
 202 base=BASE
 203
 204 [session-size]
 205 run = -e cpu-clock -m 1 sleep 10
 206
 207 [session-time]
 208 run = -e task-clock -m 1 sleep 10
 209 EOF
 210
 211         sed -i -e "s|BASE|${base}|" ${config}
 212
 213         # start daemon
 214         daemon_start ${config} size
 215
 216         # check 2nd session
 217         # pid:time:-e task-clock:base/time:base/time/output:base/time/control:base/time/ack:0
 218         local line=`perf daemon --config ${config} -x: | head -3 | tail -1`
 219         check_line_other "${line}" time "-e task-clock -m 1 sleep 10" ${base}/session-time \
 220                          ${base}/session-time/output ${base}/session-time/control ${base}/session-time/ack "0"
 221         local pid=`echo "${line}" | awk 'BEGIN { FS = ":" } ; { print $1 }'`
 222
 223         # prepare new config
 224         local config_new=${config}.new
 225         cat <<EOF > ${config_new}
 226 [daemon]
 227 base=BASE
 228
 229 [session-size]
 230 run = -e cpu-clock -m 1 sleep 10
 231
 232 [session-time]
 233 run = -e cpu-clock -m 1 sleep 10
 234 EOF
 235
 236         # TEST 1 - change config
 237
 238         sed -i -e "s|BASE|${base}|" ${config_new}
 239         cp ${config_new} ${config}
 240
 241         # wait for old session to finish
 242         tail --pid=${pid} -f /dev/null
 243
 244         # wait for new one to start
 245         local state="FAIL"
 246         while [ "${state}" != "OK" ]; do
 247                 state=`perf daemon ping --config ${config} --session time | awk '{ print $1 }'`
 248         done
 249
 250         # check reconfigured 2nd session
 251         # pid:time:-e task-clock:base/time:base/time/output:base/time/control:base/time/ack:0
 252         local line=`perf daemon --config ${config} -x: | head -3 | tail -1`
 253         check_line_other "${line}" time "-e cpu-clock -m 1 sleep 10" ${base}/session-time \
 254                          ${base}/session-time/output ${base}/session-time/control ${base}/session-time/ack "0"
 255
 256         # TEST 2 - empty config
 257
 258         local config_empty=${config}.empty
 259         cat <<EOF > ${config_empty}
 260 [daemon]
 261 base=BASE
 262 EOF
 263
 264         # change config
 265         sed -i -e "s|BASE|${base}|" ${config_empty}
 266         cp ${config_empty} ${config}
 267
 268         # wait for sessions to finish
 269         local state="OK"
 270         while [ "${state}" != "FAIL" ]; do
 271                 state=`perf daemon ping --config ${config} --session time | awk '{ print $1 }'`
 272         done
 273
 274         local state="OK"
 275         while [ "${state}" != "FAIL" ]; do
 276                 state=`perf daemon ping --config ${config} --session size | awk '{ print $1 }'`
 277         done
 278
 279         local one=`perf daemon --config ${config} -x: | wc -l`
 280
 281         if [ ${one} -ne "1" ]; then
 282                 echo "FAILED: wrong list output"
 283                 error=1
 284         fi
 285
 286         # TEST 3 - config again
 287
 288         cp ${config_new} ${config}
 289
 290         # wait for size to start
 291         local state="FAIL"
 292         while [ "${state}" != "OK" ]; do
 293                 state=`perf daemon ping --config ${config} --session size | awk '{ print $1 }'`
 294         done
 295
 296         # wait for time to start
 297         local state="FAIL"
 298         while [ "${state}" != "OK" ]; do
 299                 state=`perf daemon ping --config ${config} --session time | awk '{ print $1 }'`
 300         done
 301
 302         # stop daemon
 303         daemon_exit ${config}
 304
 305         rm -rf ${base}
 306         rm -f ${config}
 307         rm -f ${config_new}
 308         rm -f ${config_empty}
 309 }
 310
 311 test_stop()
 312 {
 313         echo "test daemon stop"
 314
 315         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 316         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 317
 318         # prepare config
 319         cat <<EOF > ${config}
 320 [daemon]
 321 base=BASE
 322
 323 [session-size]
 324 run = -e cpu-clock -m 1 sleep 10
 325
 326 [session-time]
 327 run = -e task-clock -m 1 sleep 10
 328 EOF
 329
 330         sed -i -e "s|BASE|${base}|" ${config}
 331
 332         # start daemon
 333         daemon_start ${config} size
 334
 335         local pid_size=`perf daemon --config ${config} -x: | head -2 | tail -1 | awk 'BEGIN { FS = ":" } ; { print $1 }'`
 336         local pid_time=`perf daemon --config ${config} -x: | head -3 | tail -1 | awk 'BEGIN { FS = ":" } ; { print $1 }'`
 337
 338         # check that sessions are running
 339         if [ ! -d "/proc/${pid_size}" ]; then
 340                 echo "FAILED: session size not up"
 341         fi
 342
 343         if [ ! -d "/proc/${pid_time}" ]; then
 344                 echo "FAILED: session time not up"
 345         fi
 346
 347         # stop daemon
 348         daemon_exit ${config}
 349
 350         # check that sessions are gone
 351         if [ -d "/proc/${pid_size}" ]; then
 352                 echo "FAILED: session size still up"
 353         fi
 354
 355         if [ -d "/proc/${pid_time}" ]; then
 356                 echo "FAILED: session time still up"
 357         fi
 358
 359         rm -rf ${base}
 360         rm -f ${config}
 361 }
 362
 363 test_signal()
 364 {
 365         echo "test daemon signal"
 366
 367         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 368         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 369
 370         # prepare config
 371         cat <<EOF > ${config}
 372 [daemon]
 373 base=BASE
 374
 375 [session-test]
 376 run = -e cpu-clock --switch-output -m 1 sleep 10
 377 EOF
 378
 379         sed -i -e "s|BASE|${base}|" ${config}
 380
 381         # start daemon
 382         daemon_start ${config} test
 383
 384         # send 2 signals
 385         perf daemon signal --config ${config} --session test
 386         perf daemon signal --config ${config}
 387
 388         # stop daemon
 389         daemon_exit ${config}
 390
 391         # count is 2 perf.data for signals and 1 for perf record finished
 392         count=`ls ${base}/session-test/ | grep perf.data | wc -l`
 393         if [ ${count} -ne 3 ]; then
 394                 error=1
 395                 echo "FAILED: perf data no generated"
 396         fi
 397
 398         rm -rf ${base}
 399         rm -f ${config}
 400 }
 401
 402 test_ping()
 403 {
 404         echo "test daemon ping"
 405
 406         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 407         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 408
 409         # prepare config
 410         cat <<EOF > ${config}
 411 [daemon]
 412 base=BASE
 413
 414 [session-size]
 415 run = -e cpu-clock -m 1 sleep 10
 416
 417 [session-time]
 418 run = -e task-clock -m 1 sleep 10
 419 EOF
 420
 421         sed -i -e "s|BASE|${base}|" ${config}
 422
 423         # start daemon
 424         daemon_start ${config} size
 425
 426         size=`perf daemon ping --config ${config} --session size | awk '{ print $1 }'`
 427         type=`perf daemon ping --config ${config} --session time | awk '{ print $1 }'`
 428
 429         if [ ${size} != "OK" -o ${type} != "OK" ]; then
 430                 error=1
 431                 echo "FAILED: daemon ping failed"
 432         fi
 433
 434         # stop daemon
 435         daemon_exit ${config}
 436
 437         rm -rf ${base}
 438         rm -f ${config}
 439 }
 440
 441 test_lock()
 442 {
 443         echo "test daemon lock"
 444
 445         local config=$(mktemp /tmp/perf.daemon.config.XXX)
 446         local base=$(mktemp -d /tmp/perf.daemon.base.XXX)
 447
 448         # prepare config
 449         cat <<EOF > ${config}
 450 [daemon]
 451 base=BASE
 452
 453 [session-size]
 454 run = -e cpu-clock -m 1 sleep 10
 455 EOF
 456
 457         sed -i -e "s|BASE|${base}|" ${config}
 458
 459         # start daemon
 460         daemon_start ${config} size
 461
 462         # start second daemon over the same config/base
 463         failed=`perf daemon start --config ${config} 2>&1 | awk '{ print $1 }'`
 464
 465         # check that we failed properly
 466         if [ ${failed} != "failed:" ]; then
 467                 error=1
 468                 echo "FAILED: daemon lock failed"
 469         fi
 470
 471         # stop daemon
 472         daemon_exit ${config}
 473
 474         rm -rf ${base}
 475         rm -f ${config}
 476 }
 477
 478 error=0
 479
 480 test_list
 481 test_reconfig
 482 test_stop
 483 test_signal
 484 test_ping
 485 test_lock
 486
 487 exit ${error}