/*
|
* Copyright (C) 2017 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.power.batterysaver;
|
|
import android.content.Context;
|
import android.os.Environment;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.SystemProperties;
|
import android.util.ArrayMap;
|
import android.util.AtomicFile;
|
import android.util.Slog;
|
import android.util.Xml;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.util.FastXmlSerializer;
|
import com.android.internal.util.XmlUtils;
|
import com.android.server.IoThread;
|
|
import libcore.io.IoUtils;
|
|
import org.xmlpull.v1.XmlPullParser;
|
import org.xmlpull.v1.XmlPullParserException;
|
import org.xmlpull.v1.XmlSerializer;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileNotFoundException;
|
import java.io.FileOutputStream;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Map;
|
|
/**
|
* Used by {@link BatterySaverController} to write values to /sys/ (and possibly /proc/ too) files
|
* with retries. It also support restoring to the file original values.
|
*
|
* Retries are needed because writing to "/sys/.../scaling_max_freq" returns EIO when the current
|
* frequency happens to be above the new max frequency.
|
*
|
* Test:
|
atest $ANDROID_BUILD_TOP/frameworks/base/services/tests/servicestests/src/com/android/server/power/batterysaver/FileUpdaterTest.java
|
*/
|
public class FileUpdater {
|
private static final String TAG = BatterySaverController.TAG;
|
|
private static final boolean DEBUG = BatterySaverController.DEBUG;
|
|
/**
|
* If this system property is set to 1, it'll skip all file writes. This can be used when
|
* one needs to change max CPU frequency for benchmarking, for example.
|
*/
|
private static final String PROP_SKIP_WRITE = "debug.batterysaver.no_write_files";
|
|
private static final String TAG_DEFAULT_ROOT = "defaults";
|
|
// Don't do disk access with this lock held.
|
private final Object mLock = new Object();
|
|
private final Context mContext;
|
|
private final Handler mHandler;
|
|
/**
|
* Filename -> value map that holds pending writes.
|
*/
|
@GuardedBy("mLock")
|
private final ArrayMap<String, String> mPendingWrites = new ArrayMap<>();
|
|
/**
|
* Filename -> value that holds the original value of each file.
|
*/
|
@GuardedBy("mLock")
|
private final ArrayMap<String, String> mDefaultValues = new ArrayMap<>();
|
|
/** Number of retries. We give up on writing after {@link #MAX_RETRIES} retries. */
|
@GuardedBy("mLock")
|
private int mRetries = 0;
|
|
private final int MAX_RETRIES;
|
|
private final long RETRY_INTERVAL_MS;
|
|
/**
|
* "Official" constructor. Don't use the other constructor in the production code.
|
*/
|
public FileUpdater(Context context) {
|
this(context, IoThread.get().getLooper(), 10, 5000);
|
}
|
|
/**
|
* Constructor for test.
|
*/
|
@VisibleForTesting
|
FileUpdater(Context context, Looper looper, int maxRetries, int retryIntervalMs) {
|
mContext = context;
|
mHandler = new Handler(looper);
|
|
MAX_RETRIES = maxRetries;
|
RETRY_INTERVAL_MS = retryIntervalMs;
|
}
|
|
public void systemReady(boolean runtimeRestarted) {
|
synchronized (mLock) {
|
if (runtimeRestarted) {
|
// If it runtime restarted, read the original values from the disk and apply.
|
if (loadDefaultValuesLocked()) {
|
Slog.d(TAG, "Default values loaded after runtime restart; writing them...");
|
restoreDefault();
|
}
|
} else {
|
// Delete it, without checking the result. (file-not-exist is not an exception.)
|
injectDefaultValuesFilename().delete();
|
}
|
}
|
}
|
|
/**
|
* Write values to files. (Note the actual writes happen ASAP but asynchronously.)
|
*/
|
public void writeFiles(ArrayMap<String, String> fileValues) {
|
synchronized (mLock) {
|
for (int i = fileValues.size() - 1; i >= 0; i--) {
|
final String file = fileValues.keyAt(i);
|
final String value = fileValues.valueAt(i);
|
|
if (DEBUG) {
|
Slog.d(TAG, "Scheduling write: '" + value + "' to '" + file + "'");
|
}
|
|
mPendingWrites.put(file, value);
|
|
}
|
mRetries = 0;
|
|
mHandler.removeCallbacks(mHandleWriteOnHandlerRunnable);
|
mHandler.post(mHandleWriteOnHandlerRunnable);
|
}
|
}
|
|
/**
|
* Restore the default values.
|
*/
|
public void restoreDefault() {
|
synchronized (mLock) {
|
if (DEBUG) {
|
Slog.d(TAG, "Resetting file default values.");
|
}
|
mPendingWrites.clear();
|
|
writeFiles(mDefaultValues);
|
}
|
}
|
|
private Runnable mHandleWriteOnHandlerRunnable = () -> handleWriteOnHandler();
|
|
/** Convert map keys into a single string for debug messages. */
|
private String getKeysString(Map<String, String> source) {
|
return new ArrayList<>(source.keySet()).toString();
|
}
|
|
/** Clone an ArrayMap. */
|
private ArrayMap<String, String> cloneMap(ArrayMap<String, String> source) {
|
return new ArrayMap<>(source);
|
}
|
|
/**
|
* Called on the handler and writes {@link #mPendingWrites} to the disk.
|
*
|
* When it about to write to each file for the first time, it'll read the file and store
|
* the original value in {@link #mDefaultValues}.
|
*/
|
private void handleWriteOnHandler() {
|
// We don't want to access the disk with the lock held, so copy the pending writes to
|
// a local map.
|
final ArrayMap<String, String> writes;
|
synchronized (mLock) {
|
if (mPendingWrites.size() == 0) {
|
return;
|
}
|
|
if (DEBUG) {
|
Slog.d(TAG, "Writing files: (# retries=" + mRetries + ") " +
|
getKeysString(mPendingWrites));
|
}
|
|
writes = cloneMap(mPendingWrites);
|
}
|
|
// Then write.
|
|
boolean needRetry = false;
|
|
final int size = writes.size();
|
for (int i = 0; i < size; i++) {
|
final String file = writes.keyAt(i);
|
final String value = writes.valueAt(i);
|
|
// Make sure the default value is loaded.
|
if (!ensureDefaultLoaded(file)) {
|
continue;
|
}
|
|
// Write to the file. When succeeded, remove it from the pending list.
|
// Otherwise, schedule a retry.
|
try {
|
injectWriteToFile(file, value);
|
|
removePendingWrite(file);
|
} catch (IOException e) {
|
needRetry = true;
|
}
|
}
|
if (needRetry) {
|
scheduleRetry();
|
}
|
}
|
|
private void removePendingWrite(String file) {
|
synchronized (mLock) {
|
mPendingWrites.remove(file);
|
}
|
}
|
|
private void scheduleRetry() {
|
synchronized (mLock) {
|
if (mPendingWrites.size() == 0) {
|
return; // Shouldn't happen but just in case.
|
}
|
|
mRetries++;
|
if (mRetries > MAX_RETRIES) {
|
doWtf("Gave up writing files: " + getKeysString(mPendingWrites));
|
return;
|
}
|
|
mHandler.removeCallbacks(mHandleWriteOnHandlerRunnable);
|
mHandler.postDelayed(mHandleWriteOnHandlerRunnable, RETRY_INTERVAL_MS);
|
}
|
}
|
|
/**
|
* Make sure {@link #mDefaultValues} has the default value loaded for {@code file}.
|
*
|
* @return true if the default value is loaded. false if the file cannot be read.
|
*/
|
private boolean ensureDefaultLoaded(String file) {
|
// Has the default already?
|
synchronized (mLock) {
|
if (mDefaultValues.containsKey(file)) {
|
return true;
|
}
|
}
|
final String originalValue;
|
try {
|
originalValue = injectReadFromFileTrimmed(file);
|
} catch (IOException e) {
|
// If the file is not readable, assume can't write too.
|
injectWtf("Unable to read from file", e);
|
|
removePendingWrite(file);
|
return false;
|
}
|
synchronized (mLock) {
|
mDefaultValues.put(file, originalValue);
|
saveDefaultValuesLocked();
|
}
|
return true;
|
}
|
|
@VisibleForTesting
|
String injectReadFromFileTrimmed(String file) throws IOException {
|
return IoUtils.readFileAsString(file).trim();
|
}
|
|
@VisibleForTesting
|
void injectWriteToFile(String file, String value) throws IOException {
|
if (injectShouldSkipWrite()) {
|
Slog.i(TAG, "Skipped writing to '" + file + "'");
|
return;
|
}
|
if (DEBUG) {
|
Slog.d(TAG, "Writing: '" + value + "' to '" + file + "'");
|
}
|
try (FileWriter out = new FileWriter(file)) {
|
out.write(value);
|
} catch (IOException | RuntimeException e) {
|
Slog.w(TAG, "Failed writing '" + value + "' to '" + file + "': " + e.getMessage());
|
throw e;
|
}
|
}
|
|
@GuardedBy("mLock")
|
private void saveDefaultValuesLocked() {
|
final AtomicFile file = new AtomicFile(injectDefaultValuesFilename());
|
|
FileOutputStream outs = null;
|
try {
|
file.getBaseFile().getParentFile().mkdirs();
|
outs = file.startWrite();
|
|
// Write to XML
|
XmlSerializer out = new FastXmlSerializer();
|
out.setOutput(outs, StandardCharsets.UTF_8.name());
|
out.startDocument(null, true);
|
out.startTag(null, TAG_DEFAULT_ROOT);
|
|
XmlUtils.writeMapXml(mDefaultValues, out, null);
|
|
// Epilogue.
|
out.endTag(null, TAG_DEFAULT_ROOT);
|
out.endDocument();
|
|
// Close.
|
file.finishWrite(outs);
|
} catch (IOException | XmlPullParserException | RuntimeException e) {
|
Slog.e(TAG, "Failed to write to file " + file.getBaseFile(), e);
|
file.failWrite(outs);
|
}
|
}
|
|
@GuardedBy("mLock")
|
@VisibleForTesting
|
boolean loadDefaultValuesLocked() {
|
final AtomicFile file = new AtomicFile(injectDefaultValuesFilename());
|
if (DEBUG) {
|
Slog.d(TAG, "Loading from " + file.getBaseFile());
|
}
|
Map<String, String> read = null;
|
try (FileInputStream in = file.openRead()) {
|
XmlPullParser parser = Xml.newPullParser();
|
parser.setInput(in, StandardCharsets.UTF_8.name());
|
|
int type;
|
while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
|
if (type != XmlPullParser.START_TAG) {
|
continue;
|
}
|
final int depth = parser.getDepth();
|
// Check the root tag
|
final String tag = parser.getName();
|
if (depth == 1) {
|
if (!TAG_DEFAULT_ROOT.equals(tag)) {
|
Slog.e(TAG, "Invalid root tag: " + tag);
|
return false;
|
}
|
continue;
|
}
|
final String[] tagName = new String[1];
|
read = (ArrayMap<String, String>) XmlUtils.readThisArrayMapXml(parser,
|
TAG_DEFAULT_ROOT, tagName, null);
|
}
|
} catch (FileNotFoundException e) {
|
read = null;
|
} catch (IOException | XmlPullParserException | RuntimeException e) {
|
Slog.e(TAG, "Failed to read file " + file.getBaseFile(), e);
|
}
|
if (read != null) {
|
mDefaultValues.clear();
|
mDefaultValues.putAll(read);
|
return true;
|
}
|
return false;
|
}
|
|
private void doWtf(String message) {
|
injectWtf(message, null);
|
}
|
|
@VisibleForTesting
|
void injectWtf(String message, Throwable e) {
|
Slog.wtf(TAG, message, e);
|
}
|
|
File injectDefaultValuesFilename() {
|
final File dir = new File(Environment.getDataSystemDirectory(), "battery-saver");
|
dir.mkdirs();
|
return new File(dir, "default-values.xml");
|
}
|
|
@VisibleForTesting
|
boolean injectShouldSkipWrite() {
|
return SystemProperties.getBoolean(PROP_SKIP_WRITE, false);
|
}
|
|
@VisibleForTesting
|
ArrayMap<String, String> getDefaultValuesForTest() {
|
return mDefaultValues;
|
}
|
}
|
