blob: fd552b4f4da2ec6c59c4129ba9634292a6c7d537 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2005 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jason Parksdcd39582009-11-03 12:14:38 -080017#define LOG_TAG "IPCThreadState"
18
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070019#include <binder/IPCThreadState.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070021#include <binder/Binder.h>
22#include <binder/BpBinder.h>
Mathias Agopian002e1e52013-05-06 20:20:50 -070023#include <binder/TextOutput.h>
24
Glenn Kastena26e1cf2012-03-16 07:15:23 -070025#include <cutils/sched_policy.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080026#include <utils/Log.h>
Colin Cross96e83222016-04-15 14:29:55 -070027#include <utils/SystemClock.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080028#include <utils/threads.h>
29
Mathias Agopian208059f2009-05-18 15:08:03 -070030#include <private/binder/binder_module.h>
31#include <private/binder/Static.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080032
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080033#include <errno.h>
Colin Cross96e83222016-04-15 14:29:55 -070034#include <inttypes.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035#include <pthread.h>
36#include <sched.h>
Yabin Cui8fb2d252015-01-26 19:45:47 -080037#include <signal.h>
38#include <stdio.h>
39#include <sys/ioctl.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080040#include <sys/resource.h>
Yabin Cui8fb2d252015-01-26 19:45:47 -080041#include <unistd.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080042
43#if LOG_NDEBUG
44
45#define IF_LOG_TRANSACTIONS() if (false)
46#define IF_LOG_COMMANDS() if (false)
47#define LOG_REMOTEREFS(...)
48#define IF_LOG_REMOTEREFS() if (false)
Tim Murrayd429f4a2017-03-07 09:31:09 -080049
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080050#define LOG_THREADPOOL(...)
51#define LOG_ONEWAY(...)
52
53#else
54
Steve Block9f760152011-10-12 17:27:03 +010055#define IF_LOG_TRANSACTIONS() IF_ALOG(LOG_VERBOSE, "transact")
56#define IF_LOG_COMMANDS() IF_ALOG(LOG_VERBOSE, "ipc")
57#define LOG_REMOTEREFS(...) ALOG(LOG_DEBUG, "remoterefs", __VA_ARGS__)
58#define IF_LOG_REMOTEREFS() IF_ALOG(LOG_DEBUG, "remoterefs")
59#define LOG_THREADPOOL(...) ALOG(LOG_DEBUG, "threadpool", __VA_ARGS__)
60#define LOG_ONEWAY(...) ALOG(LOG_DEBUG, "ipc", __VA_ARGS__)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061
62#endif
63
64// ---------------------------------------------------------------------------
65
66namespace android {
67
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -070068// Static const and functions will be optimized out if not used,
69// when LOG_NDEBUG and references in IF_LOG_COMMANDS() are optimized out.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080070static const char *kReturnStrings[] = {
Andy McFaddenaefc9cd2011-08-31 07:43:40 -070071 "BR_ERROR",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080072 "BR_OK",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080073 "BR_TRANSACTION",
74 "BR_REPLY",
75 "BR_ACQUIRE_RESULT",
76 "BR_DEAD_REPLY",
77 "BR_TRANSACTION_COMPLETE",
78 "BR_INCREFS",
79 "BR_ACQUIRE",
80 "BR_RELEASE",
81 "BR_DECREFS",
82 "BR_ATTEMPT_ACQUIRE",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083 "BR_NOOP",
84 "BR_SPAWN_LOOPER",
85 "BR_FINISHED",
86 "BR_DEAD_BINDER",
Andy McFaddenaefc9cd2011-08-31 07:43:40 -070087 "BR_CLEAR_DEATH_NOTIFICATION_DONE",
88 "BR_FAILED_REPLY"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080089};
90
91static const char *kCommandStrings[] = {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080092 "BC_TRANSACTION",
93 "BC_REPLY",
94 "BC_ACQUIRE_RESULT",
95 "BC_FREE_BUFFER",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080096 "BC_INCREFS",
97 "BC_ACQUIRE",
98 "BC_RELEASE",
99 "BC_DECREFS",
100 "BC_INCREFS_DONE",
101 "BC_ACQUIRE_DONE",
102 "BC_ATTEMPT_ACQUIRE",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800103 "BC_REGISTER_LOOPER",
104 "BC_ENTER_LOOPER",
105 "BC_EXIT_LOOPER",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800106 "BC_REQUEST_DEATH_NOTIFICATION",
107 "BC_CLEAR_DEATH_NOTIFICATION",
108 "BC_DEAD_BINDER_DONE"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800109};
110
songjinshi73a7dde2016-10-18 21:05:56 +0800111static const char* getReturnString(uint32_t cmd)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800112{
songjinshi73a7dde2016-10-18 21:05:56 +0800113 size_t idx = cmd & 0xff;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800114 if (idx < sizeof(kReturnStrings) / sizeof(kReturnStrings[0]))
115 return kReturnStrings[idx];
116 else
117 return "unknown";
118}
119
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800120static const void* printBinderTransactionData(TextOutput& out, const void* data)
121{
122 const binder_transaction_data* btd =
123 (const binder_transaction_data*)data;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700124 if (btd->target.handle < 1024) {
125 /* want to print descriptors in decimal; guess based on value */
126 out << "target.desc=" << btd->target.handle;
127 } else {
128 out << "target.ptr=" << btd->target.ptr;
129 }
130 out << " (cookie " << btd->cookie << ")" << endl
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700131 << "code=" << TypeCode(btd->code) << ", flags=" << (void*)(long)btd->flags << endl
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800132 << "data=" << btd->data.ptr.buffer << " (" << (void*)btd->data_size
133 << " bytes)" << endl
134 << "offsets=" << btd->data.ptr.offsets << " (" << (void*)btd->offsets_size
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700135 << " bytes)";
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800136 return btd+1;
137}
138
139static const void* printReturnCommand(TextOutput& out, const void* _cmd)
140{
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700141 static const size_t N = sizeof(kReturnStrings)/sizeof(kReturnStrings[0]);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800142 const int32_t* cmd = (const int32_t*)_cmd;
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +0100143 uint32_t code = (uint32_t)*cmd++;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700144 size_t cmdIndex = code & 0xff;
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +0100145 if (code == BR_ERROR) {
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700146 out << "BR_ERROR: " << (void*)(long)(*cmd++) << endl;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800147 return cmd;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700148 } else if (cmdIndex >= N) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800149 out << "Unknown reply: " << code << endl;
150 return cmd;
151 }
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700152 out << kReturnStrings[cmdIndex];
Tim Murrayd429f4a2017-03-07 09:31:09 -0800153
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800154 switch (code) {
155 case BR_TRANSACTION:
156 case BR_REPLY: {
157 out << ": " << indent;
158 cmd = (const int32_t *)printBinderTransactionData(out, cmd);
159 out << dedent;
160 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800161
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800162 case BR_ACQUIRE_RESULT: {
163 const int32_t res = *cmd++;
164 out << ": " << res << (res ? " (SUCCESS)" : " (FAILURE)");
165 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800166
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800167 case BR_INCREFS:
168 case BR_ACQUIRE:
169 case BR_RELEASE:
170 case BR_DECREFS: {
171 const int32_t b = *cmd++;
172 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700173 out << ": target=" << (void*)(long)b << " (cookie " << (void*)(long)c << ")";
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800174 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800175
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800176 case BR_ATTEMPT_ACQUIRE: {
177 const int32_t p = *cmd++;
178 const int32_t b = *cmd++;
179 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700180 out << ": target=" << (void*)(long)b << " (cookie " << (void*)(long)c
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800181 << "), pri=" << p;
182 } break;
183
184 case BR_DEAD_BINDER:
185 case BR_CLEAR_DEATH_NOTIFICATION_DONE: {
186 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700187 out << ": death cookie " << (void*)(long)c;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800188 } break;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700189
190 default:
191 // no details to show for: BR_OK, BR_DEAD_REPLY,
192 // BR_TRANSACTION_COMPLETE, BR_FINISHED
193 break;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800194 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800195
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800196 out << endl;
197 return cmd;
198}
199
200static const void* printCommand(TextOutput& out, const void* _cmd)
201{
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700202 static const size_t N = sizeof(kCommandStrings)/sizeof(kCommandStrings[0]);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800203 const int32_t* cmd = (const int32_t*)_cmd;
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +0100204 uint32_t code = (uint32_t)*cmd++;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700205 size_t cmdIndex = code & 0xff;
206
207 if (cmdIndex >= N) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800208 out << "Unknown command: " << code << endl;
209 return cmd;
210 }
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700211 out << kCommandStrings[cmdIndex];
212
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800213 switch (code) {
214 case BC_TRANSACTION:
215 case BC_REPLY: {
216 out << ": " << indent;
217 cmd = (const int32_t *)printBinderTransactionData(out, cmd);
218 out << dedent;
219 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800220
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800221 case BC_ACQUIRE_RESULT: {
222 const int32_t res = *cmd++;
223 out << ": " << res << (res ? " (SUCCESS)" : " (FAILURE)");
224 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800225
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800226 case BC_FREE_BUFFER: {
227 const int32_t buf = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700228 out << ": buffer=" << (void*)(long)buf;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800229 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800230
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800231 case BC_INCREFS:
232 case BC_ACQUIRE:
233 case BC_RELEASE:
234 case BC_DECREFS: {
235 const int32_t d = *cmd++;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700236 out << ": desc=" << d;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800237 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800238
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800239 case BC_INCREFS_DONE:
240 case BC_ACQUIRE_DONE: {
241 const int32_t b = *cmd++;
242 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700243 out << ": target=" << (void*)(long)b << " (cookie " << (void*)(long)c << ")";
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800244 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800245
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800246 case BC_ATTEMPT_ACQUIRE: {
247 const int32_t p = *cmd++;
248 const int32_t d = *cmd++;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700249 out << ": desc=" << d << ", pri=" << p;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800250 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800251
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800252 case BC_REQUEST_DEATH_NOTIFICATION:
253 case BC_CLEAR_DEATH_NOTIFICATION: {
254 const int32_t h = *cmd++;
255 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700256 out << ": handle=" << h << " (death cookie " << (void*)(long)c << ")";
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800257 } break;
258
259 case BC_DEAD_BINDER_DONE: {
260 const int32_t c = *cmd++;
Chih-Hung Hsieh8e5337d2014-10-24 14:10:09 -0700261 out << ": death cookie " << (void*)(long)c;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800262 } break;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700263
264 default:
265 // no details to show for: BC_REGISTER_LOOPER, BC_ENTER_LOOPER,
266 // BC_EXIT_LOOPER
267 break;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800268 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800269
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800270 out << endl;
271 return cmd;
272}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800273
274static pthread_mutex_t gTLSMutex = PTHREAD_MUTEX_INITIALIZER;
275static bool gHaveTLS = false;
276static pthread_key_t gTLS = 0;
277static bool gShutdown = false;
Dianne Hackborn8c6cedc2009-12-07 17:59:37 -0800278static bool gDisableBackgroundScheduling = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800279
280IPCThreadState* IPCThreadState::self()
281{
282 if (gHaveTLS) {
283restart:
284 const pthread_key_t k = gTLS;
285 IPCThreadState* st = (IPCThreadState*)pthread_getspecific(k);
286 if (st) return st;
287 return new IPCThreadState;
288 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800289
Andreas Gampef31a3eb2016-02-01 13:21:56 -0800290 if (gShutdown) {
291 ALOGW("Calling IPCThreadState::self() during shutdown is dangerous, expect a crash.\n");
292 return NULL;
293 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800294
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800295 pthread_mutex_lock(&gTLSMutex);
296 if (!gHaveTLS) {
Andreas Gampef31a3eb2016-02-01 13:21:56 -0800297 int key_create_value = pthread_key_create(&gTLS, threadDestructor);
298 if (key_create_value != 0) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800299 pthread_mutex_unlock(&gTLSMutex);
Andreas Gampef31a3eb2016-02-01 13:21:56 -0800300 ALOGW("IPCThreadState::self() unable to create TLS key, expect a crash: %s\n",
301 strerror(key_create_value));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800302 return NULL;
303 }
304 gHaveTLS = true;
305 }
306 pthread_mutex_unlock(&gTLSMutex);
307 goto restart;
308}
309
Brad Fitzpatrick1b608432010-12-13 16:52:35 -0800310IPCThreadState* IPCThreadState::selfOrNull()
311{
312 if (gHaveTLS) {
313 const pthread_key_t k = gTLS;
314 IPCThreadState* st = (IPCThreadState*)pthread_getspecific(k);
315 return st;
316 }
317 return NULL;
318}
319
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800320void IPCThreadState::shutdown()
321{
322 gShutdown = true;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800323
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800324 if (gHaveTLS) {
325 // XXX Need to wait for all thread pool threads to exit!
326 IPCThreadState* st = (IPCThreadState*)pthread_getspecific(gTLS);
327 if (st) {
328 delete st;
329 pthread_setspecific(gTLS, NULL);
330 }
zhongjieff405782016-03-09 15:05:04 +0800331 pthread_key_delete(gTLS);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800332 gHaveTLS = false;
333 }
334}
335
Dianne Hackborn8c6cedc2009-12-07 17:59:37 -0800336void IPCThreadState::disableBackgroundScheduling(bool disable)
337{
338 gDisableBackgroundScheduling = disable;
339}
340
Martijn Coenen2b631742017-05-05 11:16:59 -0700341bool IPCThreadState::backgroundSchedulingDisabled()
342{
343 return gDisableBackgroundScheduling;
344}
345
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800346sp<ProcessState> IPCThreadState::process()
347{
348 return mProcess;
349}
350
351status_t IPCThreadState::clearLastError()
352{
353 const status_t err = mLastError;
354 mLastError = NO_ERROR;
355 return err;
356}
357
Dan Stoza9c634fd2014-11-26 12:23:23 -0800358pid_t IPCThreadState::getCallingPid() const
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800359{
360 return mCallingPid;
361}
362
Dan Stoza9c634fd2014-11-26 12:23:23 -0800363uid_t IPCThreadState::getCallingUid() const
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800364{
365 return mCallingUid;
366}
367
368int64_t IPCThreadState::clearCallingIdentity()
369{
370 int64_t token = ((int64_t)mCallingUid<<32) | mCallingPid;
371 clearCaller();
372 return token;
373}
374
Brad Fitzpatrick702ea9d2010-06-18 13:07:53 -0700375void IPCThreadState::setStrictModePolicy(int32_t policy)
376{
377 mStrictModePolicy = policy;
378}
379
Brad Fitzpatricka877cd82010-07-07 16:06:39 -0700380int32_t IPCThreadState::getStrictModePolicy() const
381{
Brad Fitzpatrick702ea9d2010-06-18 13:07:53 -0700382 return mStrictModePolicy;
383}
384
Brad Fitzpatrick52736032010-08-30 16:01:16 -0700385void IPCThreadState::setLastTransactionBinderFlags(int32_t flags)
386{
387 mLastTransactionBinderFlags = flags;
388}
389
390int32_t IPCThreadState::getLastTransactionBinderFlags() const
391{
392 return mLastTransactionBinderFlags;
393}
394
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800395void IPCThreadState::restoreCallingIdentity(int64_t token)
396{
397 mCallingUid = (int)(token>>32);
398 mCallingPid = (int)token;
399}
400
401void IPCThreadState::clearCaller()
402{
Marco Nelissend43b1942009-07-17 07:59:17 -0700403 mCallingPid = getpid();
404 mCallingUid = getuid();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800405}
406
407void IPCThreadState::flushCommands()
408{
409 if (mProcess->mDriverFD <= 0)
410 return;
411 talkWithDriver(false);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700412 // The flush could have caused post-write refcount decrements to have
413 // been executed, which in turn could result in BC_RELEASE/BC_DECREFS
414 // being queued in mOut. So flush again, if we need to.
415 if (mOut.dataSize() > 0) {
416 talkWithDriver(false);
417 }
418 if (mOut.dataSize() > 0) {
419 ALOGW("mOut.dataSize() > 0 after flushCommands()");
420 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800421}
422
Wale Ogunwale376b8222015-04-13 16:16:10 -0700423void IPCThreadState::blockUntilThreadAvailable()
424{
425 pthread_mutex_lock(&mProcess->mThreadCountLock);
426 while (mProcess->mExecutingThreadsCount >= mProcess->mMaxThreads) {
Wale Ogunwalea3206e62015-04-21 12:29:50 -0700427 ALOGW("Waiting for thread to be free. mExecutingThreadsCount=%lu mMaxThreads=%lu\n",
428 static_cast<unsigned long>(mProcess->mExecutingThreadsCount),
429 static_cast<unsigned long>(mProcess->mMaxThreads));
Wale Ogunwale376b8222015-04-13 16:16:10 -0700430 pthread_cond_wait(&mProcess->mThreadCountDecrement, &mProcess->mThreadCountLock);
431 }
432 pthread_mutex_unlock(&mProcess->mThreadCountLock);
433}
434
Todd Poynor8d96cab2013-06-25 19:12:18 -0700435status_t IPCThreadState::getAndExecuteCommand()
436{
437 status_t result;
438 int32_t cmd;
439
440 result = talkWithDriver();
441 if (result >= NO_ERROR) {
442 size_t IN = mIn.dataAvail();
443 if (IN < sizeof(int32_t)) return result;
444 cmd = mIn.readInt32();
445 IF_LOG_COMMANDS() {
446 alog << "Processing top-level Command: "
447 << getReturnString(cmd) << endl;
448 }
449
Wale Ogunwale376b8222015-04-13 16:16:10 -0700450 pthread_mutex_lock(&mProcess->mThreadCountLock);
451 mProcess->mExecutingThreadsCount++;
Colin Cross96e83222016-04-15 14:29:55 -0700452 if (mProcess->mExecutingThreadsCount >= mProcess->mMaxThreads &&
453 mProcess->mStarvationStartTimeMs == 0) {
454 mProcess->mStarvationStartTimeMs = uptimeMillis();
455 }
Wale Ogunwale376b8222015-04-13 16:16:10 -0700456 pthread_mutex_unlock(&mProcess->mThreadCountLock);
457
Todd Poynor8d96cab2013-06-25 19:12:18 -0700458 result = executeCommand(cmd);
459
Wale Ogunwale376b8222015-04-13 16:16:10 -0700460 pthread_mutex_lock(&mProcess->mThreadCountLock);
461 mProcess->mExecutingThreadsCount--;
Colin Cross96e83222016-04-15 14:29:55 -0700462 if (mProcess->mExecutingThreadsCount < mProcess->mMaxThreads &&
463 mProcess->mStarvationStartTimeMs != 0) {
464 int64_t starvationTimeMs = uptimeMillis() - mProcess->mStarvationStartTimeMs;
465 if (starvationTimeMs > 100) {
466 ALOGE("binder thread pool (%zu threads) starved for %" PRId64 " ms",
467 mProcess->mMaxThreads, starvationTimeMs);
468 }
469 mProcess->mStarvationStartTimeMs = 0;
470 }
Wale Ogunwale376b8222015-04-13 16:16:10 -0700471 pthread_cond_broadcast(&mProcess->mThreadCountDecrement);
472 pthread_mutex_unlock(&mProcess->mThreadCountLock);
Todd Poynor8d96cab2013-06-25 19:12:18 -0700473 }
474
475 return result;
476}
477
478// When we've cleared the incoming command queue, process any pending derefs
479void IPCThreadState::processPendingDerefs()
480{
481 if (mIn.dataPosition() >= mIn.dataSize()) {
Martijn Coenen0791fbf2017-08-08 15:36:16 +0200482 /*
483 * The decWeak()/decStrong() calls may cause a destructor to run,
484 * which in turn could have initiated an outgoing transaction,
485 * which in turn could cause us to add to the pending refs
486 * vectors; so instead of simply iterating, loop until they're empty.
487 *
488 * We do this in an outer loop, because calling decStrong()
489 * may result in something being added to mPendingWeakDerefs,
490 * which could be delayed until the next incoming command
491 * from the driver if we don't process it now.
492 */
493 while (mPendingWeakDerefs.size() > 0 || mPendingStrongDerefs.size() > 0) {
494 while (mPendingWeakDerefs.size() > 0) {
495 RefBase::weakref_type* refs = mPendingWeakDerefs[0];
496 mPendingWeakDerefs.removeAt(0);
Todd Poynor8d96cab2013-06-25 19:12:18 -0700497 refs->decWeak(mProcess.get());
498 }
Todd Poynor8d96cab2013-06-25 19:12:18 -0700499
Martijn Coenen0791fbf2017-08-08 15:36:16 +0200500 if (mPendingStrongDerefs.size() > 0) {
501 // We don't use while() here because we don't want to re-order
502 // strong and weak decs at all; if this decStrong() causes both a
503 // decWeak() and a decStrong() to be queued, we want to process
504 // the decWeak() first.
505 BBinder* obj = mPendingStrongDerefs[0];
506 mPendingStrongDerefs.removeAt(0);
Todd Poynor8d96cab2013-06-25 19:12:18 -0700507 obj->decStrong(mProcess.get());
508 }
Todd Poynor8d96cab2013-06-25 19:12:18 -0700509 }
510 }
511}
512
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700513void IPCThreadState::processPostWriteDerefs()
514{
515 for (size_t i = 0; i < mPostWriteWeakDerefs.size(); i++) {
516 RefBase::weakref_type* refs = mPostWriteWeakDerefs[i];
517 refs->decWeak(mProcess.get());
518 }
519 mPostWriteWeakDerefs.clear();
520
521 for (size_t i = 0; i < mPostWriteStrongDerefs.size(); i++) {
522 RefBase* obj = mPostWriteStrongDerefs[i];
523 obj->decStrong(mProcess.get());
524 }
525 mPostWriteStrongDerefs.clear();
526}
527
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800528void IPCThreadState::joinThreadPool(bool isMain)
529{
530 LOG_THREADPOOL("**** THREAD %p (PID %d) IS JOINING THE THREAD POOL\n", (void*)pthread_self(), getpid());
531
532 mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);
Tim Murrayd429f4a2017-03-07 09:31:09 -0800533
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800534 status_t result;
535 do {
Todd Poynor8d96cab2013-06-25 19:12:18 -0700536 processPendingDerefs();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800537 // now get the next command to be processed, waiting if necessary
Todd Poynor8d96cab2013-06-25 19:12:18 -0700538 result = getAndExecuteCommand();
Jason Parksdcd39582009-11-03 12:14:38 -0800539
Todd Poynor8d96cab2013-06-25 19:12:18 -0700540 if (result < NO_ERROR && result != TIMED_OUT && result != -ECONNREFUSED && result != -EBADF) {
541 ALOGE("getAndExecuteCommand(fd=%d) returned unexpected error %d, aborting",
Jeff Tinkeref073862013-06-11 11:30:21 -0700542 mProcess->mDriverFD, result);
543 abort();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800544 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800545
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800546 // Let this thread exit the thread pool if it is no longer
547 // needed and it is not the main process thread.
548 if(result == TIMED_OUT && !isMain) {
549 break;
550 }
551 } while (result != -ECONNREFUSED && result != -EBADF);
552
Wei Wangc7341432016-10-19 10:23:59 -0700553 LOG_THREADPOOL("**** THREAD %p (PID %d) IS LEAVING THE THREAD POOL err=%d\n",
554 (void*)pthread_self(), getpid(), result);
Tim Murrayd429f4a2017-03-07 09:31:09 -0800555
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800556 mOut.writeInt32(BC_EXIT_LOOPER);
557 talkWithDriver(false);
558}
559
Todd Poynor8d96cab2013-06-25 19:12:18 -0700560int IPCThreadState::setupPolling(int* fd)
561{
562 if (mProcess->mDriverFD <= 0) {
563 return -EBADF;
564 }
565
566 mOut.writeInt32(BC_ENTER_LOOPER);
567 *fd = mProcess->mDriverFD;
568 return 0;
569}
570
571status_t IPCThreadState::handlePolledCommands()
572{
573 status_t result;
574
575 do {
576 result = getAndExecuteCommand();
577 } while (mIn.dataPosition() < mIn.dataSize());
578
579 processPendingDerefs();
580 flushCommands();
581 return result;
582}
583
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800584void IPCThreadState::stopProcess(bool /*immediate*/)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800585{
Steve Blocka19954a2012-01-04 20:05:49 +0000586 //ALOGI("**** STOPPING PROCESS");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800587 flushCommands();
588 int fd = mProcess->mDriverFD;
589 mProcess->mDriverFD = -1;
590 close(fd);
591 //kill(getpid(), SIGKILL);
592}
593
594status_t IPCThreadState::transact(int32_t handle,
595 uint32_t code, const Parcel& data,
596 Parcel* reply, uint32_t flags)
597{
Ganesh Mahendran58e5daa2017-10-11 18:05:13 +0800598 status_t err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800599
600 flags |= TF_ACCEPT_FDS;
601
602 IF_LOG_TRANSACTIONS() {
603 TextOutput::Bundle _b(alog);
604 alog << "BC_TRANSACTION thr " << (void*)pthread_self() << " / hand "
605 << handle << " / code " << TypeCode(code) << ": "
606 << indent << data << dedent << endl;
607 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800608
Ganesh Mahendran58e5daa2017-10-11 18:05:13 +0800609 LOG_ONEWAY(">>>> SEND from pid %d uid %d %s", getpid(), getuid(),
610 (flags & TF_ONE_WAY) == 0 ? "READ REPLY" : "ONE WAY");
611 err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);
Tim Murrayd429f4a2017-03-07 09:31:09 -0800612
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800613 if (err != NO_ERROR) {
614 if (reply) reply->setError(err);
615 return (mLastError = err);
616 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800617
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800618 if ((flags & TF_ONE_WAY) == 0) {
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700619 #if 0
620 if (code == 4) { // relayout
Steve Blocka19954a2012-01-04 20:05:49 +0000621 ALOGI(">>>>>> CALLING transaction 4");
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700622 } else {
Steve Blocka19954a2012-01-04 20:05:49 +0000623 ALOGI(">>>>>> CALLING transaction %d", code);
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700624 }
625 #endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800626 if (reply) {
627 err = waitForResponse(reply);
628 } else {
629 Parcel fakeReply;
630 err = waitForResponse(&fakeReply);
631 }
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700632 #if 0
633 if (code == 4) { // relayout
Steve Blocka19954a2012-01-04 20:05:49 +0000634 ALOGI("<<<<<< RETURNING transaction 4");
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700635 } else {
Steve Blocka19954a2012-01-04 20:05:49 +0000636 ALOGI("<<<<<< RETURNING transaction %d", code);
Dianne Hackborn67f78c42010-09-24 11:16:23 -0700637 }
638 #endif
Tim Murrayd429f4a2017-03-07 09:31:09 -0800639
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800640 IF_LOG_TRANSACTIONS() {
641 TextOutput::Bundle _b(alog);
642 alog << "BR_REPLY thr " << (void*)pthread_self() << " / hand "
643 << handle << ": ";
644 if (reply) alog << indent << *reply << dedent << endl;
645 else alog << "(none requested)" << endl;
646 }
647 } else {
648 err = waitForResponse(NULL, NULL);
649 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800650
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800651 return err;
652}
653
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700654void IPCThreadState::incStrongHandle(int32_t handle, BpBinder *proxy)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800655{
656 LOG_REMOTEREFS("IPCThreadState::incStrongHandle(%d)\n", handle);
657 mOut.writeInt32(BC_ACQUIRE);
658 mOut.writeInt32(handle);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700659 // Create a temp reference until the driver has handled this command.
660 proxy->incStrong(mProcess.get());
661 mPostWriteStrongDerefs.push(proxy);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800662}
663
664void IPCThreadState::decStrongHandle(int32_t handle)
665{
666 LOG_REMOTEREFS("IPCThreadState::decStrongHandle(%d)\n", handle);
667 mOut.writeInt32(BC_RELEASE);
668 mOut.writeInt32(handle);
669}
670
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700671void IPCThreadState::incWeakHandle(int32_t handle, BpBinder *proxy)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800672{
673 LOG_REMOTEREFS("IPCThreadState::incWeakHandle(%d)\n", handle);
674 mOut.writeInt32(BC_INCREFS);
675 mOut.writeInt32(handle);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700676 // Create a temp reference until the driver has handled this command.
677 proxy->getWeakRefs()->incWeak(mProcess.get());
678 mPostWriteWeakDerefs.push(proxy->getWeakRefs());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800679}
680
681void IPCThreadState::decWeakHandle(int32_t handle)
682{
683 LOG_REMOTEREFS("IPCThreadState::decWeakHandle(%d)\n", handle);
684 mOut.writeInt32(BC_DECREFS);
685 mOut.writeInt32(handle);
686}
687
688status_t IPCThreadState::attemptIncStrongHandle(int32_t handle)
689{
Arve Hjønnevåg11cfdcc2014-02-14 20:14:02 -0800690#if HAS_BC_ATTEMPT_ACQUIRE
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700691 LOG_REMOTEREFS("IPCThreadState::attemptIncStrongHandle(%d)\n", handle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800692 mOut.writeInt32(BC_ATTEMPT_ACQUIRE);
693 mOut.writeInt32(0); // xxx was thread priority
694 mOut.writeInt32(handle);
695 status_t result = UNKNOWN_ERROR;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800696
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800697 waitForResponse(NULL, &result);
Tim Murrayd429f4a2017-03-07 09:31:09 -0800698
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800699#if LOG_REFCOUNTS
liangweikanga43ee152016-10-25 16:37:54 +0800700 ALOGV("IPCThreadState::attemptIncStrongHandle(%ld) = %s\n",
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800701 handle, result == NO_ERROR ? "SUCCESS" : "FAILURE");
702#endif
Tim Murrayd429f4a2017-03-07 09:31:09 -0800703
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800704 return result;
Arve Hjønnevåg11cfdcc2014-02-14 20:14:02 -0800705#else
706 (void)handle;
707 ALOGE("%s(%d): Not supported\n", __func__, handle);
708 return INVALID_OPERATION;
709#endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800710}
711
712void IPCThreadState::expungeHandle(int32_t handle, IBinder* binder)
713{
714#if LOG_REFCOUNTS
liangweikanga43ee152016-10-25 16:37:54 +0800715 ALOGV("IPCThreadState::expungeHandle(%ld)\n", handle);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800716#endif
Manoj Gupta9cec85b2017-09-19 16:34:29 -0700717 self()->mProcess->expungeHandle(handle, binder); // NOLINT
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800718}
719
720status_t IPCThreadState::requestDeathNotification(int32_t handle, BpBinder* proxy)
721{
722 mOut.writeInt32(BC_REQUEST_DEATH_NOTIFICATION);
723 mOut.writeInt32((int32_t)handle);
Serban Constantinescuf683e012013-11-05 16:53:55 +0000724 mOut.writePointer((uintptr_t)proxy);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800725 return NO_ERROR;
726}
727
728status_t IPCThreadState::clearDeathNotification(int32_t handle, BpBinder* proxy)
729{
730 mOut.writeInt32(BC_CLEAR_DEATH_NOTIFICATION);
731 mOut.writeInt32((int32_t)handle);
Serban Constantinescuf683e012013-11-05 16:53:55 +0000732 mOut.writePointer((uintptr_t)proxy);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800733 return NO_ERROR;
734}
735
736IPCThreadState::IPCThreadState()
Brad Fitzpatrick52736032010-08-30 16:01:16 -0700737 : mProcess(ProcessState::self()),
Brad Fitzpatrick52736032010-08-30 16:01:16 -0700738 mStrictModePolicy(0),
739 mLastTransactionBinderFlags(0)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800740{
741 pthread_setspecific(gTLS, this);
Dianne Hackborn8c6cedc2009-12-07 17:59:37 -0800742 clearCaller();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800743 mIn.setDataCapacity(256);
744 mOut.setDataCapacity(256);
745}
746
747IPCThreadState::~IPCThreadState()
748{
749}
750
Martijn Coenenea0090a2017-11-02 18:54:40 +0000751status_t IPCThreadState::sendReply(const Parcel& reply, uint32_t flags)
752{
753 status_t err;
754 status_t statusBuffer;
755 err = writeTransactionData(BC_REPLY, flags, -1, 0, reply, &statusBuffer);
756 if (err < NO_ERROR) return err;
757
758 return waitForResponse(NULL, NULL);
759}
760
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800761status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
762{
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +0100763 uint32_t cmd;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800764 int32_t err;
765
766 while (1) {
767 if ((err=talkWithDriver()) < NO_ERROR) break;
768 err = mIn.errorCheck();
769 if (err < NO_ERROR) break;
770 if (mIn.dataAvail() == 0) continue;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800771
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +0100772 cmd = (uint32_t)mIn.readInt32();
Tim Murrayd429f4a2017-03-07 09:31:09 -0800773
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800774 IF_LOG_COMMANDS() {
775 alog << "Processing waitForResponse Command: "
776 << getReturnString(cmd) << endl;
777 }
778
779 switch (cmd) {
780 case BR_TRANSACTION_COMPLETE:
781 if (!reply && !acquireResult) goto finish;
782 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800783
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800784 case BR_DEAD_REPLY:
785 err = DEAD_OBJECT;
786 goto finish;
787
788 case BR_FAILED_REPLY:
789 err = FAILED_TRANSACTION;
790 goto finish;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800791
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800792 case BR_ACQUIRE_RESULT:
793 {
Steve Block67263472012-01-09 18:35:44 +0000794 ALOG_ASSERT(acquireResult != NULL, "Unexpected brACQUIRE_RESULT");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800795 const int32_t result = mIn.readInt32();
796 if (!acquireResult) continue;
797 *acquireResult = result ? NO_ERROR : INVALID_OPERATION;
798 }
799 goto finish;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800800
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800801 case BR_REPLY:
802 {
803 binder_transaction_data tr;
804 err = mIn.read(&tr, sizeof(tr));
Steve Block67263472012-01-09 18:35:44 +0000805 ALOG_ASSERT(err == NO_ERROR, "Not enough command data for brREPLY");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800806 if (err != NO_ERROR) goto finish;
807
808 if (reply) {
809 if ((tr.flags & TF_STATUS_CODE) == 0) {
810 reply->ipcSetDataReference(
811 reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
812 tr.data_size,
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800813 reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
814 tr.offsets_size/sizeof(binder_size_t),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800815 freeBuffer, this);
816 } else {
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800817 err = *reinterpret_cast<const status_t*>(tr.data.ptr.buffer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800818 freeBuffer(NULL,
819 reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
820 tr.data_size,
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800821 reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
822 tr.offsets_size/sizeof(binder_size_t), this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800823 }
824 } else {
825 freeBuffer(NULL,
826 reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
827 tr.data_size,
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800828 reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
829 tr.offsets_size/sizeof(binder_size_t), this);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800830 continue;
831 }
832 }
833 goto finish;
834
835 default:
836 err = executeCommand(cmd);
837 if (err != NO_ERROR) goto finish;
838 break;
839 }
840 }
841
842finish:
843 if (err != NO_ERROR) {
844 if (acquireResult) *acquireResult = err;
845 if (reply) reply->setError(err);
846 mLastError = err;
847 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800848
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800849 return err;
850}
851
852status_t IPCThreadState::talkWithDriver(bool doReceive)
853{
Johannes Carlssondb1597a2011-02-17 14:06:53 +0100854 if (mProcess->mDriverFD <= 0) {
855 return -EBADF;
856 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800857
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800858 binder_write_read bwr;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800859
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800860 // Is the read buffer empty?
861 const bool needRead = mIn.dataPosition() >= mIn.dataSize();
Tim Murrayd429f4a2017-03-07 09:31:09 -0800862
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800863 // We don't want to write anything if we are still reading
864 // from data left in the input buffer and the caller
865 // has requested to read the next data.
866 const size_t outAvail = (!doReceive || needRead) ? mOut.dataSize() : 0;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800867
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800868 bwr.write_size = outAvail;
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800869 bwr.write_buffer = (uintptr_t)mOut.data();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800870
871 // This is what we'll read.
872 if (doReceive && needRead) {
873 bwr.read_size = mIn.dataCapacity();
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800874 bwr.read_buffer = (uintptr_t)mIn.data();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800875 } else {
876 bwr.read_size = 0;
Ben Chengd640f892011-12-01 17:11:32 -0800877 bwr.read_buffer = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800878 }
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700879
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800880 IF_LOG_COMMANDS() {
881 TextOutput::Bundle _b(alog);
882 if (outAvail != 0) {
883 alog << "Sending commands to driver: " << indent;
884 const void* cmds = (const void*)bwr.write_buffer;
885 const void* end = ((const uint8_t*)cmds)+bwr.write_size;
886 alog << HexDump(cmds, bwr.write_size) << endl;
887 while (cmds < end) cmds = printCommand(alog, cmds);
888 alog << dedent;
889 }
890 alog << "Size of receive buffer: " << bwr.read_size
891 << ", needRead: " << needRead << ", doReceive: " << doReceive << endl;
892 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800893
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800894 // Return immediately if there is nothing to do.
895 if ((bwr.write_size == 0) && (bwr.read_size == 0)) return NO_ERROR;
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700896
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800897 bwr.write_consumed = 0;
898 bwr.read_consumed = 0;
899 status_t err;
900 do {
901 IF_LOG_COMMANDS() {
902 alog << "About to read/write, write size = " << mOut.dataSize() << endl;
903 }
Elliott Hughes6071da72015-08-12 15:27:47 -0700904#if defined(__ANDROID__)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800905 if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
906 err = NO_ERROR;
907 else
908 err = -errno;
909#else
910 err = INVALID_OPERATION;
911#endif
Johannes Carlssondb1597a2011-02-17 14:06:53 +0100912 if (mProcess->mDriverFD <= 0) {
913 err = -EBADF;
914 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800915 IF_LOG_COMMANDS() {
916 alog << "Finished read/write, write size = " << mOut.dataSize() << endl;
917 }
918 } while (err == -EINTR);
Andy McFaddenaefc9cd2011-08-31 07:43:40 -0700919
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800920 IF_LOG_COMMANDS() {
Colin Cross6f4f3ab2014-02-05 17:42:44 -0800921 alog << "Our err: " << (void*)(intptr_t)err << ", write consumed: "
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800922 << bwr.write_consumed << " (of " << mOut.dataSize()
Todd Poynor8d96cab2013-06-25 19:12:18 -0700923 << "), read consumed: " << bwr.read_consumed << endl;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800924 }
925
926 if (err >= NO_ERROR) {
927 if (bwr.write_consumed > 0) {
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800928 if (bwr.write_consumed < mOut.dataSize())
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800929 mOut.remove(0, bwr.write_consumed);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700930 else {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800931 mOut.setDataSize(0);
Martijn Coenen7c170bb2018-05-04 17:28:55 -0700932 processPostWriteDerefs();
933 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800934 }
935 if (bwr.read_consumed > 0) {
936 mIn.setDataSize(bwr.read_consumed);
937 mIn.setDataPosition(0);
938 }
939 IF_LOG_COMMANDS() {
940 TextOutput::Bundle _b(alog);
941 alog << "Remaining data size: " << mOut.dataSize() << endl;
942 alog << "Received commands from driver: " << indent;
943 const void* cmds = mIn.data();
944 const void* end = mIn.data() + mIn.dataSize();
945 alog << HexDump(cmds, mIn.dataSize()) << endl;
946 while (cmds < end) cmds = printReturnCommand(alog, cmds);
947 alog << dedent;
948 }
949 return NO_ERROR;
950 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800951
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800952 return err;
953}
954
955status_t IPCThreadState::writeTransactionData(int32_t cmd, uint32_t binderFlags,
956 int32_t handle, uint32_t code, const Parcel& data, status_t* statusBuffer)
957{
958 binder_transaction_data tr;
959
Arve Hjønnevåg07fd0f12014-02-18 21:10:29 -0800960 tr.target.ptr = 0; /* Don't pass uninitialized stack data to a remote process */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800961 tr.target.handle = handle;
962 tr.code = code;
963 tr.flags = binderFlags;
Evgeniy Stepanovd5474322011-04-21 14:15:00 +0400964 tr.cookie = 0;
965 tr.sender_pid = 0;
966 tr.sender_euid = 0;
Tim Murrayd429f4a2017-03-07 09:31:09 -0800967
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800968 const status_t err = data.errorCheck();
969 if (err == NO_ERROR) {
970 tr.data_size = data.ipcDataSize();
971 tr.data.ptr.buffer = data.ipcData();
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800972 tr.offsets_size = data.ipcObjectsCount()*sizeof(binder_size_t);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800973 tr.data.ptr.offsets = data.ipcObjects();
974 } else if (statusBuffer) {
975 tr.flags |= TF_STATUS_CODE;
976 *statusBuffer = err;
977 tr.data_size = sizeof(status_t);
Arve Hjønnevåg87b30d02014-02-18 21:04:31 -0800978 tr.data.ptr.buffer = reinterpret_cast<uintptr_t>(statusBuffer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800979 tr.offsets_size = 0;
Arve Hjønnevåg84e625a2014-01-28 20:12:59 -0800980 tr.data.ptr.offsets = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800981 } else {
982 return (mLastError = err);
983 }
Tim Murrayd429f4a2017-03-07 09:31:09 -0800984
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800985 mOut.writeInt32(cmd);
986 mOut.write(&tr, sizeof(tr));
Tim Murrayd429f4a2017-03-07 09:31:09 -0800987
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800988 return NO_ERROR;
989}
990
991sp<BBinder> the_context_object;
992
993void setTheContextObject(sp<BBinder> obj)
994{
995 the_context_object = obj;
996}
997
998status_t IPCThreadState::executeCommand(int32_t cmd)
999{
1000 BBinder* obj;
1001 RefBase::weakref_type* refs;
1002 status_t result = NO_ERROR;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001003
Bernhard Rosenkränzer74debb02014-11-25 21:55:33 +01001004 switch ((uint32_t)cmd) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001005 case BR_ERROR:
1006 result = mIn.readInt32();
1007 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001008
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001009 case BR_OK:
1010 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001011
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001012 case BR_ACQUIRE:
Serban Constantinescuf683e012013-11-05 16:53:55 +00001013 refs = (RefBase::weakref_type*)mIn.readPointer();
1014 obj = (BBinder*)mIn.readPointer();
Steve Block67263472012-01-09 18:35:44 +00001015 ALOG_ASSERT(refs->refBase() == obj,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001016 "BR_ACQUIRE: object %p does not match cookie %p (expected %p)",
1017 refs, obj, refs->refBase());
1018 obj->incStrong(mProcess.get());
1019 IF_LOG_REMOTEREFS() {
1020 LOG_REMOTEREFS("BR_ACQUIRE from driver on %p", obj);
1021 obj->printRefs();
1022 }
1023 mOut.writeInt32(BC_ACQUIRE_DONE);
Serban Constantinescuf683e012013-11-05 16:53:55 +00001024 mOut.writePointer((uintptr_t)refs);
1025 mOut.writePointer((uintptr_t)obj);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001026 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001027
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001028 case BR_RELEASE:
Serban Constantinescuf683e012013-11-05 16:53:55 +00001029 refs = (RefBase::weakref_type*)mIn.readPointer();
1030 obj = (BBinder*)mIn.readPointer();
Steve Block67263472012-01-09 18:35:44 +00001031 ALOG_ASSERT(refs->refBase() == obj,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001032 "BR_RELEASE: object %p does not match cookie %p (expected %p)",
1033 refs, obj, refs->refBase());
1034 IF_LOG_REMOTEREFS() {
1035 LOG_REMOTEREFS("BR_RELEASE from driver on %p", obj);
1036 obj->printRefs();
1037 }
1038 mPendingStrongDerefs.push(obj);
1039 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001040
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001041 case BR_INCREFS:
Serban Constantinescuf683e012013-11-05 16:53:55 +00001042 refs = (RefBase::weakref_type*)mIn.readPointer();
1043 obj = (BBinder*)mIn.readPointer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001044 refs->incWeak(mProcess.get());
1045 mOut.writeInt32(BC_INCREFS_DONE);
Serban Constantinescuf683e012013-11-05 16:53:55 +00001046 mOut.writePointer((uintptr_t)refs);
1047 mOut.writePointer((uintptr_t)obj);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001048 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001049
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001050 case BR_DECREFS:
Serban Constantinescuf683e012013-11-05 16:53:55 +00001051 refs = (RefBase::weakref_type*)mIn.readPointer();
1052 obj = (BBinder*)mIn.readPointer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001053 // NOTE: This assertion is not valid, because the object may no
1054 // longer exist (thus the (BBinder*)cast above resulting in a different
1055 // memory address).
Steve Block67263472012-01-09 18:35:44 +00001056 //ALOG_ASSERT(refs->refBase() == obj,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001057 // "BR_DECREFS: object %p does not match cookie %p (expected %p)",
1058 // refs, obj, refs->refBase());
1059 mPendingWeakDerefs.push(refs);
1060 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001061
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001062 case BR_ATTEMPT_ACQUIRE:
Serban Constantinescuf683e012013-11-05 16:53:55 +00001063 refs = (RefBase::weakref_type*)mIn.readPointer();
1064 obj = (BBinder*)mIn.readPointer();
Tim Murrayd429f4a2017-03-07 09:31:09 -08001065
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001066 {
1067 const bool success = refs->attemptIncStrong(mProcess.get());
Steve Block67263472012-01-09 18:35:44 +00001068 ALOG_ASSERT(success && refs->refBase() == obj,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001069 "BR_ATTEMPT_ACQUIRE: object %p does not match cookie %p (expected %p)",
1070 refs, obj, refs->refBase());
Tim Murrayd429f4a2017-03-07 09:31:09 -08001071
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001072 mOut.writeInt32(BC_ACQUIRE_RESULT);
1073 mOut.writeInt32((int32_t)success);
1074 }
1075 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001076
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001077 case BR_TRANSACTION:
1078 {
1079 binder_transaction_data tr;
1080 result = mIn.read(&tr, sizeof(tr));
Steve Block67263472012-01-09 18:35:44 +00001081 ALOG_ASSERT(result == NO_ERROR,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001082 "Not enough command data for brTRANSACTION");
1083 if (result != NO_ERROR) break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001084
Martijn Coenenea0090a2017-11-02 18:54:40 +00001085 Parcel buffer;
1086 buffer.ipcSetDataReference(
1087 reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
1088 tr.data_size,
1089 reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
1090 tr.offsets_size/sizeof(binder_size_t), freeBuffer, this);
1091
1092 const pid_t origPid = mCallingPid;
1093 const uid_t origUid = mCallingUid;
1094 const int32_t origStrictModePolicy = mStrictModePolicy;
1095 const int32_t origTransactionBinderFlags = mLastTransactionBinderFlags;
1096
1097 mCallingPid = tr.sender_pid;
1098 mCallingUid = tr.sender_euid;
1099 mLastTransactionBinderFlags = tr.flags;
1100
1101 //ALOGI(">>>> TRANSACT from pid %d uid %d\n", mCallingPid, mCallingUid);
1102
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001103 Parcel reply;
Martijn Coenenea0090a2017-11-02 18:54:40 +00001104 status_t error;
1105 IF_LOG_TRANSACTIONS() {
1106 TextOutput::Bundle _b(alog);
1107 alog << "BR_TRANSACTION thr " << (void*)pthread_self()
1108 << " / obj " << tr.target.ptr << " / code "
1109 << TypeCode(tr.code) << ": " << indent << buffer
1110 << dedent << endl
1111 << "Data addr = "
1112 << reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer)
1113 << ", offsets addr="
1114 << reinterpret_cast<const size_t*>(tr.data.ptr.offsets) << endl;
1115 }
1116 if (tr.target.ptr) {
1117 // We only have a weak reference on the target object, so we must first try to
1118 // safely acquire a strong reference before doing anything else with it.
1119 if (reinterpret_cast<RefBase::weakref_type*>(
1120 tr.target.ptr)->attemptIncStrong(this)) {
1121 error = reinterpret_cast<BBinder*>(tr.cookie)->transact(tr.code, buffer,
1122 &reply, tr.flags);
1123 reinterpret_cast<BBinder*>(tr.cookie)->decStrong(this);
Dianne Hackbornc1114612016-03-21 10:36:54 -07001124 } else {
Martijn Coenenea0090a2017-11-02 18:54:40 +00001125 error = UNKNOWN_TRANSACTION;
Dianne Hackbornc1114612016-03-21 10:36:54 -07001126 }
Brad Fitzpatrick52736032010-08-30 16:01:16 -07001127
Martijn Coenenea0090a2017-11-02 18:54:40 +00001128 } else {
1129 error = the_context_object->transact(tr.code, buffer, &reply, tr.flags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001130 }
Dianne Hackborn5ee2c9d2014-09-30 11:30:03 -07001131
Martijn Coenenea0090a2017-11-02 18:54:40 +00001132 //ALOGI("<<<< TRANSACT from pid %d restore pid %d uid %d\n",
1133 // mCallingPid, origPid, origUid);
Tim Murrayd429f4a2017-03-07 09:31:09 -08001134
Martijn Coenenea0090a2017-11-02 18:54:40 +00001135 if ((tr.flags & TF_ONE_WAY) == 0) {
1136 LOG_ONEWAY("Sending reply to %d!", mCallingPid);
1137 if (error < NO_ERROR) reply.setError(error);
1138 sendReply(reply, 0);
1139 } else {
1140 LOG_ONEWAY("NOT sending reply to %d!", mCallingPid);
1141 }
1142
1143 mCallingPid = origPid;
1144 mCallingUid = origUid;
1145 mStrictModePolicy = origStrictModePolicy;
1146 mLastTransactionBinderFlags = origTransactionBinderFlags;
Christopher Tate440fd872010-03-18 17:55:03 -07001147
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001148 IF_LOG_TRANSACTIONS() {
1149 TextOutput::Bundle _b(alog);
1150 alog << "BC_REPLY thr " << (void*)pthread_self() << " / obj "
1151 << tr.target.ptr << ": " << indent << reply << dedent << endl;
1152 }
Tim Murrayd429f4a2017-03-07 09:31:09 -08001153
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001154 }
1155 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001156
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001157 case BR_DEAD_BINDER:
1158 {
Serban Constantinescuf683e012013-11-05 16:53:55 +00001159 BpBinder *proxy = (BpBinder*)mIn.readPointer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001160 proxy->sendObituary();
1161 mOut.writeInt32(BC_DEAD_BINDER_DONE);
Serban Constantinescuf683e012013-11-05 16:53:55 +00001162 mOut.writePointer((uintptr_t)proxy);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001163 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001164
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001165 case BR_CLEAR_DEATH_NOTIFICATION_DONE:
1166 {
Serban Constantinescuf683e012013-11-05 16:53:55 +00001167 BpBinder *proxy = (BpBinder*)mIn.readPointer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001168 proxy->getWeakRefs()->decWeak(proxy);
1169 } break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001170
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001171 case BR_FINISHED:
1172 result = TIMED_OUT;
1173 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001174
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001175 case BR_NOOP:
1176 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001177
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001178 case BR_SPAWN_LOOPER:
1179 mProcess->spawnPooledThread(false);
1180 break;
Tim Murrayd429f4a2017-03-07 09:31:09 -08001181
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001182 default:
liangweikanga43ee152016-10-25 16:37:54 +08001183 ALOGE("*** BAD COMMAND %d received from Binder driver\n", cmd);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001184 result = UNKNOWN_ERROR;
1185 break;
1186 }
1187
1188 if (result != NO_ERROR) {
1189 mLastError = result;
1190 }
Tim Murrayd429f4a2017-03-07 09:31:09 -08001191
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001192 return result;
1193}
1194
1195void IPCThreadState::threadDestructor(void *st)
1196{
Todd Poynor8d96cab2013-06-25 19:12:18 -07001197 IPCThreadState* const self = static_cast<IPCThreadState*>(st);
1198 if (self) {
1199 self->flushCommands();
Elliott Hughes6071da72015-08-12 15:27:47 -07001200#if defined(__ANDROID__)
Johannes Carlssondb1597a2011-02-17 14:06:53 +01001201 if (self->mProcess->mDriverFD > 0) {
1202 ioctl(self->mProcess->mDriverFD, BINDER_THREAD_EXIT, 0);
1203 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001204#endif
Todd Poynor8d96cab2013-06-25 19:12:18 -07001205 delete self;
1206 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001207}
1208
1209
Colin Cross6f4f3ab2014-02-05 17:42:44 -08001210void IPCThreadState::freeBuffer(Parcel* parcel, const uint8_t* data,
1211 size_t /*dataSize*/,
1212 const binder_size_t* /*objects*/,
1213 size_t /*objectsSize*/, void* /*cookie*/)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001214{
Steve Blocka19954a2012-01-04 20:05:49 +00001215 //ALOGI("Freeing parcel %p", &parcel);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001216 IF_LOG_COMMANDS() {
1217 alog << "Writing BC_FREE_BUFFER for " << data << endl;
1218 }
Steve Block67263472012-01-09 18:35:44 +00001219 ALOG_ASSERT(data != NULL, "Called with NULL data");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001220 if (parcel != NULL) parcel->closeFileDescriptors();
1221 IPCThreadState* state = self();
1222 state->mOut.writeInt32(BC_FREE_BUFFER);
Serban Constantinescuf683e012013-11-05 16:53:55 +00001223 state->mOut.writePointer((uintptr_t)data);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001224}
1225
1226}; // namespace android