static int initCtx(uid_t uid, int pid, struct ctx *ctx)
{
int ret;
char path[PROCESSGROUP_MAX_PATH_LEN] = {0};
convertUidPidToPath(path, sizeof(path), uid, pid);
strlcat(path, PROCESSGROUP_CGROUP_PROCS_FILE, sizeof(path));
int fd = open(path, O_RDONLY);
if (fd < 0) {
ret = -errno;
SLOGW("failed to open %s: %s", path, strerror(errno));
return ret;
}
ctx->fd = fd;
ctx->buf_ptr = ctx->buf;
ctx->buf_len = 0;
ctx->initialized = true;
SLOGV("Initialized context for %s", path);
return 0;
}
static void removeUidProcessGroups(const char *uid_path)
{
std::unique_ptr<DIR, decltype(&closedir)> uid(opendir(uid_path), closedir);
if (uid != NULL) {
struct dirent cur;
struct dirent *dir;
while ((readdir_r(uid.get(), &cur, &dir) == 0) && dir) {
char path[PROCESSGROUP_MAX_PATH_LEN];
if (dir->d_type != DT_DIR) {
continue;
}
if (strncmp(dir->d_name, PROCESSGROUP_PID_PREFIX, strlen(PROCESSGROUP_PID_PREFIX))) {
continue;
}
snprintf(path, sizeof(path), "%s/%s", uid_path, dir->d_name);
SLOGV("removing %s\n", path);
rmdir(path);
}
}
}
void PhoneMachine::receiveSolicited(const Parcel& data)
{
int serial = data.readInt32();
int result = data.readInt32();
RILRequest *request = getPending(serial);
if (!request) {
SLOGW("receiveSolicited: not requested serial=%d result=%d\n", serial, result);
return;
}
SLOGV("<<< Solicited message=%s [%d] serial=%d result=%d\n", rilMessageStr(request->message()),
request->message(), serial, result);
int token = request->token();
int message = request->message();
int ivalue = 0;
Parcel extra;
switch (message) {
case RIL_REQUEST_GET_SIM_STATUS:
ivalue = data.readInt32(); // Store the card state
break;
case RIL_REQUEST_GET_CURRENT_CALLS: {
// We retrieve audio information for the client.
// We also update the AudioFlinger audio state appropriately based
// on the current call state
ivalue = data.readInt32(); // How many calls there are
audio_mode_t audio_mode = AUDIO_MODE_NORMAL;
for (int i = 0 ; i < ivalue ; i++) {
RILCall call(data);
CallState call_state(call.state, call.index,
call.number, call.numberPresentation,
call.name, call.namePresentation);
call_state.writeToParcel(&extra);
if (call.state == RIL_CALL_INCOMING)
audio_mode = AUDIO_MODE_RINGTONE;
else if (call.state == RIL_CALL_ACTIVE || call.state == RIL_CALL_DIALING || call.state == RIL_CALL_ALERTING)
audio_mode = AUDIO_MODE_IN_CALL;
}
SLOGV(" %d calls, audio_mode=%d\n", ivalue, audio_mode);
updateAudioMode(audio_mode);
break;
}
case RIL_REQUEST_DIAL:
case RIL_REQUEST_HANGUP:
case RIL_REQUEST_ANSWER:
case RIL_REQUEST_UDUB:
case RIL_REQUEST_SET_MUTE:
break;
case RIL_REQUEST_GET_MUTE:
ivalue = data.readInt32();
break;
case RIL_REQUEST_SIGNAL_STRENGTH:
// In actuality, we should probably read all 12 signal strengths
ivalue = data.readInt32();
break;
#if defined(SHORT_PLATFORM_VERSION) && (SHORT_PLATFORM_VERSION == 23)
#else
case RIL_REQUEST_VOICE_REGISTRATION_STATE:
ivalue = data.readInt32(); // Starts with the number of strings
for (int i = 0 ; i < ivalue ; i++)
extra.writeString16(data.readString16());
break;
#endif
case RIL_REQUEST_OPERATOR: {
ivalue = data.readInt32();
assert(ivalue == 3);
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
break;
}
case RIL_REQUEST_RADIO_POWER:
SLOGV(" RIL Radio Power\n");
// No response....
break;
default:
SLOGV("Unhandled RIL request %d\n", message);
break;
}
if (request->client() != NULL) {
SLOGV(" Passing solicited message to client token=%d message=%d result=%d ivalue=%d...\n",
token, message, result, ivalue);
request->client()->Response( token, message, result, ivalue, extra );
}
delete request;
}
void SocketListener::runListener() {
SocketClientCollection pendingList;
while(1) {
SocketClientCollection::iterator it;
fd_set read_fds;
int rc = 0;
int max = -1;
FD_ZERO(&read_fds);
if (mListen) {
max = mSock;
FD_SET(mSock, &read_fds);
}
FD_SET(mCtrlPipe[0], &read_fds);
if (mCtrlPipe[0] > max)
max = mCtrlPipe[0];
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
// NB: calling out to an other object with mClientsLock held (safe)
int fd = (*it)->getSocket();
FD_SET(fd, &read_fds);
if (fd > max) {
max = fd;
}
}
pthread_mutex_unlock(&mClientsLock);
SLOGV("mListen=%d, max=%d, mSocketName=%s", mListen, max, mSocketName);
if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {
if (errno == EINTR)
continue;
SLOGE("select failed (%s) mListen=%d, max=%d", strerror(errno), mListen, max);
sleep(1);
continue;
} else if (!rc)
continue;
if (FD_ISSET(mCtrlPipe[0], &read_fds)) {
char c = CtrlPipe_Shutdown;
TEMP_FAILURE_RETRY(read(mCtrlPipe[0], &c, 1));
if (c == CtrlPipe_Shutdown) {
break;
}
continue;
}
if (mListen && FD_ISSET(mSock, &read_fds)) {
sockaddr_storage ss;
sockaddr* addrp = reinterpret_cast<sockaddr*>(&ss);
socklen_t alen;
int c;
do {
alen = sizeof(ss);
c = accept(mSock, addrp, &alen);
SLOGV("%s got %d from accept", mSocketName, c);
} while (c < 0 && errno == EINTR);
if (c < 0) {
SLOGE("accept failed (%s)", strerror(errno));
sleep(1);
continue;
}
fcntl(c, F_SETFD, FD_CLOEXEC);
pthread_mutex_lock(&mClientsLock);
mClients->push_back(new SocketClient(c, true, mUseCmdNum));
pthread_mutex_unlock(&mClientsLock);
}
/* Add all active clients to the pending list first */
pendingList.clear();
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
SocketClient* c = *it;
// NB: calling out to an other object with mClientsLock held (safe)
int fd = c->getSocket();
if (FD_ISSET(fd, &read_fds)) {
pendingList.push_back(c);
c->incRef();
}
}
pthread_mutex_unlock(&mClientsLock);
/* Process the pending list, since it is owned by the thread,
* there is no need to lock it */
while (!pendingList.empty()) {
/* Pop the first item from the list */
it = pendingList.begin();
SocketClient* c = *it;
pendingList.erase(it);
/* Process it, if false is returned, remove from list */
if (!onDataAvailable(c)) {
release(c, false);
}
c->decRef();
}
}
}
void *SpeechVMRecorder::DumpVMRecordDataThread(void *arg)
{
// Adjust thread priority
prctl(PR_SET_NAME, (unsigned long)__FUNCTION__, 0, 0, 0);
setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
ALOGD("%s(), pid: %d, tid: %d", __FUNCTION__, getpid(), gettid());
SpeechVMRecorder *pSpeechVMRecorder = (SpeechVMRecorder *)arg;
RingBuf &ring_buf = pSpeechVMRecorder->mRingBuf;
// open modem record function
SpeechDriverInterface *pSpeechDriver = SpeechDriverFactory::GetInstance()->GetSpeechDriver();
status_t retval = pSpeechDriver->VoiceMemoRecordOn();
if (retval != NO_ERROR)
{
ALOGE("%s(), VoiceMemoRecordOn() fail!! Return.", __FUNCTION__);
pSpeechDriver->VoiceMemoRecordOff();
pthread_exit(NULL);
return 0;
}
// open file
if (pSpeechVMRecorder->OpenFile() != NO_ERROR)
{
pSpeechDriver->VoiceMemoRecordOff();
pthread_exit(NULL);
return 0;
}
// Internal Input Buffer Initialization
pSpeechVMRecorder->mRingBuf.pBufBase = new char[kReadBufferSize];
pSpeechVMRecorder->mRingBuf.bufLen = kReadBufferSize;
pSpeechVMRecorder->mRingBuf.pRead = pSpeechVMRecorder->mRingBuf.pBufBase;
pSpeechVMRecorder->mRingBuf.pWrite = pSpeechVMRecorder->mRingBuf.pBufBase;
ASSERT(pSpeechVMRecorder->mRingBuf.pBufBase != NULL);
memset(pSpeechVMRecorder->mRingBuf.pBufBase, 0, pSpeechVMRecorder->mRingBuf.bufLen);
pSpeechVMRecorder->mStarting = true;
while (1)
{
// lock & wait data
pthread_mutex_lock(&pSpeechVMRecorder->mMutex);
int ret = pthread_cond_timeout_np(&pSpeechVMRecorder->mExitCond, &pSpeechVMRecorder->mMutex, kCondWaitTimeoutMsec);
if (ret != 0)
{
ALOGW("%s(), pthread_cond_timeout_np return %d. ", __FUNCTION__, ret);
}
// make sure VM is still recording after conditional wait
if (pSpeechVMRecorder->mStarting == false)
{
// close file
if (pSpeechVMRecorder->mDumpFile != NULL)
{
fflush(pSpeechVMRecorder->mDumpFile);
fclose(pSpeechVMRecorder->mDumpFile);
pSpeechVMRecorder->mDumpFile = NULL;
}
// release local ring buffer
if (pSpeechVMRecorder->mRingBuf.pBufBase != NULL)
{
delete []pSpeechVMRecorder->mRingBuf.pBufBase;
pSpeechVMRecorder->mRingBuf.pBufBase = NULL;
pSpeechVMRecorder->mRingBuf.pRead = NULL;
pSpeechVMRecorder->mRingBuf.pWrite = NULL;
pSpeechVMRecorder->mRingBuf.bufLen = 0;
}
ALOGD("%s(), pid: %d, tid: %d, mStarting == false, break", __FUNCTION__, getpid(), gettid());
pthread_mutex_unlock(&pSpeechVMRecorder->mMutex);
break;
}
// write data to sd card
const uint16_t data_count = RingBuf_getDataCount(&ring_buf);
uint16_t write_bytes = 0;
if (data_count > 0)
{
const char *end = ring_buf.pBufBase + ring_buf.bufLen;
if (ring_buf.pRead <= ring_buf.pWrite)
{
write_bytes += fwrite((void *)ring_buf.pRead, sizeof(char), data_count, pSpeechVMRecorder->mDumpFile);
}
else
{
int r2e = end - ring_buf.pRead;
write_bytes += fwrite((void *)ring_buf.pRead, sizeof(char), r2e, pSpeechVMRecorder->mDumpFile);
write_bytes += fwrite((void *)ring_buf.pBufBase, sizeof(char), data_count - r2e, pSpeechVMRecorder->mDumpFile);
}
ring_buf.pRead += write_bytes;
if (ring_buf.pRead >= end) { ring_buf.pRead -= ring_buf.bufLen; }
SLOGV("data_count: %u, write_bytes: %u", data_count, write_bytes);
}
if (write_bytes != data_count)
{
ALOGE("%s(), write_bytes(%d) != data_count(%d), SD Card might be full!!", __FUNCTION__, write_bytes, data_count);
}
// unlock
pthread_mutex_unlock(&pSpeechVMRecorder->mMutex);
}
pthread_exit(NULL);
return 0;
}
TEST(liblog, SLOG) {
static const char content[] = "log_system.h";
static const char content_false[] = "log_system.h false";
// ratelimit content to 10/s to keep away from spam filters
// do not send identical content together to keep away from spam filters
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGV"
SLOGV(content);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGD"
SLOGD(content);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGI"
SLOGI(content);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGW"
SLOGW(content);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGE"
SLOGE(content);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGV"
SLOGV_IF(true, content);
usleep(100000);
SLOGV_IF(false, content_false);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGD"
SLOGD_IF(true, content);
usleep(100000);
SLOGD_IF(false, content_false);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGI"
SLOGI_IF(true, content);
usleep(100000);
SLOGI_IF(false, content_false);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGW"
SLOGW_IF(true, content);
usleep(100000);
SLOGW_IF(false, content_false);
usleep(100000);
#undef LOG_TAG
#define LOG_TAG "TEST__SLOGE"
SLOGE_IF(true, content);
usleep(100000);
SLOGE_IF(false, content_false);
#ifdef __ANDROID__
// give time for content to long-path through logger
sleep(1);
std::string buf = android::base::StringPrintf(
"logcat -b system --pid=%u -d -s"
" TEST__SLOGV TEST__SLOGD TEST__SLOGI TEST__SLOGW TEST__SLOGE",
(unsigned)getpid());
FILE* fp = popen(buf.c_str(), "re");
int count = 0;
int count_false = 0;
if (fp) {
if (!android::base::ReadFdToString(fileno(fp), &buf)) buf = "";
pclose(fp);
for (size_t pos = 0; (pos = buf.find(content, pos)) != std::string::npos;
++pos) {
++count;
}
for (size_t pos = 0;
(pos = buf.find(content_false, pos)) != std::string::npos; ++pos) {
++count_false;
}
}
EXPECT_EQ(0, count_false);
#if LOG_NDEBUG
ASSERT_EQ(8, count);
#else
ASSERT_EQ(10, count);
#endif
#else
GTEST_LOG_(INFO) << "This test does not test end-to-end.\n";
#endif
}
static int get_used_log_size(struct mrknlog_device_t* dev) {
SLOGV("Getting used buffer size of %s", LOG_FILE); /* */
return ioctl_log(O_RDONLY, LOGGER_GET_LOG_LEN); /* */
}
static int get_total_log_size(struct mrknlog_device_t* dev) {
SLOGV("Getting total buffer size of %s", LOG_FILE); /* */
return ioctl_log(O_RDONLY, LOGGER_GET_LOG_BUF_SIZE); /* */
}
static int flush_log(struct mrknlog_device_t* dev) {
SLOGV("Flushing %s", LOG_FILE); /* */
return ioctl_log(O_WRONLY, LOGGER_FLUSH_LOG); /* */
}
