/* * 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.string(), "-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.string(), result.size()); } else { ALOGW("%s:", result.string()); } 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