Lines Matching defs:pid
547 * All of the processes we currently have running organized by pid.
548 * The keys are the pid running the application.
557 * is the pid of the caller who requested it (we hold a death
561 int pid;
885 public final int pid;
890 pid = _pid;
1141 int pid;
1213 AppDeathRecipient(ProcessRecord app, int pid,
1219 mPid = pid;
1323 && proc.pid != MY_PID);
1664 final int pid = msg.arg1;
1666 dispatchProcessDied(pid, uid);
1842 if (mPidsSelfLocked.indexOfKey(st.pid) >= 0) {
1847 nativeTotalPss += Debug.getPss(st.pid, null, null);
1865 int pid;
1880 pid = proc.pid;
1883 pid = 0;
1887 long pss = Debug.getPss(pid, tmp, null);
1890 && proc.pid == pid && proc.lastPssTime == lastPssTime) {
1922 app.pid = MY_PID;
1927 mPidsSelfLocked.put(app.pid, app);
1966 pw.println("Permission Denial: can't dump meminfo from from pid="
1986 pw.println("Permission Denial: can't dump gfxinfo from from pid="
2006 pw.println("Permission Denial: can't dump dbinfo from from pid="
2026 pw.println("Permission Denial: can't dump cpuinfo from from pid="
2283 ProcessRecord pr = mPidsSelfLocked.get(st.pid);
2481 Process.killProcessQuiet(app.pid);
2482 Process.killProcessGroup(app.info.uid, app.pid);
2760 return proc != null ? proc.pid : 0;
2791 // (3) There is a pid assigned to it, so it is either starting or
2796 + " pid=" + (app != null ? app.pid : -1));
2797 if (app != null && app.pid > 0) {
2800 // come up (we have a pid but not yet its thread), so keep it.
2812 Process.killProcessGroup(app.info.uid, app.pid);
2886 return (app.pid != 0) ? app : null;
2902 if (app.pid > 0 && app.pid != MY_PID) {
2905 mPidsSelfLocked.remove(app.pid);
3026 UserHandle.getUserId(uid), startResult.pid, uid,
3031 Watchdog.getInstance().processStarted(app.processName, startResult.pid);
3038 buf.append(startResult.pid);
3055 app.setPid(startResult.pid);
3062 this.mPidsSelfLocked.put(startResult.pid, app);
3313 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG, "ACTIVITIES CHANGED pid="
3314 + item.pid + " uid=" + item.uid + ": "
3316 observer.onForegroundActivitiesChanged(item.pid, item.uid,
3320 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG, "PROCSTATE CHANGED pid="
3321 + item.pid + " uid=" + item.uid + ": " + item.processState);
3322 observer.onProcessStateChanged(item.pid, item.uid, item.processState);
3332 private void dispatchProcessDied(int pid, int uid) {
3339 observer.onProcessDied(pid, uid);
3504 String msg = "Permission Denial: startVoiceActivity() from pid="
4345 String msg = "Permission Denial: finishHeavyWeightApp() from pid="
4379 String msg = "Permission Denial: crashApplication() from pid="
4399 if (p.pid == initialPid) {
4417 if (proc.pid == Process.myPid()) {
4551 int pid = app.pid;
4555 if (pid > 0) {
4556 ProcessList.remove(pid);
4647 memInfos.add(new ProcessMemInfo(rec.processName, rec.pid, rec.setAdj,
4674 appDiedLocked(app, app.pid, app.thread);
4677 final void appDiedLocked(ProcessRecord app, int pid, IApplicationThread thread) {
4678 // First check if this ProcessRecord is actually active for the pid.
4680 ProcessRecord curProc = mPidsSelfLocked.get(pid);
4682 Slog.w(TAG, "Spurious death for " + app + ", curProc for " + pid + ": " + curProc);
4689 stats.noteProcessDiedLocked(app.info.uid, pid);
4693 Process.killProcessQuiet(pid);
4694 Process.killProcessGroup(app.info.uid, pid);
4699 if (app.pid == pid && app.thread != null &&
4704 Slog.i(TAG, "Process " + app.processName + " (pid " + pid
4713 EventLog.writeEvent(EventLogTags.AM_PROC_DIED, app.userId, app.pid, app.processName);
4715 TAG, "Dying app: " + app + ", pid: " + pid
4725 } else if (app.pid != pid) {
4727 Slog.i(TAG, "Process " + app.processName + " (pid " + pid
4728 + ") has died and restarted (pid " + app.pid + ").");
4729 EventLog.writeEvent(EventLogTags.AM_PROC_DIED, app.userId, app.pid, app.processName);
4807 for (int pid : pids) {
4808 Debug.dumpNativeBacktraceToFile(pid, tracesPath);
4831 if (lastPids.indexOfKey(stats.pid) >= 0) {
4835 Process.sendSignal(stats.pid, Process.SIGNAL_QUIT);
4900 firstPids.add(app.pid);
4935 int res = mController.appEarlyNotResponding(app.processName, app.pid, annotation);
4936 if (res < 0 && app.pid != MY_PID) {
4968 EventLog.writeEvent(EventLogTags.AM_ANR, app.userId, app.pid,
4972 firstPids.add(app.pid);
4974 int parentPid = app.pid;
4975 if (parent != null && parent.app != null && parent.app.pid > 0) parentPid = parent.app.pid;
4976 if (parentPid != app.pid) firstPids.add(parentPid);
4978 if (MY_PID != app.pid && MY_PID != parentPid) firstPids.add(MY_PID);
4983 int pid = r.pid;
4984 if (pid > 0 && pid != app.pid && pid != parentPid && pid != MY_PID) {
4986 firstPids.add(pid);
4988 lastPids.put(pid, Boolean.TRUE);
5003 info.append("PID: ").append(app.pid).append("\n");
5031 Process.sendSignal(app.pid, Process.SIGNAL_QUIT);
5040 int res = mController.appNotResponding(app.processName, app.pid, info.toString());
5042 if (res < 0 && app.pid != MY_PID) {
5064 if (!showBackground && !app.isInterestingToUserLocked() && app.pid != MY_PID) {
5119 int pid = Binder.getCallingPid();
5120 userId = handleIncomingUser(pid, uid,
5144 pid, uid, -1, true)
5148 throw new SecurityException("PID " + pid + " does not have permission "
5192 String msg = "Permission Denial: killBackgroundProcesses() from pid="
5227 String msg = "Permission Denial: killAllBackgroundProcesses() from pid="
5275 String msg = "Permission Denial: forceStopPackage() from pid="
5309 forceStopPackageLocked(packageName, pkgUid, "from pid " + callingPid);
5374 final int pid = Binder.getCallingPid();
5384 proc = mPidsSelfLocked.get(pid);
5778 if (app.pid > 0 && app.pid != MY_PID) {
5779 int pid = app.pid;
5781 mPidsSelfLocked.remove(pid);
5807 final int pid = app.pid;
5810 ProcessRecord knownApp = mPidsSelfLocked.get(pid);
5812 mPidsSelfLocked.remove(pid);
5820 pid, app.uid, app.processName);
5837 if (mBackupTarget != null && mBackupTarget.app.pid == pid) {
5847 if (isPendingBroadcastProcessLocked(pid)) {
5849 skipPendingBroadcastLocked(pid);
5852 Slog.w(TAG, "Spurious process start timeout - pid not known for " + app);
5857 int pid) {
5860 // the pid if we are running in multiple processes, or just pull the
5863 if (pid != MY_PID && pid >= 0) {
5865 app = mPidsSelfLocked.get(pid);
5872 Slog.w(TAG, "No pending application record for pid " + pid
5874 EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid);
5875 if (pid > 0 && pid != MY_PID) {
5876 Process.killProcessQuiet(pid);
5877 //TODO: Process.killProcessGroup(app.info.uid, pid);
5897 TAG, "Binding process pid " + pid + " to record " + app);
5902 app, pid, thread);
5911 EventLog.writeEvent(EventLogTags.AM_PROC_BOUND, app.userId, app.pid, app.processName);
5934 + " thread=" + thread.asBinder() + " pid=" + pid);
6041 if (!badApp && isPendingBroadcastProcessLocked(pid)) {
6476 String msg = "Permission Denial: getIntentSender() from pid="
6571 String msg = "Permission Denial: cancelIntentSender() from pid="
6724 = mForegroundProcesses.get(token.pid);
6728 mForegroundProcesses.remove(token.pid);
6729 ProcessRecord pr = mPidsSelfLocked.get(token.pid);
6741 public void setProcessForeground(IBinder token, int pid, boolean isForeground) {
6748 ProcessRecord pr = mPidsSelfLocked.get(pid);
6750 Slog.w(TAG, "setProcessForeground called on unknown pid: " + pid);
6753 ForegroundToken oldToken = mForegroundProcesses.get(pid);
6756 mForegroundProcesses.remove(pid);
6769 newToken.pid = pid;
6773 mForegroundProcesses.put(pid, newToken);
6800 public boolean checkPermission(String permission, int pid, int uid) {
6801 return mActivityManagerService.checkPermission(permission, pid,
6808 public int checkComponentPermission(String permission, int pid, int uid,
6810 return ActivityManagerService.this.checkComponentPermission(permission, pid, uid,
6823 int checkComponentPermission(String permission, int pid, int uid,
6825 if (pid == MY_PID) {
6842 public int checkPermission(String permission, int pid, int uid) {
6846 return checkComponentPermission(permission, pid, UserHandle.getAppId(uid), -1, true);
6850 public int checkPermissionWithToken(String permission, int pid, int uid, IBinder callerToken) {
6860 Slog.d(TAG, "checkComponentPermission() adjusting {pid,uid} to {"
6861 + tlsIdentity.pid + "," + tlsIdentity.uid + "}");
6863 pid = tlsIdentity.pid;
6866 return checkComponentPermission(permission, pid, UserHandle.getAppId(uid), -1, true);
6888 String msg = "Permission Denial: " + func + " from pid="
7073 public int checkUriPermission(Uri uri, int pid, int uid,
7082 pid = tlsIdentity.pid;
7086 if (pid == MY_PID) {
8972 final int callingPid = (r != null) ? r.pid : Binder.getCallingPid();
9033 + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid
9038 + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid
9168 + " (pid=" + Binder.getCallingPid()
9245 Process.killProcess(cpr.proc.pid);
9606 + " (pid=" + Binder.getCallingPid()
9742 Slog.i(TAG, "Process " + proc.processName + " (pid " + proc.pid
10366 public long inputDispatchingTimedOut(int pid, final boolean aboveSystem, String reason) {
10376 proc = mPidsSelfLocked.get(pid);
10480 if (activity.app.pid == Binder.getCallingPid()) {
10833 final int pid = mPidsSelfLocked.keyAt(i);
10873 Slog.i(TAG, "Hanging system process at request of pid " + Binder.getCallingPid());
11429 report.pid = app.pid;
11451 if (app.pid > 0 && app.pid != MY_PID) {
11796 if (r != null && r.pid != Process.myPid() &&
11843 + " from pid=" + Binder.getCallingPid()
11893 if (process == null || process.pid == MY_PID) {
11933 if (parent != null && parent.app != null && parent.app.pid != process.pid) {
12031 int pid = r != null ? r.pid : Binder.getCallingPid();
12033 if (!mController.appCrashed(name, pid,
12038 + "(" + pid + ") during testing");
12046 Process.killProcess(pid);
12047 Process.killProcessGroup(uid, pid);
12223 outInfo.pid = app.pid;
12260 app.pid, app.getPackageList());
12263 currApp.importanceReasonPid = ((ProcessRecord)app.adjSource).pid;
12269 if (r.app != null) currApp.importanceReasonPid = r.app.pid;
12329 pw.println("Permission Denial: can't dump ActivityManager from from pid="
12836 mForegroundProcesses.valueAt(i).pid);
13384 pw.print(" pid=");
13385 if (r.app != null) pw.println(r.app.pid);
13773 r.pid, curRealtime);
13811 int pid = -1;
13813 pid = Integer.parseInt(args[start]);
13818 if (proc.pid == pid) {
13853 pw.println("\n** Graphics info for pid " + r.pid + " [" + r.processName + "] **");
13886 pw.println("\n** Database info for pid " + r.pid + " [" + r.processName + "] **");
14106 pw.println("pid of a specific process to dump.");
14135 if (st.pid == findPid || (st.baseName != null
14147 final int pid = r.pid;
14149 pw.println("\n** MEMINFO in pid " + pid + " [" + r.baseName + "] **");
14155 Debug.getMemoryInfo(pid, mi);
14157 mi.dalvikPss = (int)Debug.getPss(pid, tmpLong, null);
14161 dumpDalvik, pid, r.baseName, 0, 0, 0, 0, 0, 0);
14200 final int pid;
14205 pid = r.pid;
14211 pw.println("\n** MEMINFO in pid " + pid + " [" + r.processName + "] **");
14217 Debug.getMemoryInfo(pid, mi);
14219 mi.dalvikPss = (int)Debug.getPss(pid, tmpLong, null);
14225 dumpDalvik, pid, r.processName, 0, 0, 0, 0, 0, 0);
14255 MemItem pssItem = new MemItem(r.processName + " (pid " + pid +
14257 r.processName, myTotalPss, pid, hasActivities);
14259 procMemsMap.put(pid, pssItem);
14300 if (st.vsize > 0 && procMemsMap.indexOfKey(st.pid) < 0) {
14305 Debug.getMemoryInfo(st.pid, mi);
14307 mi.nativePss = (int)Debug.getPss(st.pid, tmpLong, null);
14315 MemItem pssItem = new MemItem(st.name + " (pid " + st.pid + ")",
14316 st.name, myTotalPss, st.pid, false);
14516 sb.append(" (pid ");
14517 sb.append(mi.pid);
14532 infoMap.put(mi.pid, mi);
14541 long pss = Debug.getPss(st.pid, null, memtrackTmp);
14543 if (infoMap.indexOfKey(st.pid) < 0) {
14544 ProcessMemInfo mi = new ProcessMemInfo(st.name, st.pid,
14560 mi.pss = Debug.getPss(mi.pid, null, memtrackTmp);
14822 && capp.pid != 0
14823 && capp.pid != MY_PID) {
14860 ProcessList.remove(app.pid);
14957 if (mBackupTarget != null && app.pid == mBackupTarget.app.pid) {
14971 if (item.pid == app.pid) {
14976 mHandler.obtainMessage(DISPATCH_PROCESS_DIED, app.pid, app.info.uid, null).sendToTarget();
15018 ProcessList.remove(app.pid);
15023 } else if (app.pid > 0 && app.pid != MY_PID) {
15027 mPidsSelfLocked.remove(app.pid);
15543 boolean isPendingBroadcastProcessLocked(int pid) {
15544 return mFgBroadcastQueue.isPendingBroadcastProcessLocked(pid)
15545 || mBgBroadcastQueue.isPendingBroadcastProcessLocked(pid);
15548 void skipPendingBroadcastLocked(int pid) {
15551 queue.skipPendingBroadcastLocked(pid);
15576 + " (pid=" + Binder.getCallingPid()
15586 callingPid = callerApp.pid;
15646 } else if (rl.pid != callingPid) {
15648 "Receiver requested to register for pid " + callingPid
15649 + " was previously registered for pid " + rl.pid);
15875 + intent.getAction() + " from pid="
15928 + " broadcast from " + callerPackage + " (pid=" + callingPid
16055 String msg = "Permission Denial: broadcastIntent() requesting a sticky broadcast from pid="
16360 String msg = "Permission Denial: unbroadcastIntent() from pid="
16480 + className + " from pid="
17550 //Slog.i(TAG, "OOM ADJ " + app + ": pid=" + app.pid +
17812 app.pid, curRealtime);
17878 ProcessList.setOomAdj(app.pid, app.info.uid, app.curAdj);
17880 TAG, "Set " + app.pid + " " + app.processName +
17898 Process.setProcessGroup(app.pid, app.curSchedGroup);
17900 Slog.w(TAG, "Failed setting process group of " + app.pid
17914 Process.setSwappiness(app.pid,
17945 long pss = Debug.getPss(app.pid, mTmpLong, null);
17984 app.pid, SystemClock.elapsedRealtime());
18006 if (item.pid == app.pid) {
18023 item.pid = app.pid;
18547 if (app.pid > 0 && app.pid != MY_PID) {
18586 Process.sendSignal(r.pid, sig);
18693 int pid = Integer.parseInt(process);
18695 proc = mPidsSelfLocked.get(pid);
18871 String msg = "Permission Denial: switchUser() from pid="
19298 String msg = "Permission Denial: switchUser() from pid="
19448 String msg = "Permission Denial: getCurrentUser() from pid="
19469 String msg = "Permission Denial: isUserRunning() from pid="
19497 String msg = "Permission Denial: isUserRunning() from pid="
19535 String msg = "Permission Denial: registerUserSwitchObserver() from pid="