#!/bin/sh

set -e

# The maximum number of trace-files to store on the SD card
BS_MAX_TRACE_FILES=${BS_MAX_TRACE_FILES:-5}
BS_TRACE_NAME=${BS_TRACE_NAME:-bs}
LTTNG="lttng"
EXPORT_DIR=""
BS_TRACE_GROUPS="default"
TRACE_CHANNEL="channel0"
HIGH_FREQ_TRACE_CHANNEL="channel_high_freq"
PROFILE=""

die() {
  echo $@ 1>&2
  exit 1
}

# Converts the arguments into a CSV string returned via __csv global
__csv=""
to_csv() {
    __csv=""
    for s in "$@"; do
        [ -z "${__csv}" ] || __csv="${__csv},"
        __csv="${__csv}${s}"
    done
}

lttng_set_event() {
    [ $# -gt 3 ] || die "lttng_set_event: Missing arguments: " "$@"

    local cmd="$1"
    [ "${cmd}" = 'enable-event' -o "${cmd}" = 'disable-event' ] || die "lttng_set_event: Bad command ${cmd}"

    local channel="$2"

    local domain="$3"
    [ "${domain}" = "-u" -o "${domain}" = "-k" ] || die "lttng_set_event: Invalid domain ${domain}"

    shift 3
    to_csv "$@"

    # LTTng will complain if the tracepoint is missing or already enabled.
    # Ignore these errors. Failure to set one tracepoint should not cause
    # all tracepoints to fail.
    echo ${LTTNG} "${cmd}" -s "${BS_TRACE_NAME}" -c "${channel}" "${domain}" "${__csv}"
    ${LTTNG} "${cmd}" -s "${BS_TRACE_NAME}" -c "${channel}" "${domain}" "${__csv}" || true
}

enable_high_freq_event() {
    lttng_set_event enable-event "${HIGH_FREQ_TRACE_CHANNEL}" -u "$@"
}

disable_high_freq_event() {
    lttng_set_event disable-event "${HIGH_FREQ_TRACE_CHANNEL}" -u "$@"
}

enable_user_event() {
    lttng_set_event enable-event "${TRACE_CHANNEL}" -u "$@"
}

disable_user_event() {
    lttng_set_event disable-event "${TRACE_CHANNEL}" -u "$@"
}

enable_kernel_event() {
    lttng_set_event enable-event "${TRACE_CHANNEL}" -k "$@"
}

disable_kernel_event() {
    lttng_set_event disable-event "${TRACE_CHANNEL}" -k "$@"
}

qt_traces() {
    enable_user_event \
        'brightsign_qt_platformsupport:*' \
        'brightsign_qt_gui:*' \
        'brightsign_qt_widgets:*' \
        'brightsign_qt_webengine_widgets:*' \
        'brightsign_scripting:HtmlWidgetQt*'

}

chromium_traces() {
    echo BS_CHROMIUM_TRACE=\"${BS_CHROMIUM_TRACE}\"
    if [ -z "${BS_CHROMIUM_TRACE}" ]; then
        echo "Warning: BS_CHROMIUM_TRACE: No trace categories defined"
    fi

    enable_user_event 'brightsign_chromium:AddTraceEvent'
}

bs_chromium_traces() {
    enable_user_event \
        'brightsign_chromium:BackToBackBeginFrameSource_*' \
        'brightsign_chromium:BeginFrameSourceBase_CallOnBeginFrame' \
        'brightsign_chromium:Compositor_Draw_duration' \
        'brightsign_chromium:CopyTextureCHROMIUMResourceManager_DoCopyTextureWithTransform' \
        'brightsign_chromium:DelayBasedTimeSource_*' \
        'brightsign_chromium:DelegatingRenderer_*' \
        'brightsign_chromium:Display_DrawAndSwap_*' \
        'brightsign_chromium:DisplayListRasterSource_*' \
        'brightsign_chromium:FreeTileResources' \
        'brightsign_chromium:FreeLowerPriorityTileResources' \
        'brightsign_chromium:GLES2*' \
        'brightsign_chromium:GraphicsContext_*' \
        'brightsign_chromium:GpuMemoryManager_*' \
        'brightsign_chromium:GrGpuGL_uploadTexData' \
        'brightsign_chromium:GrResourceCache_*' \
        'brightsign_chromium:GpuRasterizer_*' \
        'brightsign_chromium:LayerTreeHost_*' \
        'brightsign_chromium:Program_*' \
        'brightsign_chromium:ResourceProvider_*' \
        'brightsign_chromium:Scheduler_*' \
        'brightsign_chromium:SkMultiPictureDraw_*' \
        'brightsign_chromium:SkPaint2GrPaintNoShader_*' \
        'brightsign_chromium:SkPaint2GrPaint_*' \
        'brightsign_chromium:SyncControlVSyncProvider_*' \
        'brightsign_chromium:Texture*' \
        'brightsign_chromium:ThreadProxy_*' \

}

capture_traces() {
    enable_user_event 'brightsign_roku_dfb:CaptureThread*'
}

# GL rendering from the application level
render_traces() {
    bs_chromium_traces
    qt_traces
}

# Just the v-sync callback so ctf2json can highlight v-sync boundaries
vsync_traces() {
    enable_user_event \
        'brightsign_nexus:NEXUS_Display_P_VecInterrupt_isr'  \
        'brightsign_vc5_nxpl:bs_native_window_on_vsync'

}

# Nexus compositor
compositor_traces() {
    enable_user_event \
        'brightsign_nexus:NEXUS_Display_P_VecInterrupt_isr'  \
        'brightsign_chromium:DelayBasedTimeSource_OnTimerFired' \
        'brightsign_chromium:DelayBasedTimeSource_SetTimebaseAndInterval' \
        'brightsign_chromium:ThreadProxy_DrawSwapInternal_duration' \
        'brightsign_chromium:DelayBasedTimeSource_PostNextTickTask' \
        'brightsign_chromium:SyncControlVSyncProvider_GetVSyncParameters' \
        'brightsign_vc5_nxpl:*' \
        'brightsign_nxpl:*' \
        'brightsign_scripting:Ticker*'

    vsync_traces
    bscompositor_traces
}

bscompositor_traces() {
    enable_user_event \
        'brightsign_scripting:Compositor_*' \
        'brightsign_scripting:GLCompositor_*' \
        'brightsign_scripting:GLRenderer_*'

}

gl_api_traces() {
    enable_user_event \
       'brightsign_v3d:eglWaitGL_*' \
       'brightsign_v3d:eglMakeCurrent_*' \
       'brightsign_v3d:eglSwapBuffers_*' \
       'brightsign_v3d:glBindFramebuffer*' \
       'brightsign_v3d:glBindTexture*' \
       'brightsign_v3d:glClear*' \
       'brightsign_v3d:glGenerateMipMap*' \
       'brightsign_v3d:glFinish*' \
       'brightsign_v3d:glFlush*' \
       'brightsign_v3d:glTexImage2D*' \
       'brightsign_v3d:glTexSubImage2D*' \
       'brightsign_v3d:glViewport*' \
       'brightsign_vc5:*'

    }

# Internal GL driver tracing
gl_driver_traces() {
    enable_user_event \
        'brightsign_v3d:khrn_job*' \
        'brightsign_v3d:glDrawElements_*' \
        'brightsign_v3d:khrn_fast_copy_to_tf*' \
        'brightsign_v3d:khrn_render_state_flush_*' \
        'brightsign_v3d:create_master_cl*' \
        'brightsign_v3d:glxx_install_framebuffer_*' \
        'brightsign_v3d:egl_*' \
        'brightsign_v3d:glxx_lock_server_state_*' \
        'brightsign_v3d:glxx_get_client_state' \
        'brightsign_vc5_nxpl:khrn_job*' \
        'brightsign_vc5_nxpl:DispSurfaceGetInfo*' \
        'brightsign_vc5_nxpl:NXPL_Pixmap*' \
        'brightsign_vc5:*'

    gl_api_traces
}

# Track memory for Skia objects allocated on the malloc heap
skia_mem_traces() {
    enable_user_event \
       'brightsign_chromium:sk_malloc' \
       'brightsign_chromium:sk_malloc_*' \
       'brightsign_chromium:sk_free' \
       'brightsign_chromium:sk_alloc_*' \
       'brightsign_chromium:sk_free_*'

}

malloc_log_traces() {
    enable_user_event \
        'brightsign_chromium:calloc' \
        'brightsign_chromium:free' \
        'brightsign_chromium:malloc' \
        'brightsign_chromium:memalign' \
        'brightsign_chromium:pvalloc' \
        'brightsign_chromium:realloc' \
        'brightsign_chromium:unchecked_malloc' \
        'brightsign_chromium:valloc' \
        'brightsign_chromium:sk_malloc' \
        'brightsign_chromium:sk_malloc_*' \
        'brightsign_chromium:sk_free' \
        'brightsign_chromium:sk_alloc_*' \
        'brightsign_chromium:sk_free_*' \
        'brightsign_v3d:platform_malloc' \
        'brightsign_v3d:platform_free' \
        'brightsign_v3d:allocate_malloc' \
        'brightsign_v3d:malloc_size_counter' \
        'brightsign_v3d:free_malloc' \
        'brightsign_chromium:MemoryCache_live_counter' \
        'brightsign_chromium:MemoryCache_dead_counter'

}

nexus_td_traces() {
    enable_user_event \
        'brightsign_nexus:acap_event' \
        'brightsign_nexus:bvdc_event' \
        'brightsign_nexus:bxdm_event'

}

# Track WebKit memory cache
webkit_mem_traces() {
    enable_user_event \
        'brightsign_chromium:MemoryCache*' \
        'brightsign_chromium:Resource*' \
        'brightsign_chromium:ImageDecoder*' \
        'brightsign_chromium:ImageResource*' \
        'brightsign_chromium:BitmapImage*'

}

# GL memory allocations on the BMEM heaps
gpu_mem_traces() {
    enable_user_event \
        'brightsign_nexus:bv3d_bin*' \
        'brightsign_nexus:NEXUS_Memory*' \
        'brightsign_nexus:BMMA_range_allocator_counter' \
        'brightsign_v3d:allocate_wrapped' \
        'brightsign_v3d:free_wrapped' \
        'brightsign_v3d:allocate_direct' \
        'brightsign_v3d:free_direct' \
        'brightsign_v3d:mem_alloc_stats' \
        'brightsign_v3d:mem_alloc_size_counter' \
        'brightsign_nxpl:ExclusiveDisplay_DispBuffer*' \
        'brightsign_v3d:glTex*' \
        'brightsign_v3d:glFramebuffer*' \
        'brightsign_v3d:glBindFramebuffer*' \
        'brightsign_v3d:allocate_texture' \
        'brightsign_v3d:allocate_texture_name' \
        'brightsign_v3d:free_texture' \
        'brightsign_v3d:allocate_bcg_shader' \
        'brightsign_v3d:allocate_glxx_shader' \
        'brightsign_v3d:allocate_glxx_buffer' \
        'brightsign_v3d:allocate_program' \
        'brightsign_v3d:release_program' \
        'brightsign_v3d:shader_link_result_term*' \
        'brightsign_v3d:free_program' \
        'brightsign_v3d:allocate_bcg_shader_code' \
        'brightsign_v3d:glxx_schedule*' \
        'brightsign_v3d:gl20_link_result_create_shaders' \
        'brightsign_v3d:gl20_link_result_get_shaders' \
        'brightsign_v3d:program_acquire' \
        'brightsign_v3d:program_use' \
        'brightsign_v3d:program_release' \
        'brightsign_v3d:try_delete_program' \
        'brightsign_v3d:shader_acqurie' \
        'brightsign_v3d:shader_release' \
        'brightsign_v3d:try_delete_shader' \
        'brightsign_v3d:glDeleteProgram' \
        'brightsign_v3d:glDeleteShader' \
        'brightsign_v3d:glDetachShader' \
        'brightsign_chromium:GrResourceCache_counter'

}

fmem_traces() {
    enable_user_event \
        'brightsign_v3d:fmem_fix' \
        'brightsign_v3d:mem_release_multiple' \
        'brightsign_v3d:fmem_interlock' \
        'brightsign_v3d:interlock_release' \
        'brightsign_v3d:interlock_transfer'

    gl_driver_traces
}

image_decode_traces() {
    enable_user_event \
        'brightsign_chromium:ImageDecoder_*'

}

autotest_traces() {
    enable_user_event \
        'brightsign_scripting:autotest*'

}

bsjs_traces() {
    enable_user_event \
        'brightsign_javascript:JS_*' \
        'brightsign_chromium:BSMessagePort_*' \
        'brightsign_chromium:ExecutionContext*' \
        'brightsign_chromium:BrightSignBridge*' \
        'brightsign_scripting:HtmlWidgetQt_CreateQtWebEngine' \
        'brightsign_scripting:HtmlWidgetQt_SetURL'

}

bvp_traces() {
    enable_user_event \
        'brightsign_roku_dfb:SourceBVP_*' \
        'brightsign_roku_dfb:ProxyPlaypump_*' \
        'brightsign_roku_dfb:BVPStreamSink_*' \

   stc_traces
   videoglue_traces
}

stc_traces() {
    enable_user_event \
    'brightsign_nexus:BXDM_PP*' \
    'brightsign_nexus:NEXUS_StcChannel_P_SetStc_isr' \
    'brightsign_nexus:NEXUS_VideoDecoder_P_PtsError_isr' \
    'brightsign_nexus:NEXUS_VideoDecoder_decoded_frames_counter' \
    'brightsign_nexus:NEXUS_VideoDecoder_dropped_frames_counter' \
    'brightsign_nexus:NEXUS_AudioDecoder_P_AudioTsmFail_isr' \

}

lttng_ust_traces() {
    enable_user_event \
        'lttng_*'
}

tracef_traces() {
    # Always enable tracef
    enable_user_event \
        'lttng_ust_tracef:*'

}

shader_mem_traces() {
    enable_user_event \
        'brightsign_v3d:allocate_malloc' \
        'brightsign_v3d:malloc_size_counter' \
        'brightsign_v3d:free_malloc' \
        'brightsign_v3d:allocate_shader*' \
        'brightsign_v3d:free_shader*' \
        'brightsign_v3d:allocate_program' \
        'brightsign_v3d:program_acquire' \
        'brightsign_v3d:program_use' \
        'brightsign_v3d:program_release' \
        'brightsign_v3d:try_delete_program' \
        'brightsign_v3d:try_delete_shader' \
        'brightsign_v3d:free_program' \
        'brightsign_v3d:allocate_shader' \
        'brightsign_v3d:free_shader' \
        'brightsign_v3d:platform_malloc' \
        'brightsign_v3d:platform_free'
}

videoglue_traces() {
    enable_user_event \
        'brightsign_scripting:VideoGlueQt_*' \
        'brightsign_chromium:WebMediaPlayerBrcm_*' \
        'brightsign_chromium:MediaPlayerBridgeBrightsign_*' \
        'brightsign_chromium:MediaPlayerBridgeManager_*' \
        'brightsign_chromium:HTMLMediaElement_*'
}

transposer_traces() {
    enable_high_freq_event \
        'brightsign_roku_dfb:Transposer_*' \
        'brightsign_nexus:BVDC_P_Window_ApplyChanges_isr' \
        'brightsign_nexus:BVDC_P_Window_Writer_isr' \
        'brightsign_nexus:BVDC_Window_SetVisibility' \
        'brightsign_nexus:NEXUS_Graphics2D_Checkpoint_*'

    videoglue_traces
    vsync_traces
}

kernel_traces() {
    lttng_set_event enable-event "${TRACE_CHANNEL}" -k \
        sched_switch \
        sched_process_fork
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t pid -t prio
}

irq_traces() {
    lttng_set_event enable-event "${TRACE_CHANNEL}" -k \
        irq_handler_entry \
        irq_handler_exit

    kernel_traces
}

cpu_cache_traces() {
    kernel_traces
    # Supported but disabled because it's limited to 8 contexts
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:cpu-cycles
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:page-fault
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:cache-misses
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:LLC-loads
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:LLC-stores

    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-loads
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-load-misses
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-stores
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-store-misses

    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:LLC-load-misses
    ${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:LLC-store-misses

    # Unknown type
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:stalled-cycles-frontend
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:stalled-cycles-backend
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-prefetches
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:L1-dcache-prefetch-misses
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:dTLBs-loads
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:dTLBs-load-misses
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:dTLBs-stores
    #${LTTNG} add-context -k -s "${BS_TRACE_NAME}" -t perf:cpu:dTLBs-store-misses
}

syscall_traces() {
    ${LTTNG} enable-event -c "${TRACE_CHANNEL}" -k --syscall --all || true
}

# Default traces - these are enabled in release builds for (future) inclusion
# in crash-dumps if no other trace configuration is defined.
default_traces() {
    # Client window traces except for the verbose texture and render update
    # Include the autotest and videoglue traces to minimise the number
    # of processes launched in normal startup
    enable_user_event \
        'brightsign_scripting:Compositor_ClientWindow_ctor' \
        'brightsign_scripting:Compositor_ClientWindow_dtor' \
        'brightsign_scripting:Compositor_ClientWindow_Raise' \
        'brightsign_scripting:Compositor_ClientWindow_Lower' \
        'brightsign_scripting:autotest*' \
        'brightsign_scripting:VideoGlueQt_*' \
        'brightsign_chromium:WebMediaPlayerBrcm_*' \
        'brightsign_chromium:MediaPlayerBridgeBrightsign_*' \
        'brightsign_chromium:MediaPlayerBridgeManager_*' \
        'brightsign_chromium:HTMLMediaElement_*'

    enable_high_freq_event \
        'brightsign_nexus:NEXUS_Display_P_VecInterrupt_isr'  \
        'brightsign_scripting:Compositor_CloneScene*' \
        'brightsign_scripting:Compositor_Update*' \
        'brightsign_scripting:Compositor_Signal*' \
        'brightsign_scripting:GLRenderer_StartRenderPass_*' \
        'brightsign_roku_dfb:Transposer_*' \
        'brightsign_nexus:NEXUS*' \
        'brightsign_nexus:BVDC*' \
        'brightsign_nexus:BGRC*' \
        'brightsign_nexus:BMMA*'
}

enable_trace_groups() {
    echo "BS_TRACE_GROUPS: ${1}"
    for t in $1; do
        case $t in
            autotest)
                autotest_traces
                ;;
            default)
                default_traces
                ;;
            bsjs)
                bsjs_traces
                ;;
            bvp)
                bvp_traces
                ;;
            capture)
                capture_traces
                ;;
            bschromium)
                bs_chromium_traces
                ;;
            bscompositor)
                bscompositor_traces
                ;;
            chromium)
                chromium_traces
                ;;
            compositor)
                compositor_traces
                ;;
            fmem)
                fmem_traces
                ;;
            gl_api)
                gl_api_traces
                ;;
            gl_driver)
                gl_driver_traces
                ;;
            gpu_mem)
                gpu_mem_traces
                ;;
            image_decode)
                image_decode_traces
                ;;
            malloc_log)
                malloc_log_traces
                ;;
            nexus_td)
                nexus_td_traces
                ;;
            kernel)
                kernel_traces
                ;;
            cpu_cache)
                cpu_cache_traces
                ;;
            irq)
                irq_traces
                ;;
            qt)
                qt_traces
                ;;
            render)
                render_traces
                ;;
            syscall)
                syscall_traces
                ;;
            shader_mem)
                shader_mem_traces
                ;;
            skia_mem)
                skia_mem_traces
                ;;
            stc)
                stc_traces
                ;;
            tracef)
                tracef_traces
                ;;
            transposer)
                transposer_traces
                ;;
            videoglue)
                videoglue_traces
                ;;
            vsync)
                vsync_traces
                ;;
            webkit_mem)
                webkit_mem_traces
                ;;
            \?)
                echo "Unknown trace group: $p" >&2
                exit -1
                ;;
        esac
    done
}


