1 /* 2 * Copyright (C) 2012 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 17 package com.android.server.am; 18 19 import java.io.FileDescriptor; 20 import java.io.PrintWriter; 21 import java.util.ArrayList; 22 23 import android.app.ActivityManager; 24 import android.app.AppGlobals; 25 import android.app.AppOpsManager; 26 import android.content.ComponentName; 27 import android.content.IIntentReceiver; 28 import android.content.Intent; 29 import android.content.pm.ActivityInfo; 30 import android.content.pm.PackageManager; 31 import android.content.pm.ResolveInfo; 32 import android.os.Bundle; 33 import android.os.Handler; 34 import android.os.IBinder; 35 import android.os.Message; 36 import android.os.Process; 37 import android.os.RemoteException; 38 import android.os.SystemClock; 39 import android.os.UserHandle; 40 import android.util.EventLog; 41 import android.util.Log; 42 import android.util.Slog; 43 44 /** 45 * BROADCASTS 46 * 47 * We keep two broadcast queues and associated bookkeeping, one for those at 48 * foreground priority, and one for normal (background-priority) broadcasts. 49 */ 50 public class BroadcastQueue { 51 static final String TAG = "BroadcastQueue"; 52 static final String TAG_MU = ActivityManagerService.TAG_MU; 53 static final boolean DEBUG_BROADCAST = ActivityManagerService.DEBUG_BROADCAST; 54 static final boolean DEBUG_BROADCAST_LIGHT = ActivityManagerService.DEBUG_BROADCAST_LIGHT; 55 static final boolean DEBUG_MU = ActivityManagerService.DEBUG_MU; 56 57 static final int MAX_BROADCAST_HISTORY = 25; 58 static final int MAX_BROADCAST_SUMMARY_HISTORY = 100; 59 60 final ActivityManagerService mService; 61 62 /** 63 * Recognizable moniker for this queue 64 */ 65 final String mQueueName; 66 67 /** 68 * Timeout period for this queue's broadcasts 69 */ 70 final long mTimeoutPeriod; 71 72 /** 73 * Lists of all active broadcasts that are to be executed immediately 74 * (without waiting for another broadcast to finish). Currently this only 75 * contains broadcasts to registered receivers, to avoid spinning up 76 * a bunch of processes to execute IntentReceiver components. Background- 77 * and foreground-priority broadcasts are queued separately. 78 */ 79 final ArrayList<BroadcastRecord> mParallelBroadcasts 80 = new ArrayList<BroadcastRecord>(); 81 /** 82 * List of all active broadcasts that are to be executed one at a time. 83 * The object at the top of the list is the currently activity broadcasts; 84 * those after it are waiting for the top to finish. As with parallel 85 * broadcasts, separate background- and foreground-priority queues are 86 * maintained. 87 */ 88 final ArrayList<BroadcastRecord> mOrderedBroadcasts 89 = new ArrayList<BroadcastRecord>(); 90 91 /** 92 * Historical data of past broadcasts, for debugging. 93 */ 94 final BroadcastRecord[] mBroadcastHistory 95 = new BroadcastRecord[MAX_BROADCAST_HISTORY]; 96 97 /** 98 * Summary of historical data of past broadcasts, for debugging. 99 */ 100 final Intent[] mBroadcastSummaryHistory 101 = new Intent[MAX_BROADCAST_SUMMARY_HISTORY]; 102 103 /** 104 * Set when we current have a BROADCAST_INTENT_MSG in flight. 105 */ 106 boolean mBroadcastsScheduled = false; 107 108 /** 109 * True if we have a pending unexpired BROADCAST_TIMEOUT_MSG posted to our handler. 110 */ 111 boolean mPendingBroadcastTimeoutMessage; 112 113 /** 114 * Intent broadcasts that we have tried to start, but are 115 * waiting for the application's process to be created. We only 116 * need one per scheduling class (instead of a list) because we always 117 * process broadcasts one at a time, so no others can be started while 118 * waiting for this one. 119 */ 120 BroadcastRecord mPendingBroadcast = null; 121 122 /** 123 * The receiver index that is pending, to restart the broadcast if needed. 124 */ 125 int mPendingBroadcastRecvIndex; 126 127 static final int BROADCAST_INTENT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG; 128 static final int BROADCAST_TIMEOUT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG + 1; 129 130 final Handler mHandler = new Handler() { 131 //public Handler() { 132 // if (localLOGV) Slog.v(TAG, "Handler started!"); 133 //} 134 135 public void handleMessage(Message msg) { 136 switch (msg.what) { 137 case BROADCAST_INTENT_MSG: { 138 if (DEBUG_BROADCAST) Slog.v( 139 TAG, "Received BROADCAST_INTENT_MSG"); 140 processNextBroadcast(true); 141 } break; 142 case BROADCAST_TIMEOUT_MSG: { 143 synchronized (mService) { 144 broadcastTimeoutLocked(true); 145 } 146 } break; 147 } 148 } 149 }; 150 151 private final class AppNotResponding implements Runnable { 152 private final ProcessRecord mApp; 153 private final String mAnnotation; 154 AppNotResponding(ProcessRecord app, String annotation)155 public AppNotResponding(ProcessRecord app, String annotation) { 156 mApp = app; 157 mAnnotation = annotation; 158 } 159 160 @Override run()161 public void run() { 162 mService.appNotResponding(mApp, null, null, false, mAnnotation); 163 } 164 } 165 BroadcastQueue(ActivityManagerService service, String name, long timeoutPeriod)166 BroadcastQueue(ActivityManagerService service, String name, long timeoutPeriod) { 167 mService = service; 168 mQueueName = name; 169 mTimeoutPeriod = timeoutPeriod; 170 } 171 isPendingBroadcastProcessLocked(int pid)172 public boolean isPendingBroadcastProcessLocked(int pid) { 173 return mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid; 174 } 175 enqueueParallelBroadcastLocked(BroadcastRecord r)176 public void enqueueParallelBroadcastLocked(BroadcastRecord r) { 177 mParallelBroadcasts.add(r); 178 } 179 enqueueOrderedBroadcastLocked(BroadcastRecord r)180 public void enqueueOrderedBroadcastLocked(BroadcastRecord r) { 181 mOrderedBroadcasts.add(r); 182 } 183 replaceParallelBroadcastLocked(BroadcastRecord r)184 public final boolean replaceParallelBroadcastLocked(BroadcastRecord r) { 185 for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { 186 if (r.intent.filterEquals(mParallelBroadcasts.get(i).intent)) { 187 if (DEBUG_BROADCAST) Slog.v(TAG, 188 "***** DROPPING PARALLEL [" 189 + mQueueName + "]: " + r.intent); 190 mParallelBroadcasts.set(i, r); 191 return true; 192 } 193 } 194 return false; 195 } 196 replaceOrderedBroadcastLocked(BroadcastRecord r)197 public final boolean replaceOrderedBroadcastLocked(BroadcastRecord r) { 198 for (int i=mOrderedBroadcasts.size()-1; i>0; i--) { 199 if (r.intent.filterEquals(mOrderedBroadcasts.get(i).intent)) { 200 if (DEBUG_BROADCAST) Slog.v(TAG, 201 "***** DROPPING ORDERED [" 202 + mQueueName + "]: " + r.intent); 203 mOrderedBroadcasts.set(i, r); 204 return true; 205 } 206 } 207 return false; 208 } 209 processCurBroadcastLocked(BroadcastRecord r, ProcessRecord app)210 private final void processCurBroadcastLocked(BroadcastRecord r, 211 ProcessRecord app) throws RemoteException { 212 if (DEBUG_BROADCAST) Slog.v(TAG, 213 "Process cur broadcast " + r + " for app " + app); 214 if (app.thread == null) { 215 throw new RemoteException(); 216 } 217 r.receiver = app.thread.asBinder(); 218 r.curApp = app; 219 app.curReceiver = r; 220 mService.updateLruProcessLocked(app, true); 221 222 // Tell the application to launch this receiver. 223 r.intent.setComponent(r.curComponent); 224 225 boolean started = false; 226 try { 227 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, 228 "Delivering to component " + r.curComponent 229 + ": " + r); 230 mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName()); 231 app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver, 232 mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo), 233 r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId); 234 if (DEBUG_BROADCAST) Slog.v(TAG, 235 "Process cur broadcast " + r + " DELIVERED for app " + app); 236 started = true; 237 } finally { 238 if (!started) { 239 if (DEBUG_BROADCAST) Slog.v(TAG, 240 "Process cur broadcast " + r + ": NOT STARTED!"); 241 r.receiver = null; 242 r.curApp = null; 243 app.curReceiver = null; 244 } 245 } 246 } 247 sendPendingBroadcastsLocked(ProcessRecord app)248 public boolean sendPendingBroadcastsLocked(ProcessRecord app) { 249 boolean didSomething = false; 250 final BroadcastRecord br = mPendingBroadcast; 251 if (br != null && br.curApp.pid == app.pid) { 252 try { 253 mPendingBroadcast = null; 254 processCurBroadcastLocked(br, app); 255 didSomething = true; 256 } catch (Exception e) { 257 Slog.w(TAG, "Exception in new application when starting receiver " 258 + br.curComponent.flattenToShortString(), e); 259 logBroadcastReceiverDiscardLocked(br); 260 finishReceiverLocked(br, br.resultCode, br.resultData, 261 br.resultExtras, br.resultAbort, true); 262 scheduleBroadcastsLocked(); 263 // We need to reset the state if we failed to start the receiver. 264 br.state = BroadcastRecord.IDLE; 265 throw new RuntimeException(e.getMessage()); 266 } 267 } 268 return didSomething; 269 } 270 skipPendingBroadcastLocked(int pid)271 public void skipPendingBroadcastLocked(int pid) { 272 final BroadcastRecord br = mPendingBroadcast; 273 if (br != null && br.curApp.pid == pid) { 274 br.state = BroadcastRecord.IDLE; 275 br.nextReceiver = mPendingBroadcastRecvIndex; 276 mPendingBroadcast = null; 277 scheduleBroadcastsLocked(); 278 } 279 } 280 skipCurrentReceiverLocked(ProcessRecord app)281 public void skipCurrentReceiverLocked(ProcessRecord app) { 282 boolean reschedule = false; 283 BroadcastRecord r = app.curReceiver; 284 if (r != null) { 285 // The current broadcast is waiting for this app's receiver 286 // to be finished. Looks like that's not going to happen, so 287 // let the broadcast continue. 288 logBroadcastReceiverDiscardLocked(r); 289 finishReceiverLocked(r, r.resultCode, r.resultData, 290 r.resultExtras, r.resultAbort, true); 291 reschedule = true; 292 } 293 294 r = mPendingBroadcast; 295 if (r != null && r.curApp == app) { 296 if (DEBUG_BROADCAST) Slog.v(TAG, 297 "[" + mQueueName + "] skip & discard pending app " + r); 298 logBroadcastReceiverDiscardLocked(r); 299 finishReceiverLocked(r, r.resultCode, r.resultData, 300 r.resultExtras, r.resultAbort, true); 301 reschedule = true; 302 } 303 if (reschedule) { 304 scheduleBroadcastsLocked(); 305 } 306 } 307 scheduleBroadcastsLocked()308 public void scheduleBroadcastsLocked() { 309 if (DEBUG_BROADCAST) Slog.v(TAG, "Schedule broadcasts [" 310 + mQueueName + "]: current=" 311 + mBroadcastsScheduled); 312 313 if (mBroadcastsScheduled) { 314 return; 315 } 316 mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this)); 317 mBroadcastsScheduled = true; 318 } 319 getMatchingOrderedReceiver(IBinder receiver)320 public BroadcastRecord getMatchingOrderedReceiver(IBinder receiver) { 321 if (mOrderedBroadcasts.size() > 0) { 322 final BroadcastRecord r = mOrderedBroadcasts.get(0); 323 if (r != null && r.receiver == receiver) { 324 return r; 325 } 326 } 327 return null; 328 } 329 finishReceiverLocked(BroadcastRecord r, int resultCode, String resultData, Bundle resultExtras, boolean resultAbort, boolean explicit)330 public boolean finishReceiverLocked(BroadcastRecord r, int resultCode, 331 String resultData, Bundle resultExtras, boolean resultAbort, 332 boolean explicit) { 333 int state = r.state; 334 r.state = BroadcastRecord.IDLE; 335 if (state == BroadcastRecord.IDLE) { 336 if (explicit) { 337 Slog.w(TAG, "finishReceiver [" + mQueueName + "] called but state is IDLE"); 338 } 339 } 340 r.receiver = null; 341 r.intent.setComponent(null); 342 if (r.curApp != null) { 343 r.curApp.curReceiver = null; 344 } 345 if (r.curFilter != null) { 346 r.curFilter.receiverList.curBroadcast = null; 347 } 348 r.curFilter = null; 349 r.curApp = null; 350 r.curComponent = null; 351 r.curReceiver = null; 352 mPendingBroadcast = null; 353 354 r.resultCode = resultCode; 355 r.resultData = resultData; 356 r.resultExtras = resultExtras; 357 r.resultAbort = resultAbort; 358 359 // We will process the next receiver right now if this is finishing 360 // an app receiver (which is always asynchronous) or after we have 361 // come back from calling a receiver. 362 return state == BroadcastRecord.APP_RECEIVE 363 || state == BroadcastRecord.CALL_DONE_RECEIVE; 364 } 365 performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser)366 private static void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, 367 Intent intent, int resultCode, String data, Bundle extras, 368 boolean ordered, boolean sticky, int sendingUser) throws RemoteException { 369 // Send the intent to the receiver asynchronously using one-way binder calls. 370 if (app != null && app.thread != null) { 371 // If we have an app thread, do the call through that so it is 372 // correctly ordered with other one-way calls. 373 app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode, 374 data, extras, ordered, sticky, sendingUser); 375 } else { 376 receiver.performReceive(intent, resultCode, data, extras, ordered, 377 sticky, sendingUser); 378 } 379 } 380 deliverToRegisteredReceiverLocked(BroadcastRecord r, BroadcastFilter filter, boolean ordered)381 private final void deliverToRegisteredReceiverLocked(BroadcastRecord r, 382 BroadcastFilter filter, boolean ordered) { 383 boolean skip = false; 384 if (filter.requiredPermission != null) { 385 int perm = mService.checkComponentPermission(filter.requiredPermission, 386 r.callingPid, r.callingUid, -1, true); 387 if (perm != PackageManager.PERMISSION_GRANTED) { 388 Slog.w(TAG, "Permission Denial: broadcasting " 389 + r.intent.toString() 390 + " from " + r.callerPackage + " (pid=" 391 + r.callingPid + ", uid=" + r.callingUid + ")" 392 + " requires " + filter.requiredPermission 393 + " due to registered receiver " + filter); 394 skip = true; 395 } 396 } 397 if (!skip && r.requiredPermission != null) { 398 int perm = mService.checkComponentPermission(r.requiredPermission, 399 filter.receiverList.pid, filter.receiverList.uid, -1, true); 400 if (perm != PackageManager.PERMISSION_GRANTED) { 401 Slog.w(TAG, "Permission Denial: receiving " 402 + r.intent.toString() 403 + " to " + filter.receiverList.app 404 + " (pid=" + filter.receiverList.pid 405 + ", uid=" + filter.receiverList.uid + ")" 406 + " requires " + r.requiredPermission 407 + " due to sender " + r.callerPackage 408 + " (uid " + r.callingUid + ")"); 409 skip = true; 410 } 411 } 412 if (r.appOp != AppOpsManager.OP_NONE) { 413 int mode = mService.mAppOpsService.checkOperation(r.appOp, 414 filter.receiverList.uid, filter.packageName); 415 if (mode != AppOpsManager.MODE_ALLOWED) { 416 if (DEBUG_BROADCAST) Slog.v(TAG, 417 "App op " + r.appOp + " not allowed for broadcast to uid " 418 + filter.receiverList.uid + " pkg " + filter.packageName); 419 skip = true; 420 } 421 } 422 423 if (!skip) { 424 // If this is not being sent as an ordered broadcast, then we 425 // don't want to touch the fields that keep track of the current 426 // state of ordered broadcasts. 427 if (ordered) { 428 r.receiver = filter.receiverList.receiver.asBinder(); 429 r.curFilter = filter; 430 filter.receiverList.curBroadcast = r; 431 r.state = BroadcastRecord.CALL_IN_RECEIVE; 432 if (filter.receiverList.app != null) { 433 // Bump hosting application to no longer be in background 434 // scheduling class. Note that we can't do that if there 435 // isn't an app... but we can only be in that case for 436 // things that directly call the IActivityManager API, which 437 // are already core system stuff so don't matter for this. 438 r.curApp = filter.receiverList.app; 439 filter.receiverList.app.curReceiver = r; 440 mService.updateOomAdjLocked(); 441 } 442 } 443 try { 444 if (DEBUG_BROADCAST_LIGHT) { 445 int seq = r.intent.getIntExtra("seq", -1); 446 Slog.i(TAG, "Delivering to " + filter 447 + " (seq=" + seq + "): " + r); 448 } 449 performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver, 450 new Intent(r.intent), r.resultCode, r.resultData, 451 r.resultExtras, r.ordered, r.initialSticky, r.userId); 452 if (ordered) { 453 r.state = BroadcastRecord.CALL_DONE_RECEIVE; 454 } 455 } catch (RemoteException e) { 456 Slog.w(TAG, "Failure sending broadcast " + r.intent, e); 457 if (ordered) { 458 r.receiver = null; 459 r.curFilter = null; 460 filter.receiverList.curBroadcast = null; 461 if (filter.receiverList.app != null) { 462 filter.receiverList.app.curReceiver = null; 463 } 464 } 465 } 466 } 467 } 468 processNextBroadcast(boolean fromMsg)469 final void processNextBroadcast(boolean fromMsg) { 470 synchronized(mService) { 471 BroadcastRecord r; 472 473 if (DEBUG_BROADCAST) Slog.v(TAG, "processNextBroadcast [" 474 + mQueueName + "]: " 475 + mParallelBroadcasts.size() + " broadcasts, " 476 + mOrderedBroadcasts.size() + " ordered broadcasts"); 477 478 mService.updateCpuStats(); 479 480 if (fromMsg) { 481 mBroadcastsScheduled = false; 482 } 483 484 // First, deliver any non-serialized broadcasts right away. 485 while (mParallelBroadcasts.size() > 0) { 486 r = mParallelBroadcasts.remove(0); 487 r.dispatchTime = SystemClock.uptimeMillis(); 488 r.dispatchClockTime = System.currentTimeMillis(); 489 final int N = r.receivers.size(); 490 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing parallel broadcast [" 491 + mQueueName + "] " + r); 492 for (int i=0; i<N; i++) { 493 Object target = r.receivers.get(i); 494 if (DEBUG_BROADCAST) Slog.v(TAG, 495 "Delivering non-ordered on [" + mQueueName + "] to registered " 496 + target + ": " + r); 497 deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false); 498 } 499 addBroadcastToHistoryLocked(r); 500 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Done with parallel broadcast [" 501 + mQueueName + "] " + r); 502 } 503 504 // Now take care of the next serialized one... 505 506 // If we are waiting for a process to come up to handle the next 507 // broadcast, then do nothing at this point. Just in case, we 508 // check that the process we're waiting for still exists. 509 if (mPendingBroadcast != null) { 510 if (DEBUG_BROADCAST_LIGHT) { 511 Slog.v(TAG, "processNextBroadcast [" 512 + mQueueName + "]: waiting for " 513 + mPendingBroadcast.curApp); 514 } 515 516 boolean isDead; 517 synchronized (mService.mPidsSelfLocked) { 518 isDead = (mService.mPidsSelfLocked.get( 519 mPendingBroadcast.curApp.pid) == null); 520 } 521 if (!isDead) { 522 // It's still alive, so keep waiting 523 return; 524 } else { 525 Slog.w(TAG, "pending app [" 526 + mQueueName + "]" + mPendingBroadcast.curApp 527 + " died before responding to broadcast"); 528 mPendingBroadcast.state = BroadcastRecord.IDLE; 529 mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex; 530 mPendingBroadcast = null; 531 } 532 } 533 534 boolean looped = false; 535 536 do { 537 if (mOrderedBroadcasts.size() == 0) { 538 // No more broadcasts pending, so all done! 539 mService.scheduleAppGcsLocked(); 540 if (looped) { 541 // If we had finished the last ordered broadcast, then 542 // make sure all processes have correct oom and sched 543 // adjustments. 544 mService.updateOomAdjLocked(); 545 } 546 return; 547 } 548 r = mOrderedBroadcasts.get(0); 549 boolean forceReceive = false; 550 551 // Ensure that even if something goes awry with the timeout 552 // detection, we catch "hung" broadcasts here, discard them, 553 // and continue to make progress. 554 // 555 // This is only done if the system is ready so that PRE_BOOT_COMPLETED 556 // receivers don't get executed with timeouts. They're intended for 557 // one time heavy lifting after system upgrades and can take 558 // significant amounts of time. 559 int numReceivers = (r.receivers != null) ? r.receivers.size() : 0; 560 if (mService.mProcessesReady && r.dispatchTime > 0) { 561 long now = SystemClock.uptimeMillis(); 562 if ((numReceivers > 0) && 563 (now > r.dispatchTime + (2*mTimeoutPeriod*numReceivers))) { 564 Slog.w(TAG, "Hung broadcast [" 565 + mQueueName + "] discarded after timeout failure:" 566 + " now=" + now 567 + " dispatchTime=" + r.dispatchTime 568 + " startTime=" + r.receiverTime 569 + " intent=" + r.intent 570 + " numReceivers=" + numReceivers 571 + " nextReceiver=" + r.nextReceiver 572 + " state=" + r.state); 573 broadcastTimeoutLocked(false); // forcibly finish this broadcast 574 forceReceive = true; 575 r.state = BroadcastRecord.IDLE; 576 } 577 } 578 579 if (r.state != BroadcastRecord.IDLE) { 580 if (DEBUG_BROADCAST) Slog.d(TAG, 581 "processNextBroadcast(" 582 + mQueueName + ") called when not idle (state=" 583 + r.state + ")"); 584 return; 585 } 586 587 if (r.receivers == null || r.nextReceiver >= numReceivers 588 || r.resultAbort || forceReceive) { 589 // No more receivers for this broadcast! Send the final 590 // result if requested... 591 if (r.resultTo != null) { 592 try { 593 if (DEBUG_BROADCAST) { 594 int seq = r.intent.getIntExtra("seq", -1); 595 Slog.i(TAG, "Finishing broadcast [" 596 + mQueueName + "] " + r.intent.getAction() 597 + " seq=" + seq + " app=" + r.callerApp); 598 } 599 performReceiveLocked(r.callerApp, r.resultTo, 600 new Intent(r.intent), r.resultCode, 601 r.resultData, r.resultExtras, false, false, r.userId); 602 // Set this to null so that the reference 603 // (local and remote) isnt kept in the mBroadcastHistory. 604 r.resultTo = null; 605 } catch (RemoteException e) { 606 Slog.w(TAG, "Failure [" 607 + mQueueName + "] sending broadcast result of " 608 + r.intent, e); 609 } 610 } 611 612 if (DEBUG_BROADCAST) Slog.v(TAG, "Cancelling BROADCAST_TIMEOUT_MSG"); 613 cancelBroadcastTimeoutLocked(); 614 615 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Finished with ordered broadcast " 616 + r); 617 618 // ... and on to the next... 619 addBroadcastToHistoryLocked(r); 620 mOrderedBroadcasts.remove(0); 621 r = null; 622 looped = true; 623 continue; 624 } 625 } while (r == null); 626 627 // Get the next receiver... 628 int recIdx = r.nextReceiver++; 629 630 // Keep track of when this receiver started, and make sure there 631 // is a timeout message pending to kill it if need be. 632 r.receiverTime = SystemClock.uptimeMillis(); 633 if (recIdx == 0) { 634 r.dispatchTime = r.receiverTime; 635 r.dispatchClockTime = System.currentTimeMillis(); 636 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing ordered broadcast [" 637 + mQueueName + "] " + r); 638 } 639 if (! mPendingBroadcastTimeoutMessage) { 640 long timeoutTime = r.receiverTime + mTimeoutPeriod; 641 if (DEBUG_BROADCAST) Slog.v(TAG, 642 "Submitting BROADCAST_TIMEOUT_MSG [" 643 + mQueueName + "] for " + r + " at " + timeoutTime); 644 setBroadcastTimeoutLocked(timeoutTime); 645 } 646 647 Object nextReceiver = r.receivers.get(recIdx); 648 if (nextReceiver instanceof BroadcastFilter) { 649 // Simple case: this is a registered receiver who gets 650 // a direct call. 651 BroadcastFilter filter = (BroadcastFilter)nextReceiver; 652 if (DEBUG_BROADCAST) Slog.v(TAG, 653 "Delivering ordered [" 654 + mQueueName + "] to registered " 655 + filter + ": " + r); 656 deliverToRegisteredReceiverLocked(r, filter, r.ordered); 657 if (r.receiver == null || !r.ordered) { 658 // The receiver has already finished, so schedule to 659 // process the next one. 660 if (DEBUG_BROADCAST) Slog.v(TAG, "Quick finishing [" 661 + mQueueName + "]: ordered=" 662 + r.ordered + " receiver=" + r.receiver); 663 r.state = BroadcastRecord.IDLE; 664 scheduleBroadcastsLocked(); 665 } 666 return; 667 } 668 669 // Hard case: need to instantiate the receiver, possibly 670 // starting its application process to host it. 671 672 ResolveInfo info = 673 (ResolveInfo)nextReceiver; 674 ComponentName component = new ComponentName( 675 info.activityInfo.applicationInfo.packageName, 676 info.activityInfo.name); 677 678 boolean skip = false; 679 int perm = mService.checkComponentPermission(info.activityInfo.permission, 680 r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid, 681 info.activityInfo.exported); 682 if (perm != PackageManager.PERMISSION_GRANTED) { 683 if (!info.activityInfo.exported) { 684 Slog.w(TAG, "Permission Denial: broadcasting " 685 + r.intent.toString() 686 + " from " + r.callerPackage + " (pid=" + r.callingPid 687 + ", uid=" + r.callingUid + ")" 688 + " is not exported from uid " + info.activityInfo.applicationInfo.uid 689 + " due to receiver " + component.flattenToShortString()); 690 } else { 691 Slog.w(TAG, "Permission Denial: broadcasting " 692 + r.intent.toString() 693 + " from " + r.callerPackage + " (pid=" + r.callingPid 694 + ", uid=" + r.callingUid + ")" 695 + " requires " + info.activityInfo.permission 696 + " due to receiver " + component.flattenToShortString()); 697 } 698 skip = true; 699 } 700 if (info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID && 701 r.requiredPermission != null) { 702 try { 703 perm = AppGlobals.getPackageManager(). 704 checkPermission(r.requiredPermission, 705 info.activityInfo.applicationInfo.packageName); 706 } catch (RemoteException e) { 707 perm = PackageManager.PERMISSION_DENIED; 708 } 709 if (perm != PackageManager.PERMISSION_GRANTED) { 710 Slog.w(TAG, "Permission Denial: receiving " 711 + r.intent + " to " 712 + component.flattenToShortString() 713 + " requires " + r.requiredPermission 714 + " due to sender " + r.callerPackage 715 + " (uid " + r.callingUid + ")"); 716 skip = true; 717 } 718 } 719 if (r.appOp != AppOpsManager.OP_NONE) { 720 int mode = mService.mAppOpsService.checkOperation(r.appOp, 721 info.activityInfo.applicationInfo.uid, info.activityInfo.packageName); 722 if (mode != AppOpsManager.MODE_ALLOWED) { 723 if (DEBUG_BROADCAST) Slog.v(TAG, 724 "App op " + r.appOp + " not allowed for broadcast to uid " 725 + info.activityInfo.applicationInfo.uid + " pkg " 726 + info.activityInfo.packageName); 727 skip = true; 728 } 729 } 730 boolean isSingleton = false; 731 try { 732 isSingleton = mService.isSingleton(info.activityInfo.processName, 733 info.activityInfo.applicationInfo, 734 info.activityInfo.name, info.activityInfo.flags); 735 } catch (SecurityException e) { 736 Slog.w(TAG, e.getMessage()); 737 skip = true; 738 } 739 if ((info.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) { 740 if (ActivityManager.checkUidPermission( 741 android.Manifest.permission.INTERACT_ACROSS_USERS, 742 info.activityInfo.applicationInfo.uid) 743 != PackageManager.PERMISSION_GRANTED) { 744 Slog.w(TAG, "Permission Denial: Receiver " + component.flattenToShortString() 745 + " requests FLAG_SINGLE_USER, but app does not hold " 746 + android.Manifest.permission.INTERACT_ACROSS_USERS); 747 skip = true; 748 } 749 } 750 if (r.curApp != null && r.curApp.crashing) { 751 // If the target process is crashing, just skip it. 752 if (DEBUG_BROADCAST) Slog.v(TAG, 753 "Skipping deliver ordered [" 754 + mQueueName + "] " + r + " to " + r.curApp 755 + ": process crashing"); 756 skip = true; 757 } 758 759 if (skip) { 760 if (DEBUG_BROADCAST) Slog.v(TAG, 761 "Skipping delivery of ordered [" 762 + mQueueName + "] " + r + " for whatever reason"); 763 r.receiver = null; 764 r.curFilter = null; 765 r.state = BroadcastRecord.IDLE; 766 scheduleBroadcastsLocked(); 767 return; 768 } 769 770 r.state = BroadcastRecord.APP_RECEIVE; 771 String targetProcess = info.activityInfo.processName; 772 r.curComponent = component; 773 if (r.callingUid != Process.SYSTEM_UID && isSingleton) { 774 info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0); 775 } 776 r.curReceiver = info.activityInfo; 777 if (DEBUG_MU && r.callingUid > UserHandle.PER_USER_RANGE) { 778 Slog.v(TAG_MU, "Updated broadcast record activity info for secondary user, " 779 + info.activityInfo + ", callingUid = " + r.callingUid + ", uid = " 780 + info.activityInfo.applicationInfo.uid); 781 } 782 783 // Broadcast is being executed, its package can't be stopped. 784 try { 785 AppGlobals.getPackageManager().setPackageStoppedState( 786 r.curComponent.getPackageName(), false, UserHandle.getUserId(r.callingUid)); 787 } catch (RemoteException e) { 788 } catch (IllegalArgumentException e) { 789 Slog.w(TAG, "Failed trying to unstop package " 790 + r.curComponent.getPackageName() + ": " + e); 791 } 792 793 // Is this receiver's application already running? 794 ProcessRecord app = mService.getProcessRecordLocked(targetProcess, 795 info.activityInfo.applicationInfo.uid); 796 if (app != null && app.thread != null) { 797 try { 798 app.addPackage(info.activityInfo.packageName); 799 processCurBroadcastLocked(r, app); 800 return; 801 } catch (RemoteException e) { 802 Slog.w(TAG, "Exception when sending broadcast to " 803 + r.curComponent, e); 804 } catch (RuntimeException e) { 805 Log.wtf(TAG, "Failed sending broadcast to " 806 + r.curComponent + " with " + r.intent, e); 807 // If some unexpected exception happened, just skip 808 // this broadcast. At this point we are not in the call 809 // from a client, so throwing an exception out from here 810 // will crash the entire system instead of just whoever 811 // sent the broadcast. 812 logBroadcastReceiverDiscardLocked(r); 813 finishReceiverLocked(r, r.resultCode, r.resultData, 814 r.resultExtras, r.resultAbort, true); 815 scheduleBroadcastsLocked(); 816 // We need to reset the state if we failed to start the receiver. 817 r.state = BroadcastRecord.IDLE; 818 return; 819 } 820 821 // If a dead object exception was thrown -- fall through to 822 // restart the application. 823 } 824 825 // Not running -- get it started, to be executed when the app comes up. 826 if (DEBUG_BROADCAST) Slog.v(TAG, 827 "Need to start app [" 828 + mQueueName + "] " + targetProcess + " for broadcast " + r); 829 if ((r.curApp=mService.startProcessLocked(targetProcess, 830 info.activityInfo.applicationInfo, true, 831 r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND, 832 "broadcast", r.curComponent, 833 (r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0, false)) 834 == null) { 835 // Ah, this recipient is unavailable. Finish it if necessary, 836 // and mark the broadcast record as ready for the next. 837 Slog.w(TAG, "Unable to launch app " 838 + info.activityInfo.applicationInfo.packageName + "/" 839 + info.activityInfo.applicationInfo.uid + " for broadcast " 840 + r.intent + ": process is bad"); 841 logBroadcastReceiverDiscardLocked(r); 842 finishReceiverLocked(r, r.resultCode, r.resultData, 843 r.resultExtras, r.resultAbort, true); 844 scheduleBroadcastsLocked(); 845 r.state = BroadcastRecord.IDLE; 846 return; 847 } 848 849 mPendingBroadcast = r; 850 mPendingBroadcastRecvIndex = recIdx; 851 } 852 } 853 setBroadcastTimeoutLocked(long timeoutTime)854 final void setBroadcastTimeoutLocked(long timeoutTime) { 855 if (! mPendingBroadcastTimeoutMessage) { 856 Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG, this); 857 mHandler.sendMessageAtTime(msg, timeoutTime); 858 mPendingBroadcastTimeoutMessage = true; 859 } 860 } 861 cancelBroadcastTimeoutLocked()862 final void cancelBroadcastTimeoutLocked() { 863 if (mPendingBroadcastTimeoutMessage) { 864 mHandler.removeMessages(BROADCAST_TIMEOUT_MSG, this); 865 mPendingBroadcastTimeoutMessage = false; 866 } 867 } 868 broadcastTimeoutLocked(boolean fromMsg)869 final void broadcastTimeoutLocked(boolean fromMsg) { 870 if (fromMsg) { 871 mPendingBroadcastTimeoutMessage = false; 872 } 873 874 if (mOrderedBroadcasts.size() == 0) { 875 return; 876 } 877 878 long now = SystemClock.uptimeMillis(); 879 BroadcastRecord r = mOrderedBroadcasts.get(0); 880 if (fromMsg) { 881 if (mService.mDidDexOpt) { 882 // Delay timeouts until dexopt finishes. 883 mService.mDidDexOpt = false; 884 long timeoutTime = SystemClock.uptimeMillis() + mTimeoutPeriod; 885 setBroadcastTimeoutLocked(timeoutTime); 886 return; 887 } 888 if (!mService.mProcessesReady) { 889 // Only process broadcast timeouts if the system is ready. That way 890 // PRE_BOOT_COMPLETED broadcasts can't timeout as they are intended 891 // to do heavy lifting for system up. 892 return; 893 } 894 895 long timeoutTime = r.receiverTime + mTimeoutPeriod; 896 if (timeoutTime > now) { 897 // We can observe premature timeouts because we do not cancel and reset the 898 // broadcast timeout message after each receiver finishes. Instead, we set up 899 // an initial timeout then kick it down the road a little further as needed 900 // when it expires. 901 if (DEBUG_BROADCAST) Slog.v(TAG, 902 "Premature timeout [" 903 + mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for " 904 + timeoutTime); 905 setBroadcastTimeoutLocked(timeoutTime); 906 return; 907 } 908 } 909 910 Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver 911 + ", started " + (now - r.receiverTime) + "ms ago"); 912 r.receiverTime = now; 913 r.anrCount++; 914 915 // Current receiver has passed its expiration date. 916 if (r.nextReceiver <= 0) { 917 Slog.w(TAG, "Timeout on receiver with nextReceiver <= 0"); 918 return; 919 } 920 921 ProcessRecord app = null; 922 String anrMessage = null; 923 924 Object curReceiver = r.receivers.get(r.nextReceiver-1); 925 Slog.w(TAG, "Receiver during timeout: " + curReceiver); 926 logBroadcastReceiverDiscardLocked(r); 927 if (curReceiver instanceof BroadcastFilter) { 928 BroadcastFilter bf = (BroadcastFilter)curReceiver; 929 if (bf.receiverList.pid != 0 930 && bf.receiverList.pid != ActivityManagerService.MY_PID) { 931 synchronized (mService.mPidsSelfLocked) { 932 app = mService.mPidsSelfLocked.get( 933 bf.receiverList.pid); 934 } 935 } 936 } else { 937 app = r.curApp; 938 } 939 940 if (app != null) { 941 anrMessage = "Broadcast of " + r.intent.toString(); 942 } 943 944 if (mPendingBroadcast == r) { 945 mPendingBroadcast = null; 946 } 947 948 // Move on to the next receiver. 949 finishReceiverLocked(r, r.resultCode, r.resultData, 950 r.resultExtras, r.resultAbort, true); 951 scheduleBroadcastsLocked(); 952 953 if (anrMessage != null) { 954 // Post the ANR to the handler since we do not want to process ANRs while 955 // potentially holding our lock. 956 mHandler.post(new AppNotResponding(app, anrMessage)); 957 } 958 } 959 addBroadcastToHistoryLocked(BroadcastRecord r)960 private final void addBroadcastToHistoryLocked(BroadcastRecord r) { 961 if (r.callingUid < 0) { 962 // This was from a registerReceiver() call; ignore it. 963 return; 964 } 965 System.arraycopy(mBroadcastHistory, 0, mBroadcastHistory, 1, 966 MAX_BROADCAST_HISTORY-1); 967 r.finishTime = SystemClock.uptimeMillis(); 968 mBroadcastHistory[0] = r; 969 System.arraycopy(mBroadcastSummaryHistory, 0, mBroadcastSummaryHistory, 1, 970 MAX_BROADCAST_SUMMARY_HISTORY-1); 971 mBroadcastSummaryHistory[0] = r.intent; 972 } 973 logBroadcastReceiverDiscardLocked(BroadcastRecord r)974 final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) { 975 if (r.nextReceiver > 0) { 976 Object curReceiver = r.receivers.get(r.nextReceiver-1); 977 if (curReceiver instanceof BroadcastFilter) { 978 BroadcastFilter bf = (BroadcastFilter) curReceiver; 979 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER, 980 bf.owningUserId, System.identityHashCode(r), 981 r.intent.getAction(), 982 r.nextReceiver - 1, 983 System.identityHashCode(bf)); 984 } else { 985 ResolveInfo ri = (ResolveInfo)curReceiver; 986 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP, 987 UserHandle.getUserId(ri.activityInfo.applicationInfo.uid), 988 System.identityHashCode(r), r.intent.getAction(), 989 r.nextReceiver - 1, ri.toString()); 990 } 991 } else { 992 Slog.w(TAG, "Discarding broadcast before first receiver is invoked: " 993 + r); 994 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP, 995 -1, System.identityHashCode(r), 996 r.intent.getAction(), 997 r.nextReceiver, 998 "NONE"); 999 } 1000 } 1001 dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, int opti, boolean dumpAll, String dumpPackage, boolean needSep)1002 final boolean dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, 1003 int opti, boolean dumpAll, String dumpPackage, boolean needSep) { 1004 if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0 1005 || mPendingBroadcast != null) { 1006 boolean printed = false; 1007 for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { 1008 BroadcastRecord br = mParallelBroadcasts.get(i); 1009 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) { 1010 continue; 1011 } 1012 if (!printed) { 1013 if (needSep) { 1014 pw.println(); 1015 } 1016 needSep = true; 1017 printed = true; 1018 pw.println(" Active broadcasts [" + mQueueName + "]:"); 1019 } 1020 pw.println(" Active Broadcast " + mQueueName + " #" + i + ":"); 1021 br.dump(pw, " "); 1022 } 1023 printed = false; 1024 needSep = true; 1025 for (int i=mOrderedBroadcasts.size()-1; i>=0; i--) { 1026 BroadcastRecord br = mOrderedBroadcasts.get(i); 1027 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) { 1028 continue; 1029 } 1030 if (!printed) { 1031 if (needSep) { 1032 pw.println(); 1033 } 1034 needSep = true; 1035 printed = true; 1036 pw.println(" Active ordered broadcasts [" + mQueueName + "]:"); 1037 } 1038 pw.println(" Active Ordered Broadcast " + mQueueName + " #" + i + ":"); 1039 mOrderedBroadcasts.get(i).dump(pw, " "); 1040 } 1041 if (dumpPackage == null || (mPendingBroadcast != null 1042 && dumpPackage.equals(mPendingBroadcast.callerPackage))) { 1043 if (needSep) { 1044 pw.println(); 1045 } 1046 pw.println(" Pending broadcast [" + mQueueName + "]:"); 1047 if (mPendingBroadcast != null) { 1048 mPendingBroadcast.dump(pw, " "); 1049 } else { 1050 pw.println(" (null)"); 1051 } 1052 needSep = true; 1053 } 1054 } 1055 1056 int i; 1057 boolean printed = false; 1058 for (i=0; i<MAX_BROADCAST_HISTORY; i++) { 1059 BroadcastRecord r = mBroadcastHistory[i]; 1060 if (r == null) { 1061 break; 1062 } 1063 if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) { 1064 continue; 1065 } 1066 if (!printed) { 1067 if (needSep) { 1068 pw.println(); 1069 } 1070 needSep = true; 1071 pw.println(" Historical broadcasts [" + mQueueName + "]:"); 1072 printed = true; 1073 } 1074 if (dumpAll) { 1075 pw.print(" Historical Broadcast " + mQueueName + " #"); 1076 pw.print(i); pw.println(":"); 1077 r.dump(pw, " "); 1078 } else { 1079 pw.print(" #"); pw.print(i); pw.print(": "); pw.println(r); 1080 pw.print(" "); 1081 pw.println(r.intent.toShortString(false, true, true, false)); 1082 if (r.targetComp != null && r.targetComp != r.intent.getComponent()) { 1083 pw.print(" targetComp: "); pw.println(r.targetComp.toShortString()); 1084 } 1085 Bundle bundle = r.intent.getExtras(); 1086 if (bundle != null) { 1087 pw.print(" extras: "); pw.println(bundle.toString()); 1088 } 1089 } 1090 } 1091 1092 if (dumpPackage == null) { 1093 if (dumpAll) { 1094 i = 0; 1095 printed = false; 1096 } 1097 for (; i<MAX_BROADCAST_SUMMARY_HISTORY; i++) { 1098 Intent intent = mBroadcastSummaryHistory[i]; 1099 if (intent == null) { 1100 break; 1101 } 1102 if (!printed) { 1103 if (needSep) { 1104 pw.println(); 1105 } 1106 needSep = true; 1107 pw.println(" Historical broadcasts summary [" + mQueueName + "]:"); 1108 printed = true; 1109 } 1110 if (!dumpAll && i >= 50) { 1111 pw.println(" ..."); 1112 break; 1113 } 1114 pw.print(" #"); pw.print(i); pw.print(": "); 1115 pw.println(intent.toShortString(false, true, true, false)); 1116 Bundle bundle = intent.getExtras(); 1117 if (bundle != null) { 1118 pw.print(" extras: "); pw.println(bundle.toString()); 1119 } 1120 } 1121 } 1122 1123 return needSep; 1124 } 1125 } 1126