[DO NOT MERGE] Crash the process when midi extraction times out (166a84bf) · Commits · e / os / android_frameworks_av

media/extractors/midi/Android.bp

+3 −2

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

	}		}

media/extractors/midi/MidiExtractor.cpp

+12 −0

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

	namespace android {		namespace android {

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

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

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

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

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

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

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

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

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

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

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

media/libwatchdog/Android.bp

0 → 100644

+35 −0

Original line number	Original line	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	Original line	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	Original line	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