start_tracing() {
    echo Clearing old trace sessions
    ${LTTNG} stop "${BS_TRACE_NAME}" > /dev/null 2>&1 || true
    ${LTTNG} destroy "${BS_TRACE_NAME}" > /dev/null 2>&1 || true

    if [ -d "${LTTNG_HOME}" ]; then
        rm -rf ${LTTNG_HOME}/lttng-traces
    fi
    mkdir -p ${LTTNG_HOME}/lttng-traces

    echo Starting lttng.sh
    /etc/init.d/lttng.sh start

    enable_trace_groups "$(echo "${BS_TRACE_GROUPS}" | tr -cd '[:alnum:][:blank:]_')"

    if [ ! -z "${PROFILE}" ]; then
        lttng_ust_traces
    fi

    for channel in "${TRACE_CHANNEL}" "${HIGH_FREQ_TRACE_CHANNEL}"; do
        ${LTTNG} add-context -s "${BS_TRACE_NAME}" -c "${channel}" -u -t vpid
        ${LTTNG} add-context -s "${BS_TRACE_NAME}" -c "${channel}" -u -t vtid
        ${LTTNG} add-context -s "${BS_TRACE_NAME}" -c "${channel}" -u -t procname
    done

    ${LTTNG} start "${BS_TRACE_NAME}"
    cd "${LTTNG_HOME}"
    mkdir -p lttng-traces
    uname -a > "lttng-traces/system-info.txt"

    echo "LTTng tracing started"
}

