[DO NOT MERGE] Crash the process when midi extraction times out am: 166a84bfe3 (80127c21) · Commits · e / os / android_frameworks_av

media/extractors/midi/Android.bp

+3 −2

Original line number	Diff line number	Diff line
		@@ -14,7 +14,9 @@ cc_library_shared {
		static_libs: [
		"libmedia_midiiowrapper",
		"libsonivox",
		"libstagefright_foundation"
		"libstagefright_foundation",
		"libwatchdog",
		"libbase",
		],
		name: "libmidiextractor",
		relative_install_path: "extractors",
		@@ -35,5 +37,4 @@ cc_library_shared {
		"signed-integer-overflow",
		],
		},

		}

media/extractors/midi/MidiExtractor.cpp

+12 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MediaErrors.h>
		#include <libsonivox/eas_reverb.h>
		#include <watchdog/Watchdog.h>

		namespace android {

		@@ -116,6 +117,7 @@ media_status_t MidiSource::read(
		MediaBufferHelper *outBuffer, const ReadOptions options)
		{
		ALOGV("MidiSource::read");

		MediaBufferHelper *buffer;
		// process an optional seek request
		int64_t seekTimeUs;
		@@ -139,6 +141,8 @@ status_t MidiSource::init()
		}

		// MidiEngine
		using namespace std::chrono_literals;
		static constexpr auto kTimeout = 10s;

		MidiEngine::MidiEngine(CDataSource *dataSource,
		AMediaFormat *fileMetadata,
		@@ -147,6 +151,8 @@ MidiEngine::MidiEngine(CDataSource *dataSource,
		mEasHandle(NULL),
		mEasConfig(NULL),
		mIsInitialized(false) {
		Watchdog watchdog(kTimeout);

		mIoWrapper = new MidiIoWrapper(dataSource);
		// spin up a new EAS engine
		EAS_I32 temp;
		@@ -186,6 +192,8 @@ MidiEngine::MidiEngine(CDataSource *dataSource,
		}

		MidiEngine::~MidiEngine() {
		Watchdog watchdog(kTimeout);

		if (mEasHandle) {
		EAS_CloseFile(mEasData, mEasHandle);
		}
		@@ -217,12 +225,16 @@ status_t MidiEngine::releaseBuffers() {
		}

		status_t MidiEngine::seekTo(int64_t positionUs) {
		Watchdog watchdog(kTimeout);

		ALOGV("seekTo %lld", (long long)positionUs);
		EAS_RESULT result = EAS_Locate(mEasData, mEasHandle, positionUs / 1000, false);
		return result == EAS_SUCCESS ? OK : UNKNOWN_ERROR;
		}

		MediaBufferHelper* MidiEngine::readBuffer() {
		Watchdog watchdog(kTimeout);

		EAS_STATE state;
		EAS_State(mEasData, mEasHandle, &state);
		if ((state == EAS_STATE_STOPPED) \|\| (state == EAS_STATE_ERROR)) {

media/libwatchdog/Android.bp

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 The Android Open Source Project
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		cc_library {
		name: "libwatchdog",
		srcs: [
		"Watchdog.cpp",
		],
		export_include_dirs: ["include"],
		shared_libs: [
		"liblog",
		],
		static_libs: [
		"libbase",
		],
		target: {
		windows: {
		enabled: false,
		},
		darwin: {
		enabled: false,
		},
		},
		}

media/libwatchdog/Watchdog.cpp

0 → 100644

+63 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_TAG "Watchdog"

		#include <watchdog/Watchdog.h>

		#include <android-base/logging.h>
		#include <android-base/threads.h>
		#include <signal.h>
		#include <time.h>
		#include <cstring>
		#include <utils/Log.h>

		namespace android {

		Watchdog::Watchdog(::std::chrono::steady_clock::duration timeout) {
		// Create the timer.
		struct sigevent sev;
		sev.sigev_notify = SIGEV_THREAD_ID;
		sev.sigev_notify_thread_id = base::GetThreadId();
		sev.sigev_signo = SIGABRT;
		sev.sigev_value.sival_ptr = &mTimerId;
		int err = timer_create(CLOCK_MONOTONIC, &sev, &mTimerId);
		if (err != 0) {
		PLOG(FATAL) << "Failed to create timer";
		}

		// Start the timer.
		struct itimerspec spec;
		memset(&spec, 0, sizeof(spec));
		auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(timeout);
		LOG_ALWAYS_FATAL_IF(timeout.count() <= 0, "Duration must be positive");
		spec.it_value.tv_sec = ns.count() / 1000000000;
		spec.it_value.tv_nsec = ns.count() % 1000000000;
		err = timer_settime(mTimerId, 0, &spec, nullptr);
		if (err != 0) {
		PLOG(FATAL) << "Failed to start timer";
		}
		}

		Watchdog::~Watchdog() {
		// Delete the timer.
		int err = timer_delete(mTimerId);
		if (err != 0) {
		PLOG(FATAL) << "Failed to delete timer";
		}
		}

		} // namespace android

media/libwatchdog/include/watchdog/Watchdog.h

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_WATCHDOG_H
		#define ANDROID_WATCHDOG_H

		#include <chrono>
		#include <time.h>

		namespace android {

		/*
		* An RAII-style object, which would crash the process if a timeout expires
		* before the object is destroyed.
		* The calling thread would be sent a SIGABORT, which would typically result in
		* a stack trace.
		*
		* Sample usage:
		* {
		* Watchdog watchdog(std::chrono::milliseconds(10));
		* DoSomething();
		* }
		* // If we got here, the function completed in time.
		*/
		class Watchdog final {
		public:
		Watchdog(std::chrono::steady_clock::duration timeout);
		~Watchdog();

		private:
		timer_t mTimerId;
		};

		} // namespace android

		#endif // ANDROID_WATCHDOG_H