blob: abe5f162d35e922334cc56f700d0658589215b24 [file] [log] [blame]
/*
* Copyright (C) 2013 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 "MediaLog"
//#define LOG_NDEBUG 0
#include <sys/mman.h>
#include <utils/Log.h>
#include <binder/PermissionCache.h>
#include <media/nblog/Merger.h>
#include <media/nblog/NBLog.h>
#include <mediautils/ServiceUtilities.h>
#include "MediaLogService.h"
namespace android {
static const char kDeadlockedString[] = "MediaLogService may be deadlocked\n";
// mMerger, mMergeReader, and mMergeThread all point to the same location in memory
// mMergerShared. This is the local memory FIFO containing data merged from all
// individual thread FIFOs in shared memory. mMergeThread is used to periodically
// call NBLog::Merger::merge() to collect the data and write it to the FIFO, and call
// NBLog::MergeReader::getAndProcessSnapshot to process the merged data.
MediaLogService::MediaLogService() :
BnMediaLogService(),
mMergerShared((NBLog::Shared*) malloc(NBLog::Timeline::sharedSize(kMergeBufferSize))),
mMerger(mMergerShared, kMergeBufferSize),
mMergeReader(mMergerShared, kMergeBufferSize, mMerger),
mMergeThread(new NBLog::MergeThread(mMerger, mMergeReader))
{
mMergeThread->run("MergeThread");
}
MediaLogService::~MediaLogService()
{
mMergeThread->requestExit();
mMergeThread->setTimeoutUs(0);
mMergeThread->join();
free(mMergerShared);
}
void MediaLogService::registerWriter(const sp<IMemory>& shared, size_t size, const char *name)
{
if (!isAudioServerOrMediaServerUid(IPCThreadState::self()->getCallingUid()) || shared == 0 ||
size < kMinSize || size > kMaxSize || name == NULL ||
shared->size() < NBLog::Timeline::sharedSize(size)) {
return;
}
sp<NBLog::Reader> reader(new NBLog::Reader(shared, size, name)); // Reader handled by merger
sp<NBLog::DumpReader> dumpReader(new NBLog::DumpReader(shared, size, name)); // for dumpsys
Mutex::Autolock _l(mLock);
mDumpReaders.add(dumpReader);
mMerger.addReader(reader);
}
void MediaLogService::unregisterWriter(const sp<IMemory>& shared)
{
if (!isAudioServerOrMediaServerUid(IPCThreadState::self()->getCallingUid()) || shared == 0) {
return;
}
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mDumpReaders.size(); ) {
if (mDumpReaders[i]->isIMemory(shared)) {
mDumpReaders.removeAt(i);
// TODO mMerger.removeReaders(shared)
} else {
i++;
}
}
}
bool MediaLogService::dumpTryLock(Mutex& mutex)
{
bool locked = false;
for (int i = 0; i < kDumpLockRetries; ++i) {
if (mutex.tryLock() == NO_ERROR) {
locked = true;
break;
}
usleep(kDumpLockSleepUs);
}
return locked;
}
status_t MediaLogService::dump(int fd, const Vector<String16>& args __unused)
{
if (!(isAudioServerOrMediaServerUid(IPCThreadState::self()->getCallingUid())
|| dumpAllowed())) {
dprintf(fd, "Permission Denial: can't dump media.log from pid=%d, uid=%d\n",
IPCThreadState::self()->getCallingPid(),
IPCThreadState::self()->getCallingUid());
return NO_ERROR;
}
if (args.size() > 0) {
const String8 arg0(args[0]);
if (!strcmp(arg0.c_str(), "-r")) {
// needed because mReaders is protected by mLock
bool locked = dumpTryLock(mLock);
// failed to lock - MediaLogService is probably deadlocked
if (!locked) {
String8 result(kDeadlockedString);
if (fd >= 0) {
write(fd, result.c_str(), result.size());
} else {
ALOGW("%s:", result.c_str());
}
return NO_ERROR;
}
for (const auto &dumpReader : mDumpReaders) {
if (fd >= 0) {
dprintf(fd, "\n%s:\n", dumpReader->name().c_str());
dumpReader->dump(fd, 0 /*indent*/);
} else {
ALOGI("%s:", dumpReader->name().c_str());
}
}
mLock.unlock();
} else {
mMergeReader.dump(fd, args);
}
}
return NO_ERROR;
}
status_t MediaLogService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
uint32_t flags)
{
return BnMediaLogService::onTransact(code, data, reply, flags);
}
void MediaLogService::requestMergeWakeup() {
mMergeThread->wakeup();
}
} // namespace android