Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge: Introduce UpdateLocks

Browse Source 
An "UpdateLock" works similarly to a wake lock in API: the caller is
providing a hint to the OS that now is not a good time to interrupt
the user/device in order to do intrusive work like applying OTAs.
This is particularly important for headless or kiosk-like products
where ordinarily the update process will be automatically scheduled
and proceed without user or administrator intervention.

UpdateLocks require that the caller hold the new signatureOrSystem
permission android.permission.UPDATE_LOCK.  acquire() and release()
will throw security exceptions if this is not the case.

The "is now convenient?" state is expressed to interested parties
by way of a sticky broadcast sent only to registered listeners.  The
broadcast is protected; only the system can send it, so listeners
can trust it to be accurate.  The broadcast intent also includes a
timestamp (System.currentTimeMillis()) to help inform listeners that
wish to implement scheduling policies based on when the device became
idle.

The API change here is a tiny one: a dump(PrintWriter) method has been
added to the TokenWatcher class to facilitate getting information out
of it for dumpsys purposes.  UpdateLock itself is still @hide.

Bug 5543442

Change-Id: I3709c831fc1883d7cb753cd2d3ee8e10a61e7e48
This commit is contained in:
Christopher Tate
2012-02-23 14:59:36 -08:00
parent c021a119a2
commit 8662cab5c6
10 changed files with 371 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Android.mk
View File

@@ -127,6 +127,7 @@ LOCAL_SRC_FILES += \
core/java/android/os/IPermissionController.aidl \
core/java/android/os/IPowerManager.aidl \
core/java/android/os/IRemoteCallback.aidl \
core/java/android/os/IUpdateLock.aidl \
core/java/android/os/IVibratorService.aidl \
core/java/android/service/wallpaper/IWallpaperConnection.aidl \
core/java/android/service/wallpaper/IWallpaperEngine.aidl \

1
api/current.txt
View File