export_trace_files() {
    if [ "${EXPORT_TRACES}" == "0" ]; then
        return
    fi
    EXPORT_TRACES="1"

    if [ ! -d "${EXPORT_DIR}" ]; then
        echo "${EXPORT_DIR} is not a directory"
        return
    fi

    # Only store the last few trace files
    cd "${EXPORT_DIR}"
    ( ls -rt bs-*.trace 2>/dev/null | head -n -${BS_MAX_TRACE_FILES} | xargs rm -f ) || true

    # Find the next id number
    id=$(ls -r *.trace 2>/dev/null | head -n 1 | cut -c4-8 || true)
    if [ -z "${id}" ]; then
        id="0"
    else
        id=$(expr "${id}" + 1)
    fi
    export_file=$(printf "bs-%05d.trace" "${id}")
    export_file="${EXPORT_DIR}/${export_file}"

    cd "${LTTNG_HOME}"
    if [ ! -d lttng-traces ]; then
        die "Missing trace directory ${LTTNG_HOME}/lttng-traces"
    fi

    # Identity the trace files
    dmesg > "${LTTNG_HOME}/lttng-traces/dmesg.txt"

    echo "Exporting trace files to ${export_file}"
    rm -f "${export_file}" "${export_file}.bz2"
    tar -cf "${export_file}" lttng-traces

    # Gzip is quicker than bzip for large trace files
    gzip "${export_file}"
    mv -f "${export_file}.gz" "${export_file}"
}

