| 1 |
#!/bin/bash |
| 2 |
# |
| 3 |
# SPDX-FileCopyrightText: 2013 Julien Desfossez <[email protected]> |
| 4 |
# |
| 5 |
# SPDX-License-Identifier: LGPL-2.1-only |
| 6 |
|
| 7 |
TEST_DESC="Snapshots - UST tracing" |
| 8 |
|
| 9 |
CURDIR=$(dirname "$0")/ |
| 10 |
TESTDIR="$CURDIR/../../.." |
| 11 |
EVENT_NAME="tp:tptest" |
| 12 |
SESSION_NAME="" |
| 13 |
CHANNEL_NAME="snapchan" |
| 14 |
TESTAPP_PATH="$TESTDIR/utils/testapp" |
| 15 |
TESTAPP_NAME="gen-ust-events" |
| 16 |
TESTAPP_BIN="$TESTAPP_PATH/$TESTAPP_NAME" |
| 17 |
APPS_PID=() |
| 18 |
|
| 19 |
NUM_TESTS=201 |
| 20 |
|
| 21 |
TRACE_PATH=$(mktemp -d -t tmp.test_snapshots_ust_trace_path.XXXXXX) |
| 22 |
|
| 23 |
# shellcheck source-path=SCRIPTDIR/../../../ |
| 24 |
source "$TESTDIR/utils/utils.sh" |
| 25 |
|
| 26 |
if [ ! -x "$TESTAPP_BIN" ]; then |
| 27 |
BAIL_OUT "No UST events binary detected" |
| 28 |
fi |
| 29 |
|
| 30 |
# Need the number of snapshot to do. |
| 31 |
if [ -z "$1" ]; then |
| 32 |
BAIL_OUT "A number of snapshot is needed" |
| 33 |
fi |
| 34 |
NR_SNAPSHOT=$1 |
| 35 |
|
| 36 |
NUM_TESTS=$((NUM_TESTS + (NR_SNAPSHOT * 3))) |
| 37 |
|
| 38 |
function start_test_app() |
| 39 |
{ |
| 40 |
local tmp_file |
| 41 |
tmp_file=$(mktemp -u -t "tmp.${FUNCNAME[0]}_tmp_file.XXXXXX") |
| 42 |
TESTAPP_ARGS=( |
| 43 |
"-i" |
| 44 |
"${NR_ITER}" |
| 45 |
"-w" |
| 46 |
"${NR_USEC_WAIT}" |
| 47 |
"--sync-after-first-event" |
| 48 |
"${tmp_file}" |
| 49 |
) |
| 50 |
if [ -n "${TESTAPP_ITER_WAIT_FILE}" ] ; then |
| 51 |
TESTAPP_ARGS+=( |
| 52 |
"--sync-after-each-iter" |
| 53 |
"${TESTAPP_ITER_WAIT_FILE}" |
| 54 |
) |
| 55 |
fi |
| 56 |
# Start application with a temporary file. |
| 57 |
$TESTAPP_BIN "${TESTAPP_ARGS[@]}" & |
| 58 |
ret=$? |
| 59 |
APPS_PID+=(${!}) |
| 60 |
ok $ret "Start application to trace" |
| 61 |
|
| 62 |
# Wait for the application file to appear indicating that at least one |
| 63 |
# tracepoint has been fired. |
| 64 |
while [ ! -f "$tmp_file" ]; do |
| 65 |
sleep 0.1 |
| 66 |
done |
| 67 |
diag "Removing test app temporary file $tmp_file" |
| 68 |
rm -f "$tmp_file" |
| 69 |
} |
| 70 |
|
| 71 |
function wait_test_apps() |
| 72 |
{ |
| 73 |
diag "Waiting for $TESTAPP_NAME" |
| 74 |
wait "${APPS_PID[@]}" 2>/dev/null |
| 75 |
} |
| 76 |
|
| 77 |
function stop_test_apps() |
| 78 |
{ |
| 79 |
if [[ -n "${APPS_PID[*]}" ]]; then |
| 80 |
diag "Stopping $TESTAPP_NAME" |
| 81 |
kill "${APPS_PID[@]}" |
| 82 |
wait "${APPS_PID[@]}" |
| 83 |
APPS_PID=() |
| 84 |
fi |
| 85 |
} |
| 86 |
|
| 87 |
function snapshot_add_output () |
| 88 |
{ |
| 89 |
local sess_name=$1 |
| 90 |
local trace_path=$2 |
| 91 |
local name=$3 |
| 92 |
local max_size=$4 |
| 93 |
local extra_opt=() |
| 94 |
|
| 95 |
if [ -n "$name" ]; then |
| 96 |
extra_opt+=(-n "$name") |
| 97 |
fi |
| 98 |
|
| 99 |
if [ -n "$max_size" ]; then |
| 100 |
extra_opt+=(-m "$max_size") |
| 101 |
fi |
| 102 |
|
| 103 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot add-output \ |
| 104 |
-s "$sess_name" "${extra_opt[@]}" "$trace_path" > /dev/null 2>&1 |
| 105 |
|
| 106 |
ok $? "Added snapshot output $trace_path (${extra_opt[*]})" |
| 107 |
} |
| 108 |
|
| 109 |
function snapshot_del_output () |
| 110 |
{ |
| 111 |
local sess_name=$1 |
| 112 |
local name=$2 |
| 113 |
|
| 114 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot del-output \ |
| 115 |
-s "$sess_name" "$name" > /dev/null 2>&1 |
| 116 |
|
| 117 |
ok $? "Deleted snapshot output named $name" |
| 118 |
} |
| 119 |
|
| 120 |
function enable_mmap_overwrite_subbuf_ust_channel () |
| 121 |
{ |
| 122 |
local sess_name=$1 |
| 123 |
local chan_name=$2 |
| 124 |
local subbuf_size=$3 |
| 125 |
local subbuf_count=$4 |
| 126 |
|
| 127 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \ |
| 128 |
"$chan_name" -u --output mmap --overwrite \ |
| 129 |
--num-subbuf="$subbuf_count" \ |
| 130 |
--subbuf-size "$subbuf_size" > /dev/null 2>&1 |
| 131 |
|
| 132 |
ok $? "Enable channel $channel_name for session $sess_name with subbuf size $subbuf_size" |
| 133 |
} |
| 134 |
|
| 135 |
function enable_mmap_small_discard_ust_channel () |
| 136 |
{ |
| 137 |
local sess_name=$1 |
| 138 |
local chan_name=$2 |
| 139 |
|
| 140 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \ |
| 141 |
"$chan_name" -u --output mmap --discard \ |
| 142 |
--subbuf-size "$(getconf PAGE_SIZE)" --num-subbuf 2 \ |
| 143 |
> /dev/null 2>&1 |
| 144 |
|
| 145 |
ok $? "Enable channel $channel_name for session $sess_name with small discard buffers" |
| 146 |
} |
| 147 |
|
| 148 |
function enable_mmap_small_overwrite_ust_channel () |
| 149 |
{ |
| 150 |
local sess_name=$1 |
| 151 |
local chan_name=$2 |
| 152 |
|
| 153 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \ |
| 154 |
"$chan_name" -u --output mmap --overwrite \ |
| 155 |
--subbuf-size "$(getconf PAGE_SIZE)" --num-subbuf 2 \ |
| 156 |
> /dev/null 2>&1 |
| 157 |
|
| 158 |
ok $? "Enable channel $channel_name for session $sess_name with small discard buffers" |
| 159 |
} |
| 160 |
|
| 161 |
function test_ust_list_output () |
| 162 |
{ |
| 163 |
output_names=("randomname" "somesnapshot") |
| 164 |
|
| 165 |
diag "Test UST snapshot output listing" |
| 166 |
create_lttng_session_no_output "$SESSION_NAME" |
| 167 |
enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 168 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 169 |
|
| 170 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 171 |
|
| 172 |
snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "${output_names[0]}" |
| 173 |
|
| 174 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot list-output \ |
| 175 |
-s "$SESSION_NAME" 2>&1 | grep "${output_names[0]}" > /dev/null |
| 176 |
ok $? "Snapshot named ${output_names[0]} present in list-output listing" |
| 177 |
|
| 178 |
snapshot_del_output "$SESSION_NAME" "${output_names[0]}" |
| 179 |
|
| 180 |
snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "${output_names[1]}" |
| 181 |
|
| 182 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot list-output \ |
| 183 |
-s "$SESSION_NAME" 2>&1 | grep "${output_names[1]}" > /dev/null |
| 184 |
|
| 185 |
ok $? "Snapshot named ${output_names[1]} present in list-output listing" |
| 186 |
|
| 187 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 188 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 189 |
} |
| 190 |
|
| 191 |
function test_ust_local_snapshot () |
| 192 |
{ |
| 193 |
NR_ITER=-1 |
| 194 |
NR_USEC_WAIT=100 |
| 195 |
|
| 196 |
diag "Test local UST snapshots" |
| 197 |
create_lttng_session_no_output "$SESSION_NAME" |
| 198 |
enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 199 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 200 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 201 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 202 |
|
| 203 |
# Returns once the application has at least fired ONE tracepoint. |
| 204 |
start_test_app |
| 205 |
|
| 206 |
lttng_snapshot_record "$SESSION_NAME" |
| 207 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 208 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 209 |
|
| 210 |
# Validate test |
| 211 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 212 |
if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then |
| 213 |
# Only delete if successful |
| 214 |
rm -rf "$TRACE_PATH" |
| 215 |
fi |
| 216 |
|
| 217 |
stop_test_apps |
| 218 |
} |
| 219 |
|
| 220 |
function test_ust_local_snapshot_small_discard_buffers () |
| 221 |
{ |
| 222 |
NR_ITER=10000 |
| 223 |
NR_USEC_WAIT=0 |
| 224 |
OLDCPUSET=$(taskset -p $$) |
| 225 |
|
| 226 |
diag "Test local UST snapshots with small discard buffers" |
| 227 |
retry_anycpu_taskset $$ |
| 228 |
ok $? "Set current process CPU affinity" |
| 229 |
create_lttng_session_no_output "$SESSION_NAME" |
| 230 |
enable_mmap_small_discard_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 231 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 232 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 233 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 234 |
|
| 235 |
# Run test apps, wait for them to complete. |
| 236 |
start_test_app |
| 237 |
wait_test_apps |
| 238 |
|
| 239 |
# Take first snapshot, remember first line. |
| 240 |
lttng_snapshot_record "$SESSION_NAME" |
| 241 |
FIRST_LINE="$(trace_first_line "$TRACE_PATH/")" |
| 242 |
diag "First line (1st snapshot): $FIRST_LINE" |
| 243 |
rm -rf "${TRACE_PATH:?}/" |
| 244 |
|
| 245 |
# Run test apps, wait for them to complete. |
| 246 |
start_test_app |
| 247 |
wait_test_apps |
| 248 |
|
| 249 |
# Take second snapshot, remember first line. |
| 250 |
lttng_snapshot_record "$SESSION_NAME" |
| 251 |
FIRST_LINE_2="$(trace_first_line "$TRACE_PATH/")" |
| 252 |
diag "First line (2nd snapshot): $FIRST_LINE_2" |
| 253 |
rm -rf "${TRACE_PATH:?}/" |
| 254 |
|
| 255 |
if [ x"$FIRST_LINE" != x"$FIRST_LINE_2" ]; then |
| 256 |
fail "First snapshot event do not match" |
| 257 |
else |
| 258 |
pass "First snapshot event match" |
| 259 |
fi |
| 260 |
|
| 261 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 262 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 263 |
|
| 264 |
if ! taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1 ; then |
| 265 |
# If returning to the original CPU set fails, create a mask e.g. FFF |
| 266 |
# which encompasses all possible CPUs. |
| 267 |
mask='' |
| 268 |
iter=0 |
| 269 |
while [[ "${iter}" -lt $(($(get_possible_cpus_count) / 4 + 1)) ]]; do |
| 270 |
mask="${mask}F" |
| 271 |
iter=$((iter+1)) |
| 272 |
done |
| 273 |
taskset -p "${mask}" $$ |
| 274 |
fi |
| 275 |
} |
| 276 |
|
| 277 |
function test_ust_local_snapshot_small_overwrite_buffers () |
| 278 |
{ |
| 279 |
NR_ITER=10000 |
| 280 |
NR_USEC_WAIT=0 |
| 281 |
OLDCPUSET=$(taskset -p $$) |
| 282 |
|
| 283 |
diag "Test local UST snapshots with small overwrite buffers" |
| 284 |
retry_anycpu_taskset $$ 1>/dev/null 2>&1 |
| 285 |
ok $? "Set current process CPU affinity" |
| 286 |
create_lttng_session_no_output "$SESSION_NAME" |
| 287 |
enable_mmap_small_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 288 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 289 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 290 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 291 |
|
| 292 |
# Run test apps, wait for them to complete. |
| 293 |
start_test_app |
| 294 |
wait_test_apps |
| 295 |
|
| 296 |
# Take first snapshot, remember first line. |
| 297 |
lttng_snapshot_record "$SESSION_NAME" |
| 298 |
FIRST_LINE="$(trace_first_line "$TRACE_PATH/")" |
| 299 |
diag "First line (1st snapshot): $FIRST_LINE" |
| 300 |
rm -rf "${TRACE_PATH:?}/" |
| 301 |
|
| 302 |
# Run test apps, wait for them to complete. |
| 303 |
start_test_app |
| 304 |
wait_test_apps |
| 305 |
|
| 306 |
# Take second snapshot, remember first line. |
| 307 |
lttng_snapshot_record "$SESSION_NAME" |
| 308 |
FIRST_LINE_2="$(trace_first_line "$TRACE_PATH/")" |
| 309 |
diag "First line (2nd snapshot): $FIRST_LINE_2" |
| 310 |
rm -rf "${TRACE_PATH:?}/" |
| 311 |
|
| 312 |
if [ x"$FIRST_LINE" != x"$FIRST_LINE_2" ]; then |
| 313 |
pass "First snapshot event do not match" |
| 314 |
else |
| 315 |
fail "First snapshot event match" |
| 316 |
fi |
| 317 |
|
| 318 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 319 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 320 |
if ! taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1 ; then |
| 321 |
# If returning to the original CPU set fails, create a mask e.g. FFF |
| 322 |
# which encompasses all possible CPUs. |
| 323 |
mask='' |
| 324 |
iter=0 |
| 325 |
while [[ "${iter}" -lt $(($(get_possible_cpus_count) / 4 + 1)) ]]; do |
| 326 |
mask="${mask}F" |
| 327 |
iter=$((iter+1)) |
| 328 |
done |
| 329 |
taskset -p "${mask}" $$ |
| 330 |
fi |
| 331 |
} |
| 332 |
|
| 333 |
function test_ust_local_snapshot_max_size () |
| 334 |
{ |
| 335 |
local possible_cpus |
| 336 |
local cpus_list |
| 337 |
local subbuf_size |
| 338 |
local subbuf_count |
| 339 |
local snapshot_max_size |
| 340 |
local channel_max_size_per_cpu |
| 341 |
|
| 342 |
IFS=" " read -r -a cpus_list <<< "$(get_online_cpus)" |
| 343 |
|
| 344 |
possible_cpus=$(get_possible_cpus_count) |
| 345 |
subbuf_size=$(getconf PAGE_SIZE) |
| 346 |
subbuf_count=8 |
| 347 |
snapshot_max_size=$((subbuf_size*possible_cpus)) |
| 348 |
channel_max_size_per_cpu=$((subbuf_size*subbuf_count)) |
| 349 |
|
| 350 |
diag "Test local UST snapshots with max size $max_size" |
| 351 |
create_lttng_session_no_output "$SESSION_NAME" |
| 352 |
|
| 353 |
enable_mmap_overwrite_subbuf_ust_channel \ |
| 354 |
"$SESSION_NAME" "$CHANNEL_NAME" \ |
| 355 |
"$subbuf_size" "$subbuf_count" |
| 356 |
|
| 357 |
enable_ust_lttng_event_ok "$SESSION_NAME" "$EVENT_NAME" "$CHANNEL_NAME" |
| 358 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 359 |
|
| 360 |
snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "" "$snapshot_max_size" |
| 361 |
|
| 362 |
# Fill all ring-buffers of the channel; assuming event size of at least one |
| 363 |
# byte |
| 364 |
for cpu in "${cpus_list[@]}"; |
| 365 |
do |
| 366 |
diag "setting affinity to $cpu" |
| 367 |
taskset --cpu-list "$cpu" "$TESTAPP_BIN" \ |
| 368 |
--iter "$channel_max_size_per_cpu" |
| 369 |
done |
| 370 |
diag "Filled channel ring-buffers" |
| 371 |
|
| 372 |
lttng_snapshot_record "$SESSION_NAME" |
| 373 |
|
| 374 |
# Check file size |
| 375 |
local snapshot_size |
| 376 |
snapshot_size=$(find "$TRACE_PATH" -name "${CHANNEL_NAME}_*" \ |
| 377 |
-exec stat -c '%s' {} \; | \ |
| 378 |
awk '{s = s + $1}END{print s}') |
| 379 |
|
| 380 |
if [ "$snapshot_size" -eq "$snapshot_max_size" ]; then |
| 381 |
pass "Tracefiles size sum validation" |
| 382 |
else |
| 383 |
fail "Tracefiles size sum validation" |
| 384 |
diag "Tracefiles size sum: $snapshot_size Expected max: $snapshot_max_size" |
| 385 |
fi |
| 386 |
|
| 387 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 388 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 389 |
|
| 390 |
# Validate test |
| 391 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 392 |
|
| 393 |
if validate_trace "$EVENT_NAME" "$TRACE_PATH/"; then |
| 394 |
# Only delete if successful |
| 395 |
rm -rf "$TRACE_PATH" |
| 396 |
fi |
| 397 |
|
| 398 |
stop_test_apps |
| 399 |
} |
| 400 |
|
| 401 |
function test_ust_local_snapshot_large_metadata () |
| 402 |
{ |
| 403 |
LM_EVENT="tp:tptest1,tp:tptest2,tp:tptest3,tp:tptest4,tp:tptest5" |
| 404 |
LM_PATH="$TESTDIR/utils/testapp" |
| 405 |
LM_NAME="gen-ust-nevents" |
| 406 |
LM_BIN="$LM_PATH/$LM_NAME" |
| 407 |
|
| 408 |
diag "Test local UST snapshots with > 4kB metadata" |
| 409 |
create_lttng_session_no_output "$SESSION_NAME" |
| 410 |
enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 411 |
enable_ust_lttng_event_ok "$SESSION_NAME" $LM_EVENT $CHANNEL_NAME |
| 412 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 413 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 414 |
$LM_BIN --iter 1 --wait 1 |
| 415 |
ok $? "Start application to trace" |
| 416 |
lttng_snapshot_record "$SESSION_NAME" |
| 417 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 418 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 419 |
|
| 420 |
# Validate test |
| 421 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 422 |
if validate_trace $LM_EVENT "$TRACE_PATH/" ; then |
| 423 |
# Only delete if successful |
| 424 |
rm -rf "${TRACE_PATH:?}/" |
| 425 |
fi |
| 426 |
} |
| 427 |
|
| 428 |
function enable_channel_per_uid_mmap_overwrite() |
| 429 |
{ |
| 430 |
sess_name=$1 |
| 431 |
channel_name=$2 |
| 432 |
|
| 433 |
"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel --buffer-ownership=user -u "$channel_name" -s "$sess_name" --output mmap --overwrite >/dev/null 2>&1 |
| 434 |
ok $? "Enable channel $channel_name per UID for session $sess_name" |
| 435 |
} |
| 436 |
|
| 437 |
function test_ust_per_uid_local_snapshot () |
| 438 |
{ |
| 439 |
NR_ITER=-1 |
| 440 |
NR_USEC_WAIT=100 |
| 441 |
diag "Test per-uid local UST snapshots" |
| 442 |
create_lttng_session_no_output "$SESSION_NAME" |
| 443 |
enable_channel_per_uid_mmap_overwrite "$SESSION_NAME" $CHANNEL_NAME |
| 444 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 445 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 446 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 447 |
|
| 448 |
# Returns once the application has at least fired ONE tracepoint. |
| 449 |
start_test_app |
| 450 |
|
| 451 |
lttng_snapshot_record "$SESSION_NAME" |
| 452 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 453 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 454 |
|
| 455 |
# Validate test |
| 456 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 457 |
if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then |
| 458 |
# Only delete if successful |
| 459 |
rm -rf "${TRACE_PATH:?}/" |
| 460 |
fi |
| 461 |
|
| 462 |
stop_test_apps |
| 463 |
} |
| 464 |
|
| 465 |
function test_ust_per_uid_local_snapshot_post_mortem () |
| 466 |
{ |
| 467 |
NR_ITER=-1 |
| 468 |
NR_USEC_WAIT=100 |
| 469 |
|
| 470 |
diag "Test local UST snapshots post-mortem" |
| 471 |
create_lttng_session_no_output "$SESSION_NAME" |
| 472 |
enable_channel_per_uid_mmap_overwrite "$SESSION_NAME" $CHANNEL_NAME |
| 473 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 474 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 475 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 476 |
|
| 477 |
# Returns once the application has at least fired ONE tracepoint. |
| 478 |
start_test_app |
| 479 |
stop_test_apps |
| 480 |
|
| 481 |
lttng_snapshot_record "$SESSION_NAME" |
| 482 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 483 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 484 |
|
| 485 |
# Validate test |
| 486 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 487 |
if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then |
| 488 |
# Only delete if successful |
| 489 |
rm -rf "${TRACE_PATH:?}/" |
| 490 |
fi |
| 491 |
} |
| 492 |
|
| 493 |
function test_ust_local_snapshots () |
| 494 |
{ |
| 495 |
NR_ITER=-1 |
| 496 |
NR_USEC_WAIT=100 |
| 497 |
|
| 498 |
diag "Test $NR_SNAPSHOT local UST snapshots" |
| 499 |
create_lttng_session_no_output "$SESSION_NAME" |
| 500 |
enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 501 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 502 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 503 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 504 |
|
| 505 |
# Returns once the application has at least fired ONE tracepoint. |
| 506 |
start_test_app |
| 507 |
|
| 508 |
for i in $(seq 1 "$NR_SNAPSHOT"); do |
| 509 |
diag "Snapshot $i/$NR_SNAPSHOT" |
| 510 |
rm -rf "$TRACE_PATH/snapshot/*" 2>/dev/null |
| 511 |
lttng_snapshot_record "$SESSION_NAME" |
| 512 |
# Validate test |
| 513 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" $((i - 1)) |
| 514 |
if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then |
| 515 |
# Only delete if successful |
| 516 |
rm -rf "${TRACE_PATH:?}/" |
| 517 |
fi |
| 518 |
done |
| 519 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 520 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 521 |
|
| 522 |
stop_test_apps |
| 523 |
} |
| 524 |
|
| 525 |
function test_ust_local_snapshot_consecutive_no_new_events_discard |
| 526 |
{ |
| 527 |
NR_ITER=10000 |
| 528 |
NR_USEC_WAIT=0 |
| 529 |
|
| 530 |
# When a flush with SWITCH_FLUSH forces delivery of a packet even if it |
| 531 |
# contains no events, this test should fail. The number of iterations should |
| 532 |
# exceed the number of sub-buffers for the channel. |
| 533 |
diag "Test local UST snapshots with consecutive snapshots and no new events on a discard channel" |
| 534 |
create_lttng_session_no_output "$SESSION_NAME" |
| 535 |
enable_mmap_small_discard_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 536 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 537 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 538 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 539 |
|
| 540 |
start_test_app |
| 541 |
wait_test_apps |
| 542 |
FIRST_LINES=() |
| 543 |
COUNTS=() |
| 544 |
for i in $(seq 0 4); do |
| 545 |
# Take first snapshot, remember first line. |
| 546 |
lttng_snapshot_record "$SESSION_NAME" |
| 547 |
FIRST_LINES+=("$(trace_first_line "$TRACE_PATH/")") |
| 548 |
COUNTS+=("$($BABELTRACE_BIN "${TRACE_PATH}" | grep -c "${EVENT_NAME}")") |
| 549 |
rm -rf "${TRACE_PATH:?}/" |
| 550 |
done |
| 551 |
for x in $(seq 1 3); do |
| 552 |
[[ "${FIRST_LINES[0]}" == "${FIRST_LINES[${x}]}" ]] |
| 553 |
ok "${?}" "First lines of snapshot 0 and ${x} match" |
| 554 |
[[ "${COUNTS[0]}" == "${COUNTS[${x}]}" ]] |
| 555 |
ok "${?}" "Event counts in snapshot 0 and ${x} match" |
| 556 |
done |
| 557 |
|
| 558 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 559 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 560 |
} |
| 561 |
|
| 562 |
function test_ust_local_snapshot_consecutive_no_new_events_overwrite |
| 563 |
{ |
| 564 |
NR_ITER=10000 |
| 565 |
NR_USEC_WAIT=0 |
| 566 |
|
| 567 |
# When a flush with SWITCH_FLUSH forces delivery of a packet even if it |
| 568 |
# contains no events, this test should fail. The number of iterations should |
| 569 |
# exceed the number of sub-buffers for the channel. |
| 570 |
diag "Test local UST snapshots with consecutive snapshots and no new events on an overwrite channel" |
| 571 |
create_lttng_session_no_output "$SESSION_NAME" |
| 572 |
enable_mmap_small_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 573 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 574 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 575 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 576 |
|
| 577 |
start_test_app |
| 578 |
wait_test_apps |
| 579 |
FIRST_LINES=() |
| 580 |
COUNTS=() |
| 581 |
for i in $(seq 1 10); do |
| 582 |
# Take first snapshot, remember first line. |
| 583 |
lttng_snapshot_record "$SESSION_NAME" |
| 584 |
FIRST_LINES+=("$(trace_first_line "$TRACE_PATH/")") |
| 585 |
COUNTS+=("$($BABELTRACE_BIN "${TRACE_PATH}" | grep -c "${EVENT_NAME}")") |
| 586 |
rm -rf "${TRACE_PATH:?}/" |
| 587 |
done |
| 588 |
for x in $(seq 1 9); do |
| 589 |
[[ "${FIRST_LINES[0]}" == "${FIRST_LINES[${x}]}" ]] |
| 590 |
ok "${?}" "First line of snapshot 0 and ${x} match" |
| 591 |
[[ "${COUNTS[0]}" == "${COUNTS[${x}]}" ]] |
| 592 |
ok "${?}" "Event counts in snapshot 0 and ${x} match" |
| 593 |
done |
| 594 |
|
| 595 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 596 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 597 |
} |
| 598 |
|
| 599 |
function test_ust_local_snapshot_duplicate_seq_num |
| 600 |
{ |
| 601 |
NR_ITER=5 |
| 602 |
NR_USEC_WAIT=0 |
| 603 |
TESTAPP_ITER_WAIT_FILE="$(mktemp -t "tmp.${FUNCNAME[0]}_tmp_file.XXXXXX")" |
| 604 |
|
| 605 |
local CPU_A="" |
| 606 |
local CPU_B="" |
| 607 |
local IS_X86_64="" |
| 608 |
local XXD="$(command -v xxd)" |
| 609 |
local TEST_SEQNUM="" |
| 610 |
local OLDCPUSET="$(taskset -p $$)" |
| 611 |
local PAGE_SIZE="$(getconf PAGE_SIZE)" |
| 612 |
if file $(command -v bash) | grep -q '64-bit' && uname -a | grep -q 'x86_64' ; then |
| 613 |
IS_X86_64="1" |
| 614 |
fi |
| 615 |
|
| 616 |
if [[ "${IS_X86_64}" && "${XXD}" ]] ; then |
| 617 |
TEST_SEQNUM="1" |
| 618 |
fi |
| 619 |
|
| 620 |
for CPU in $(get_online_cpus) ; do |
| 621 |
if [ -z "${CPU_A}" ] ; then |
| 622 |
CPU_A="${CPU}" |
| 623 |
continue |
| 624 |
fi |
| 625 |
if [ -z "${CPU_B}" ] ; then |
| 626 |
CPU_B="${CPU}" |
| 627 |
fi |
| 628 |
done |
| 629 |
if [[ "${CPU_A}" == "${CPU_B}" ]] || [ -z "${CPU_B}" ] ; then |
| 630 |
# todo |
| 631 |
skip 0 "Need at least two online CPUs to have a quiet channel for testing" 42 |
| 632 |
fi |
| 633 |
|
| 634 |
diag "Test local UST snapshots that should contain packets with duplicate sequence numbers" |
| 635 |
taskset -cp "${CPU_A}" $$ 1>/dev/null 2>&1 |
| 636 |
ok $? "Set current process CPU affinity" |
| 637 |
create_lttng_session_no_output "$SESSION_NAME" |
| 638 |
enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME |
| 639 |
enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME |
| 640 |
start_lttng_tracing_ok "$SESSION_NAME" |
| 641 |
lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH" |
| 642 |
|
| 643 |
# This will produce a set of snapshots. |
| 644 |
# For the cpu that is currently active, the snapshots will contain the following: |
| 645 |
# snapchan_0: events in one or more packets, possibly with a terminal packet |
| 646 |
# snapchan_1 to snapchan_N: 1 event in 1 packet + terminal packet |
| 647 |
start_test_app |
| 648 |
for i in $(seq 0 3) ; do |
| 649 |
touch "${TESTAPP_ITER_WAIT_FILE}" |
| 650 |
# Wait until file disappears |
| 651 |
while [ -f "${TESTAPP_ITER_WAIT_FILE}" ] ; do |
| 652 |
sleep 0.1 |
| 653 |
done |
| 654 |
lttng_snapshot_record "${SESSION_NAME}" |
| 655 |
done |
| 656 |
rm "${TESTAPP_ITER_WAIT_FILE}" |
| 657 |
|
| 658 |
lttng_snapshot_record "${SESSION_NAME}" |
| 659 |
|
| 660 |
stop_lttng_tracing_ok "$SESSION_NAME" |
| 661 |
destroy_lttng_session_ok "$SESSION_NAME" |
| 662 |
|
| 663 |
# Validate test |
| 664 |
validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0 |
| 665 |
if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then |
| 666 |
CPU_A_FILES=() |
| 667 |
while read -r f ; do |
| 668 |
CPU_A_FILES+=("${f}") |
| 669 |
done < <(find "${TRACE_PATH}" -iname "snapchan_${CPU_A}" | sort) |
| 670 |
|
| 671 |
CPU_B_FILES=() |
| 672 |
while read -r f ; do |
| 673 |
CPU_B_FILES+=("${f}") |
| 674 |
done < <(find "${TRACE_PATH}" -iname "snapchan_${CPU_B}" | sort) |
| 675 |
|
| 676 |
for i in $(seq 0 3); do |
| 677 |
A_SIZE="$(du -b "${CPU_A_FILES[${i}]}" | cut -f1)" |
| 678 |
B_SIZE="$(du -b "${CPU_B_FILES[${i}]}" | cut -f1)" |
| 679 |
if [[ "${TEST_SEQNUM}" ]] ; then |
| 680 |
SEQNUM_A1="$(xxd -g 0 -s 0x40 -l 8 "${CPU_A_FILES[${i}]}" | cut -d' ' -f2)" |
| 681 |
SEQNUM_A2="$(xxd -g 0 -s $((0x40 + PAGE_SIZE)) -l 8 "${CPU_A_FILES[${i}]}" | cut -d' ' -f2)" |
| 682 |
SEQNUM_B1="$(xxd -g 0 -s 0x40 -l 8 "${CPU_B_FILES[${i}]}" | cut -d' ' -f2)" |
| 683 |
SEQNUM_B2="$(xxd -g 0 -s $((0x40 + PAGE_SIZE)) -l 8 "${CPU_B_FILES[${i}]}" | cut -d' ' -f2)" |
| 684 |
fi |
| 685 |
|
| 686 |
diag "Snapshot #${i}" |
| 687 |
if [[ "${i}" == "0" ]] ;then |
| 688 |
# On the first iteration, the snapshot on the channel |
| 689 |
# for CPU should have just a single packet |
| 690 |
[[ "${A_SIZE}" -eq "$((PAGE_SIZE))" ]] |
| 691 |
ok $? "CPU_A stream file is one packet large" |
| 692 |
[[ "${B_SIZE}" -eq "$((PAGE_SIZE))" ]] |
| 693 |
ok $? "CPU_B stream file is one packet large" |
| 694 |
if [[ "${TEST_SEQNUM}" ]] ; then |
| 695 |
[[ "${SEQNUM_A1}" == "0000000000000000" ]] |
| 696 |
ok $? "First packet of CPU_A stream file has sequence number 0" |
| 697 |
[[ "${SEQNUM_A2}" == "" ]] |
| 698 |
ok $? "There is no second packet sequence number for CPU_A stream file" |
| 699 |
[[ "${SEQNUM_B1}" == "0000000000000000" ]] |
| 700 |
ok $? "First packet of CPU_B stream file has sequence number 0" |
| 701 |
[[ "${SEQNUM_B2}" == "" ]] |
| 702 |
ok $? "There is no second packet sequence number for CPU_B stream file" |
| 703 |
else |
| 704 |
skip 0 "Sequence number testing not available" 4 |
| 705 |
fi |
| 706 |
else |
| 707 |
# On subsequent iterations, the terminal packet |
| 708 |
# should be present, so there will be 2 packets. |
| 709 |
[[ "${A_SIZE}" -ge "$((PAGE_SIZE))" ]] |
| 710 |
ok $? "CPU_A stream file is greater or equal to one packet large" |
| 711 |
[[ "${B_SIZE}" -eq "$((PAGE_SIZE * 2 ))" ]] |
| 712 |
ok $? "CPU_B stream file is two packets large" |
| 713 |
if [[ "${TEST_SEQNUM}" ]] ; then |
| 714 |
[[ "${SEQNUM_A1}" == "0000000000000000" ]] |
| 715 |
ok $? "First packet of CPU_A stream file has sequence number 0" |
| 716 |
[[ "${SEQNUM_A2}" == "0100000000000000" ]] |
| 717 |
ok $? "Second packet of CPU_A stream file has sequence number 1" |
| 718 |
[[ "${SEQNUM_B1}" == "0000000000000000" ]] |
| 719 |
ok $? "First packet of CPU_B stream file has sequence number 0" |
| 720 |
[[ "${SEQNUM_B2}" == "0100000000000000" ]] |
| 721 |
ok $? "Second packet of CPU_B stream file has sequence number 1" |
| 722 |
else |
| 723 |
skip 0 "Sequence number testing not available" 4 |
| 724 |
fi |
| 725 |
fi |
| 726 |
done |
| 727 |
|
| 728 |
rm -rf "${TRACE_PATH:?}/" |
| 729 |
else |
| 730 |
skip 0 "Need a valid trace" 24 |
| 731 |
fi |
| 732 |
|
| 733 |
stop_test_apps |
| 734 |
taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1 |
| 735 |
} |
| 736 |
|
| 737 |
plan_tests $NUM_TESTS |
| 738 |
|
| 739 |
print_test_banner "$TEST_DESC" |
| 740 |
|
| 741 |
bail_out_if_no_babeltrace |
| 742 |
|
| 743 |
start_lttng_sessiond |
| 744 |
|
| 745 |
tests=( |
| 746 |
test_ust_list_output |
| 747 |
test_ust_local_snapshot |
| 748 |
test_ust_local_snapshot_max_size |
| 749 |
test_ust_per_uid_local_snapshot |
| 750 |
test_ust_per_uid_local_snapshot_post_mortem |
| 751 |
test_ust_local_snapshot_large_metadata |
| 752 |
test_ust_local_snapshots |
| 753 |
test_ust_local_snapshot_small_discard_buffers |
| 754 |
test_ust_local_snapshot_small_overwrite_buffers |
| 755 |
test_ust_local_snapshot_consecutive_no_new_events_discard |
| 756 |
test_ust_local_snapshot_consecutive_no_new_events_overwrite |
| 757 |
test_ust_local_snapshot_duplicate_seq_num |
| 758 |
) |
| 759 |
|
| 760 |
for fct_test in "${tests[@]}"; |
| 761 |
do |
| 762 |
SESSION_NAME=$(randstring 16 0) |
| 763 |
${fct_test} |
| 764 |
done |
| 765 |
|
| 766 |
stop_lttng_sessiond |