@@ -15343,6 +15343,7 @@ package android.os {
method public abstract void acquired();
method public void cleanup(android.os.IBinder, boolean);
method public void dump();
method public void dump(java.io.PrintWriter);
method public boolean isAcquired();
method public void release(android.os.IBinder);
method public abstract void released();

11
core/java/android/content/Context.java
View File

@@ -1644,6 +1644,17 @@ public abstract class Context {
*/
public static final String THROTTLE_SERVICE = "throttle";
/**
* Use with {@link #getSystemService} to retrieve a {@link
* android.os.IUpdateLock} for managing runtime sequences that
* must not be interrupted by headless OTA application or similar.
*
* @hide
* @see #getSystemService
* @see android.os.UpdateLock
*/
public static final String UPDATE_LOCK_SERVICE = "updatelock";
/**
* Use with {@link #getSystemService} to retrieve a {@link
* android.net.NetworkManagementService} for handling management of

27
core/java/android/os/IUpdateLock.aidl Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os;
/**
* Direct interface to the UpdateLockService's functionality
*
* {@hide}
*/
interface IUpdateLock {
void acquireUpdateLock(IBinder token, String tag);
void releaseUpdateLock(IBinder token);
}

22
core/java/android/os/TokenWatcher.java
View File

@@ -16,6 +16,8 @@
package android.os;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.WeakHashMap;
import java.util.Set;
import android.util.Log;
@@ -115,15 +117,31 @@ public abstract class TokenWatcher
public void dump()
{
ArrayList<String> a = dumpInternal();
for (String s : a) {
Log.i(mTag, s);
}
}
public void dump(PrintWriter pw) {
ArrayList<String> a = dumpInternal();
for (String s : a) {
pw.println(s);
}
}
private ArrayList<String> dumpInternal() {
ArrayList<String> a = new ArrayList<String>();
synchronized (mTokens) {
Set<IBinder> keys = mTokens.keySet();
Log.i(mTag, "Token count: " + mTokens.size());
a.add("Token count: " + mTokens.size());
int i = 0;
for (IBinder b: keys) {
Log.i(mTag, "[" + i + "] " + mTokens.get(b).tag + " - " + b);
a.add("[" + i + "] " + mTokens.get(b).tag + " - " + b);
i++;
}
}
return a;
}
private Runnable mNotificationTask = new Runnable() {

166
core/java/android/os/UpdateLock.java Normal file
View File

@@ -0,0 +1,166 @@
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os;
import android.content.Context;
import android.util.Log;
/**
* Advisory wakelock-like mechanism by which processes that should not be interrupted for
* OTA/update purposes can so advise the OS. This is particularly relevant for headless
* or kiosk-like operation.
*
* @hide
*/
public class UpdateLock {
private static final boolean DEBUG = false;
private static final String TAG = "UpdateLock";
private static IUpdateLock sService;
private static void checkService() {
if (sService == null) {
sService = IUpdateLock.Stub.asInterface(
ServiceManager.getService(Context.UPDATE_LOCK_SERVICE));
}
}
IBinder mToken;
int mCount = 0;
boolean mRefCounted = true;
boolean mHeld = false;
final String mTag;
/**
* Broadcast Intent action sent when the global update lock state changes,
* i.e. when the first locker acquires an update lock, or when the last
* locker releases theirs. The broadcast is sticky but is sent only to
* registered receivers.
*/
public static final String UPDATE_LOCK_CHANGED = "android.os.UpdateLock.UPDATE_LOCK_CHANGED";
/**
* Boolean Intent extra on the UPDATE_LOCK_CHANGED sticky broadcast, indicating
* whether now is an appropriate time to interrupt device activity with an
* update operation. True means that updates are okay right now; false indicates
* that perhaps later would be a better time.
*/
public static final String NOW_IS_CONVENIENT = "nowisconvenient";
/**
* Long Intent extra on the UPDATE_LOCK_CHANGED sticky broadcast, marking the
* wall-clock time [in UTC] at which the broadcast was sent. Note that this is
* in the System.currentTimeMillis() time base, which may be non-monotonic especially
* around reboots.
*/
public static final String TIMESTAMP = "timestamp";
/**
* Construct an UpdateLock instance.
* @param tag An arbitrary string used to identify this lock instance in dump output.
*/
public UpdateLock(String tag) {
mTag = tag;
mToken = new Binder();
}
/**
* Change the refcount behavior of this update lock.
*/
public void setReferenceCounted(boolean isRefCounted) {
if (DEBUG) {
Log.v(TAG, "setting refcounted=" + isRefCounted + " : " + this);
}
mRefCounted = isRefCounted;
}
/**
* Is this lock currently held?
*/
public boolean isHeld() {
synchronized (mToken) {
return mHeld;
}
}
/**
* Acquire an update lock.
*/
public void acquire() {
if (DEBUG) {
Log.v(TAG, "acquire() : " + this, new RuntimeException("here"));
}
checkService();
synchronized (mToken) {
acquireLocked();
}
}
private void acquireLocked() {
if (!mRefCounted || mCount++ == 0) {
if (sService != null) {
try {
sService.acquireUpdateLock(mToken, mTag);
} catch (RemoteException e) {
Log.e(TAG, "Unable to contact service to acquire");
}
}
mHeld = true;
}
}
/**
* Release this update lock.
*/
public void release() {
if (DEBUG) Log.v(TAG, "release() : " + this, new RuntimeException("here"));
checkService();
synchronized (mToken) {
releaseLocked();
}
}
private void releaseLocked() {
if (!mRefCounted || --mCount == 0) {
if (sService != null) {
try {
sService.releaseUpdateLock(mToken);
} catch (RemoteException e) {
Log.e(TAG, "Unable to contact service to release");
}
}
mHeld = false;
}
if (mCount < 0) {
throw new RuntimeException("UpdateLock under-locked");
}
}
@Override
protected void finalize() throws Throwable {
synchronized (mToken) {
// if mHeld is true, sService must be non-null
if (mHeld) {
Log.wtf(TAG, "UpdateLock finalized while still held");
try {
sService.releaseUpdateLock(mToken);
} catch (RemoteException e) {
Log.e(TAG, "Unable to contact service to release");
}
}
}
}
}

8
core/res/AndroidManifest.xml
View File

@@ -121,6 +121,7 @@
<protected-broadcast android:name="android.intent.action.CLEAR_DNS_CACHE" />
<protected-broadcast android:name="android.intent.action.PROXY_CHANGE" />
<protected-broadcast android:name="android.os.UpdateLock.UPDATE_LOCK_CHANGED" />
<!-- ====================================== -->
<!-- Permissions for things that cost money -->
@@ -1538,6 +1539,13 @@
android:label="@string/permlab_accessContentProvidersExternally"
android:description="@string/permdesc_accessContentProvidersExternally"
android:protectionLevel="signature" />
<!-- Allows an application to hold an UpdateLock, recommending that a headless
OTA reboot *not* occur while the lock is held.
@hide -->
<permission android:name="android.permission.UPDATE_LOCK"
android:label="@string/permlab_updateLock"
android:description="@string/permdesc_updateLock"
android:protectionLevel="signatureOrSystem" />
<!-- The system process is explicitly the only one allowed to launch the
confirmation UI for full backup/restore -->

4
core/res/res/values/strings.xml
View File

@@ -2263,6 +2263,10 @@
content providers from outside an ApplicationThread. [CHAR LIMIT=NONE] -->
<string name="permdesc_accessContentProvidersExternally">Allows the holder to access content
providers from the shell. Should never be needed for normal apps.</string>
<!-- Title of an application permission which allows the application to suggest that now is a bad time to reboot the device in order to apply an OTA. [CHAR LIMIT=40] -->
<string name="permlab_updateLock">discourage automatic device updates</string>
<!-- Description of an application permission which allows the application to suggest that now is a bad time to reboot the device in order to apply an OTA. [CHAR LIMIT=NONE] -->
<string name="permdesc_updateLock">Allows the holder to offer information to the system about when would be a good time for a noninteractive reboot to upgrade the device.</string>
<!-- If the user enters a password in a form on a website, a dialog will come up asking if they want to save the password. Text in the save password dialog, asking if the browser should remember a password. -->
<string name="save_password_message">Do you want the browser to remember this password?</string>

8
services/java/com/android/server/SystemServer.java
View File

@@ -402,6 +402,14 @@ class ServerThread extends Thread {
reportWtf("starting ThrottleService", e);
}
try {
Slog.i(TAG, "UpdateLock Service");
ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
new UpdateLockService(context));
} catch (Throwable e) {
reportWtf("starting UpdateLockService", e);
}
if (!"0".equals(SystemProperties.get("system_init.startmountservice"))) {
try {
/*

125
services/java/com/android/server/UpdateLockService.java Normal file
View File

@@ -0,0 +1,125 @@
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.IUpdateLock;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.TokenWatcher;
import android.os.UpdateLock;
import android.util.Slog;
import java.io.FileDescriptor;
import java.io.PrintWriter;
public class UpdateLockService extends IUpdateLock.Stub {
static final boolean DEBUG = false;
static final String TAG = "UpdateLockService";
// signatureOrSystem required to use update locks
static final String PERMISSION = "android.permission.UPDATE_LOCK";
Context mContext;
LockWatcher mLocks;
class LockWatcher extends TokenWatcher {
LockWatcher(Handler h, String tag) {
super(h, tag);
}
public void acquired() {
if (DEBUG) {
Slog.d(TAG, "first acquire; broadcasting convenient=false");
}
sendLockChangedBroadcast(false);
}
public void released() {
if (DEBUG) {
Slog.d(TAG, "last release; broadcasting convenient=true");
}
sendLockChangedBroadcast(true);
}
}
UpdateLockService(Context context) {
mContext = context;
mLocks = new LockWatcher(new Handler(), "UpdateLocks");
// Consider just-booting to be a reasonable time to allow
// interruptions for update installation etc.
sendLockChangedBroadcast(true);
}
void sendLockChangedBroadcast(boolean state) {
// Safe early during boot because this broadcast only goes to registered receivers.
long oldIdent = Binder.clearCallingIdentity();
try {
Intent intent = new Intent(UpdateLock.UPDATE_LOCK_CHANGED)
.putExtra(UpdateLock.NOW_IS_CONVENIENT, state)
.putExtra(UpdateLock.TIMESTAMP, System.currentTimeMillis())
.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
mContext.sendStickyBroadcast(intent);
} finally {
Binder.restoreCallingIdentity(oldIdent);
}
}
@Override
public void acquireUpdateLock(IBinder token, String tag) throws RemoteException {
if (DEBUG) {
Slog.d(TAG, "acquire(" + token + ") by " + makeTag(tag));
}
mContext.enforceCallingOrSelfPermission(PERMISSION, "acquireUpdateLock");
mLocks.acquire(token, makeTag(tag));
}
@Override
public void releaseUpdateLock(IBinder token) throws RemoteException {
if (DEBUG) {
Slog.d(TAG, "release(" + token + ')');
}
mContext.enforceCallingOrSelfPermission(PERMISSION, "releaseUpdateLock");
mLocks.release(token);
};
private String makeTag(String tag) {
return "{tag=" + tag
+ " uid=" + Binder.getCallingUid()
+ " pid=" + Binder.getCallingPid() + '}';
}
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
!= PackageManager.PERMISSION_GRANTED) {
pw.println("Permission Denial: can't dump update lock service from from pid="
+ Binder.getCallingPid()
+ ", uid=" + Binder.getCallingUid());
return;
}
mLocks.dump(pw);
}
}