stop_tracing() {
    lttng list "${BS_TRACE_NAME}" > "${LTTNG_HOME}/lttng-traces/lttng-info.txt" || true
    ${LTTNG} stop "${BS_TRACE_NAME}" || true
}

usage() {
    cat <<EOF
    trace-brightsign [-g "event groups"] [-e "export_dir" ]

    Resets the 'bs' trace session and starts brightsign. The default trace events
    are "autotest videoglue vsync"

    When brightsign exits the lttng 'bs' session is automatically stopped.

    -e Export traces [export_dir]
    After Brightsign process has stopped export traces to export_dir

    -g Select event groups and start a new trace session
    autotest      roLTTng tracepoints
    bscompositor  Brightsign widget compositor
    bschromium    Brightsign custom Chromium trace messages
    bsjs          Brightsign JavaScript
    bvp           Brightsign Video Proxy
    capture       Capture Thread
    chromium      Chromium trace-event messages. Define trace categories via BS_CHROMIUM_TRACE environemnt variable e.g. cc
    compositor    Nexus compositor
    cpu_cache     Include CPU cache in kernel traces
    default       The default trace domains enabled in release mode.
    fmem          GL job control - VERY VERBOSE
    kernel        Kernel scheduling & gpio
    gl_api        GL public API traces
    gl_driver     GL driver internals
    image_decode  Image Decoder
    irq           Interrupts
    malloc_log    Log all calls to malloc/free.
    nexus_td      BXDM, BVDC, Nexus 2D time-doctor tracepoints.
    gpu_mem       GL driver allocations on the graphics BMEM heap
    qt            Qt and QtWebengine traces
    render        High level render traces
    shader_mem    GLSL allocations on the malloc heap
    skia_mem      Skia allocations on the malloc heap
    stc           A/V decoder STC,PTS traces
    syscall       Track all syscalls
    tracef        Enable all trace tracepoints
    transposer    VideoGlue and transposition
    videoglue     VideoGlueQt API
    vsync         v-sync event (required for highlight v-sync in traceviewer)
    webkit_mem    Webkit memory cache

    -l Live mode
    Enable live mode (for use with the LTTng Relay Daemon)

    -r Specify the LTTng relay daemon URI
     e.g. net://hostname/

    -p Enable LTTng CallStack profile (EXPERIMENTAL)
    This only works if the code is built with -finstrument-functions

    -h Displays this message
EOF
}

[ -n "${LTTNG_HOME}" ] || die "LTTNG_HOME not defined"

EXPORT_TRACES=0
while getopts ":g:e:r:hlp" opt; do
    case "${opt}" in
        e)
            EXPORT_TRACES=1
            EXPORT_DIR="${OPTARG}"
            [ -d "${EXPORT_DIR}" ] || die "Export directory '${EXPORT_DIR}' does not exist "
            ;;
        g)
            BS_TRACE_GROUPS="${OPTARG}"
            ;;
        l)
            export BS_LTTNG_LIVE=1
            ;;
        h)
            usage
            exit 0
            ;;
        p)
            PROFILE=1
            ;;
        r)
            export BS_LTTNG_RELAY_URL="${OPTARG}"
            ;;
        *)
            echo "Invalid option: -${opt}" >&2
            usage
            die
            ;;
    esac
done

if [ "${EXPORT_TRACES}" == "1" ]; then
    stop_tracing
    export_trace_files
else
    source /etc/default/lttng
    echo BS_LTTNG_TRACEFILE_SIZE="${BS_LTTNG_TRACEFILE_SIZE}"
    start_tracing
fi
