tests/regression/tools/notification/test_notification_multi_app

   1 #!/bin/bash
   2 #
   3 # Copyright (C) - 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficiso.com>>
   4 #
   5 # This library is free software; you can redistribute it and/or modify it under
   6 # the terms of the GNU Lesser General Public License as published by the Free
   7 # Software Foundation; version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful, but WITHOUT
  10 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11 # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  12 # details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public License
  15 # along with this library; if not, write to the Free Software Foundation, Inc.,
  16 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  17
  18 TEST_DESC="Notification"
  19
  20 CURDIR=$(dirname $0)/
  21 TESTDIR=$CURDIR/../../../
  22
  23 TESTPOINT=$(readlink -f ${CURDIR}/.libs/libpause_consumer.so)
  24
  25 TESTAPP_PATH="$TESTDIR/utils/testapp"
  26 TESTAPP_NAME="gen-ust-events"
  27 TESTAPP_BIN="$TESTAPP_PATH/$TESTAPP_NAME/$TESTAPP_NAME"
  28 TESTAPP_STATE_FILE="$(mktemp -u)"
  29
  30 NR_ITER=1000
  31 NR_USEC_WAIT=5
  32
  33 SESSION_NAME="my_session"
  34 CHANNEL_NAME="my_channel"
  35
  36
  37 DIR=$(readlink -f $TESTDIR)
  38
  39 PAGE_SIZE=$(getconf PAGE_SIZE)
  40
  41 NUM_TEST_UST=50
  42 NUM_TEST_KERNEL=50
  43 NUM_TESTS=$(($NUM_TEST_UST + $NUM_TEST_KERNEL))
  44
  45 source $TESTDIR/utils/utils.sh
  46
  47 consumerd_pipe=()
  48 file_sync_after_first_event=$(mktemp -u)
  49
  50 # MUST set TESTDIR before calling those functions
  51 plan_tests $NUM_TESTS
  52
  53 print_test_banner "$TEST_DESC"
  54
  55 app_pids=()
  56
  57 function kernel_event_generator_toogle_state
  58 {
  59         kernel_event_generator_suspended=$((kernel_event_generator_suspended==0))
  60
  61 }
  62 function kernel_event_generator
  63 {
  64         state_file=$1
  65         kernel_event_generator_suspended=0
  66         trap kernel_event_generator_toogle_state SIGUSR1
  67         trap "exit" SIGTERM SIGINT
  68         while (true); do
  69                 if [[ $kernel_event_generator_suspended -eq "1" ]]; then
  70                         touch $state_file
  71                         sleep 0.5
  72                 else
  73                         if [[ -f $state_file ]]; then
  74                                 rm $state_file 2> /dev/null
  75                         fi
  76                         echo -n "1000" > /proc/lttng-test-filter-event
  77                 fi
  78         done
  79 }
  80
  81 function ust_event_generator_toogle_state
  82 {
  83         ust_event_generator_suspended=$((ust_event_generator_suspended==0))
  84
  85 }
  86 function ust_event_generator
  87 {
  88         state_file=$1
  89         ust_event_generator_suspended=0
  90         trap ust_event_generator_toogle_state SIGUSR1
  91         trap "exit" SIGTERM SIGINT
  92         while (true); do
  93                 if [[ $ust_event_generator_suspended -eq "1" ]]; then
  94                         touch $state_file
  95                         sleep 0.5
  96                 else
  97                         if [[ -f $state_file ]]; then
  98                                 rm $state_file 2> /dev/null
  99                         fi
 100                         taskset  -c 0 $TESTAPP_BIN $NR_ITER $NR_USEC_WAIT > /dev/null 2>&1
 101                 fi
 102         done
 103 }
 104
 105 function start_client {
 106         local pid=-1
 107         local output_file=$1
 108         local session_name=$2
 109         local channel_name=$3
 110         local domain_type=$4
 111         local buffer_usage_type=$5
 112         local buffer_usage_threshold_type=$6
 113         local buffer_usage_threshold_value=$7
 114         local nr_expected_notification=$8
 115
 116         ${CURDIR}/base_client ${session_name} ${channel_name} ${domain_type} ${buffer_usage_type} ${buffer_usage_threshold_type} ${buffer_usage_threshold_value} ${nr_expected_notification} > ${output_file} &
 117         pid=$!
 118
 119         app_pids+=("$pid")
 120 }
 121
 122 function wait_for_message ()
 123 {
 124         local directory=$1
 125         local file_pattern=$2
 126         local message=$3
 127
 128         for file in $directory/${file_pattern}*; do
 129                 while(true); do
 130                         # Check for "error" message
 131                         grep -q "error:" ${file}
 132                         app_error=$?
 133                         if [ $app_error -eq "0" ] ; then
 134                                 # An error occurred
 135                                 fail "Waiting message: error logged see file content: ${message}, ${file}"
 136                                 return 1
 137                         fi
 138
 139                         grep -q "${message}" ${file}
 140                         if [[ "$?" -ne "0" ]]; then
 141                                 # Lookup failed restart loop
 142                                 diag "Lookup failed sleep and retry grep for: ${message}, ${file}"
 143                                 sleep 0.25
 144                                 continue
 145                         fi
 146                         break
 147                 done
 148         done
 149         pass "Message received: ${message}"
 150         return 0
 151 }
 152
 153 function print_errors ()
 154 {
 155         local directory=$1
 156         local file_pattern=$2
 157
 158         for file in $directory/${file_pattern}*; do
 159                 # Check for "error" message
 160                 error_message=$(grep "error:" ${file})
 161                 if [[ "${error_message}x" != "x" ]]; then
 162                         diag "Errors for application ${file}:"
 163                         diag "${error_message}"
 164                 fi
 165         done
 166 }
 167
 168 function comm_consumerd ()
 169 {
 170         local message=$1
 171         local pipe=$2
 172         echo -ne "${message}" > "${pipe}"
 173 }
 174
 175 function stop_consumerd ()
 176 {
 177         local pipe=$1
 178         comm_consumerd "1" "$pipe"
 179 }
 180
 181 function resume_consumerd ()
 182 {
 183         local pipe=$1
 184         comm_consumerd "\0" "$pipe"
 185 }
 186
 187 function test_multi_app ()
 188 {
 189         local domain_type=$1
 190         local event_generator_pid=$2
 191
 192         local app_pids=()
 193         local low_output_file_pattern="low_app_output_file_"
 194         local high_output_file_pattern="high_app_output_file_"
 195         local output_dir=$(mktemp -d)
 196
 197         local testpoint_base_path=$(readlink -f "$output_dir/lttng.t_p_n_multi_app")
 198         local testpoint_pipe_path=$(mktemp -u "${testpoint_base_path}.XXXXXX")
 199
 200         local nr_notification_expected=5
 201         local nr_client_app=50
 202         local domain_string=""
 203         local event_name=""
 204
 205         case $domain_type in
 206                 ust)
 207                         domain_string=LTTNG_DOMAIN_UST
 208                         event_name="tp:tptest"
 209                         ;;
 210                 kernel)
 211                         domain_string=LTTNG_DOMAIN_KERNEL
 212                         event_name="lttng_test_filter_event"
 213                         ;;
 214                 *)
 215                         fail "Invalid domain type"
 216                         exit 1
 217                         ;;
 218         esac
 219
 220         # Setup
 221         LTTNG_SESSIOND_ENV_VARS="LTTNG_TESTPOINT_ENABLE=1 CONSUMER_PAUSE_PIPE_PATH=${testpoint_pipe_path} LD_PRELOAD=${TESTPOINT}"
 222         start_lttng_sessiond
 223
 224         create_lttng_session_ok $SESSION_NAME $TRACE_PATH
 225         enable_${domain_type}_lttng_channel_ok $SESSION_NAME $CHANNEL_NAME --subbuf-size=$PAGE_SIZE
 226         enable_${domain_type}_lttng_event_ok $SESSION_NAME $event_name $CHANNEL_NAME
 227
 228         # Fetch consumerd testpoint pipe information
 229         # This is needed since the testpoint create a pipe with the consumer type suffixed
 230         consumerd_pipe=()
 231         for f in "$testpoint_pipe_path"*; do
 232                 consumerd_pipe+=("$f")
 233         done
 234
 235         for (( i = 0; i < $nr_client_app; i++ )); do
 236                 low_app_output_file=$output_dir/${low_output_file_pattern}${i}
 237                 high_app_output_file=$output_dir/${high_output_file_pattern}${i}
 238                 start_client $low_app_output_file $SESSION_NAME $CHANNEL_NAME $domain_string LOW RATIO 0.0 $nr_notification_expected
 239                 start_client $high_app_output_file $SESSION_NAME $CHANNEL_NAME $domain_string HIGH RATIO 0.420 $nr_notification_expected
 240         done
 241
 242         wait_for_message $output_dir "${low_output_file_pattern}" "sync: ready"
 243         wait_for_message $output_dir "${high_output_file_pattern}" "sync: ready"
 244
 245         # Test notification reception
 246         for (( i = 0; i < $nr_notification_expected; i++ )); do
 247
 248                 # Stop consumerd consumption to force high notification
 249                 start_lttng_tracing_ok $SESSION_NAME
 250                 for pipe in "${consumerd_pipe[@]}"; do
 251                         stop_consumerd "${pipe}"
 252                 done
 253
 254                 wait_for_message $output_dir "${high_output_file_pattern}" "notification: high $i"
 255
 256                 # Put application in suspend mode to prevent double low
 257                 # notification and synchronize on state file.
 258                 kill -s SIGUSR1 $event_generator_pid
 259                 while [ ! -f "${TESTAPP_STATE_FILE}" ]; do
 260                         sleep 0.5
 261                 done
 262
 263                 # Resume consumerd
 264                 for pipe in "${consumerd_pipe[@]}"; do
 265                         resume_consumerd "${pipe}"
 266                 done
 267                 # Stop tracing forcing full buffer consumption
 268                 stop_lttng_tracing_ok $SESSION_NAME
 269
 270                 # Check for notifications reception
 271                 wait_for_message $output_dir "${low_output_file_pattern}" "notification: low $i"
 272                 ret=$?
 273                 ok $ret "Notifications $i received"
 274                 if [[ $ret -ne "0" ]]; then
 275                         # Error occurred bail out
 276                         break;
 277                 fi
 278
 279                 # Put application in active mode and synchronize on state file.
 280                 kill -s SIGUSR1 $event_generator_pid
 281                 while [ -f "${TESTAPP_STATE_FILE}" ]; do
 282                         sleep 0.5
 283                 done
 284         done
 285
 286         wait_for_message $output_dir "${low_output_file_pattern}" "exit: 0"
 287         ret=$?
 288         ok $ret "Application for low notification terminated normally"
 289         if [[ $ret -ne "0" ]]; then
 290                 print_errors $output_dir "${low_output_file_pattern}"
 291         fi
 292
 293         wait_for_message $output_dir "${high_output_file_pattern}" "exit: 0"
 294         ret=$?
 295         ok $ret "Application for high notification terminated normally"
 296         if [[ $ret -ne "0" ]]; then
 297                 print_errors $output_dir "${high_output_file_pattern}"
 298         fi
 299
 300         rm -rf $output_dir
 301
 302         destroy_lttng_session_ok $SESSION_NAME
 303         stop_lttng_sessiond
 304
 305         for pipe in "${consumerd_pipe[@]}"; do
 306                 rm -rf "${pipe}"
 307         done
 308 }
 309
 310 function test_multi_app_ust ()
 311 {
 312         diag "Multi client app UST notification"
 313         ust_event_generator $TESTAPP_STATE_FILE &
 314         local generator_pid=$!
 315
 316         test_multi_app ust $generator_pid
 317
 318         kill -s SIGTERM $generator_pid 2> /dev/null
 319         wait $generator_pid 2> /dev/null
 320         rm -rf ${TESTAPP_STATE_FILE} 2> /dev/null
 321 }
 322
 323 function test_multi_app_kernel ()
 324 {
 325         diag "Multi client app kernel notification"
 326         modprobe lttng-test
 327
 328         kernel_event_generator $TESTAPP_STATE_FILE &
 329         local generator_pid=$!
 330
 331         test_multi_app kernel $generator_pid
 332
 333
 334         kill -s SIGTERM $generator_pid 2> /dev/null
 335         wait $generator_pid 2> /dev/null
 336         rm -rf ${TESTAPP_STATE_FILE} 2> /dev/null
 337
 338         rmmod lttng-test
 339 }
 340
 341 function test_on_register_evaluation_ust ()
 342 {
 343         diag "On register notification UST"
 344
 345         # Start app in infinite loop
 346         ust_event_generator $TESTAPP_STATE_FILE &
 347         local generator_pid=$!
 348
 349         test_on_register_evaluation ust $generator_pid
 350
 351         kill -s SIGTERM $generator_pid 2> /dev/null
 352         wait $generator_pid 2> /dev/null
 353         rm -rf ${TESTAPP_STATE_FILE} 2> /dev/null
 354
 355 }
 356
 357 function test_on_register_evaluation_kernel()
 358 {
 359         diag "On register notification kernel"
 360
 361         modprobe lttng-test
 362
 363         kernel_event_generator $TESTAPP_STATE_FILE &
 364         local generator_pid=$!
 365
 366         test_on_register_evaluation kernel $generator_pid
 367
 368
 369         kill -s SIGTERM $generator_pid 2> /dev/null
 370         wait $generator_pid 2> /dev/null
 371         rm -rf ${TESTAPP_STATE_FILE} 2> /dev/null
 372
 373         rmmod lttng-test
 374 }
 375
 376 function test_on_register_evaluation ()
 377 {
 378         local domain_type=$1
 379         local event_generator_pid=$2
 380
 381         local app_pids=()
 382         local high_output_file_pattern="high_app_output_file_on_register_evaluation"
 383
 384         local output_dir=$(mktemp -d)
 385         local testpoint_base_path=$(readlink -f "$output_dir/lttng.t_p_n_register_evaluation")
 386         local testpoint_pipe_path=$(mktemp -u "${testpoint_base_path}.XXXXXX")
 387         local domain_string=""
 388         local event_name=""
 389
 390         case $domain_type in
 391                 ust)
 392                         domain_string=LTTNG_DOMAIN_UST
 393                         event_name="tp:tptest"
 394                         ;;
 395                 kernel)
 396                         domain_string=LTTNG_DOMAIN_KERNEL
 397                         event_name="lttng_test_filter_event"
 398                         ;;
 399                 *)
 400                         fail "Invalid domain type"
 401                         exit 1
 402                         ;;
 403         esac
 404
 405         # Setup
 406         LTTNG_SESSIOND_ENV_VARS="LTTNG_TESTPOINT_ENABLE=1 CONSUMER_PAUSE_PIPE_PATH=${testpoint_pipe_path} LD_PRELOAD=${TESTPOINT}"
 407         start_lttng_sessiond
 408
 409         create_lttng_session_ok $SESSION_NAME $TRACE_PATH
 410         enable_${domain_type}_lttng_channel_ok $SESSION_NAME $CHANNEL_NAME --subbuf-size=$PAGE_SIZE
 411         enable_${domain_type}_lttng_event_ok $SESSION_NAME $event_name $CHANNEL_NAME
 412
 413         # Fetch consumerd testpoint pipe information
 414         # This is needed since the testpoint create a pipe with the consumer type suffixed
 415         consumerd_pipe=()
 416         for f in "$testpoint_pipe_path"*; do
 417                 consumerd_pipe+=("$f")
 418         done
 419
 420         high_app_output_file=${high_output_file_pattern}.first_receiver
 421         high_app_output_path=$output_dir/${high_app_output_file}
 422         start_client $high_app_output_path $SESSION_NAME $CHANNEL_NAME $domain_string HIGH RATIO 0.420 1
 423
 424         wait_for_message $output_dir "${high_app_output_file}" "sync: ready"
 425
 426         # Stop consumerd consumption to force high notification
 427         start_lttng_tracing_ok $SESSION_NAME
 428
 429         for pipe in "${consumerd_pipe[@]}"; do
 430                 stop_consumerd "${pipe}"
 431         done
 432
 433         wait_for_message $output_dir "${high_app_output_file}" "notification: high 0"
 434
 435         # Start a second receiver, the receiver should receive a high
 436         # notification on subscription
 437         high_app_output_file=${high_output_file_pattern}.second_receiver
 438         high_app_output_path=$output_dir/${high_app_output_file}
 439         start_client $high_app_output_path $SESSION_NAME $CHANNEL_NAME $domain_string HIGH RATIO 0.420 1
 440         wait_for_message $output_dir "${high_app_output_file}" "sync: ready"
 441         wait_for_message $output_dir "${high_app_output_file}" "notification: high 0"
 442
 443         # Resume consumerd
 444         for pipe in "${consumerd_pipe[@]}"; do
 445                 resume_consumerd "${pipe}"
 446         done
 447
 448         wait_for_message $output_dir "${high_output_file_pattern}" "exit: 0"
 449         ret=$?
 450         ok $ret "Application for high notification terminated normally"
 451         if [[ $ret -ne "0" ]]; then
 452                 # Keep the file
 453                 print_errors "${high_output_file_pattern}"
 454         fi
 455
 456         rm -rf $output_dir
 457
 458         destroy_lttng_session_ok $SESSION_NAME
 459         stop_lttng_sessiond
 460
 461         kill -s SIGTERM $generator_pid 2> /dev/null
 462         wait $generator_pid 2> /dev/null
 463
 464         for pipe in "${consumerd_pipe[@]}"; do
 465                 rm -rf "${pipe}"
 466         done
 467
 468 }
 469
 470
 471 TESTS=(
 472         test_multi_app_ust
 473         test_on_register_evaluation_ust
 474 )
 475
 476 if [ "$(id -u)" == "0" ]; then
 477         TESTS+=(
 478         test_multi_app_kernel
 479         test_on_register_evaluation_kernel
 480 )
 481 else
 482         skip 0 "Root access is needed. Skipping all kernel multi-app notification tests." $NUM_TEST_KERNEL
 483 fi
 484
 485
 486 for fct_test in ${TESTS[@]};
 487 do
 488         TRACE_PATH=$(mktemp -d)
 489
 490         ${fct_test}
 491         if [ $? -ne 0 ]; then
 492                 break;
 493         fi
 494
 495         # Only delete if successful
 496         rm -rf $TRACE_PATH
 497 done