/*
* Copyright (C) 2010 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.wifi;
import com.android.internal.app.IBatteryStats;
import com.android.internal.util.Protocol;
import android.support.v4.util.CircularArray;
import android.util.Base64;
import android.util.LocalLog;
import android.util.Log;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Calendar;
import java.util.HashMap;
import java.util.zip.Deflater;
/**
* Tracks various logs for framework
*/
class WifiLogger {
private static final String TAG = "WifiLogger";
private static final boolean DBG = false;
/** log level flags; keep these consistent with wifi_logger.h */
/** No logs whatsoever */
public static final int VERBOSE_NO_LOG = 0;
/** No logs whatsoever */
public static final int VERBOSE_NORMAL_LOG = 1;
/** Be careful since this one can affect performance and power */
public static final int VERBOSE_LOG_WITH_WAKEUP = 2;
/** Be careful since this one can affect performance and power and memory */
public static final int VERBOSE_DETAILED_LOG_WITH_WAKEUP = 3;
/** ring buffer flags; keep these consistent with wifi_logger.h */
public static final int RING_BUFFER_FLAG_HAS_BINARY_ENTRIES = 0x00000001;
public static final int RING_BUFFER_FLAG_HAS_ASCII_ENTRIES = 0x00000002;
public static final int RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES = 0x00000004;
/** various reason codes */
public static final int REPORT_REASON_NONE = 0;
public static final int REPORT_REASON_ASSOC_FAILURE = 1;
public static final int REPORT_REASON_AUTH_FAILURE = 2;
public static final int REPORT_REASON_AUTOROAM_FAILURE = 3;
public static final int REPORT_REASON_DHCP_FAILURE = 4;
public static final int REPORT_REASON_UNEXPECTED_DISCONNECT = 5;
public static final int REPORT_REASON_SCAN_FAILURE = 6;
public static final int REPORT_REASON_USER_ACTION = 7;
/** number of ring buffer entries to cache */
public static final int MAX_RING_BUFFERS = 10;
/** number of bug reports to hold */
public static final int MAX_BUG_REPORTS = 4;
/** number of alerts to hold */
public static final int MAX_ALERT_REPORTS = 1;
/** minimum wakeup interval for each of the log levels */
private static final int MinWakeupIntervals[] = new int[] { 0, 3600, 60, 10 };
/** minimum buffer size for each of the log levels */
private static final int MinBufferSizes[] = new int[] { 0, 16384, 16384, 65536 };
private int mLogLevel = VERBOSE_NO_LOG;
private String mFirmwareVersion;
private String mDriverVersion;
private int mSupportedFeatureSet;
private WifiNative.RingBufferStatus[] mRingBuffers;
private WifiNative.RingBufferStatus mPerPacketRingBuffer;
private WifiStateMachine mWifiStateMachine;
public WifiLogger(WifiStateMachine wifiStateMachine) {
mWifiStateMachine = wifiStateMachine;
}
public synchronized void startLogging(boolean verboseEnabled) {
mFirmwareVersion = WifiNative.getFirmwareVersion();
mDriverVersion = WifiNative.getDriverVersion();
mSupportedFeatureSet = WifiNative.getSupportedLoggerFeatureSet();
if (mLogLevel == VERBOSE_NO_LOG)
WifiNative.setLoggingEventHandler(mHandler);
if (verboseEnabled) {
mLogLevel = VERBOSE_LOG_WITH_WAKEUP;
} else {
mLogLevel = VERBOSE_NORMAL_LOG;
}
if (mRingBuffers == null) {
if (fetchRingBuffers()) {
startLoggingAllExceptPerPacketBuffers();
}
}
}
public synchronized void startPacketLog() {
if (mPerPacketRingBuffer != null) {
startLoggingRingBuffer(mPerPacketRingBuffer);
} else {
if (DBG) Log.d(TAG, "There is no per packet ring buffer");
}
}
public synchronized void stopPacketLog() {
if (mPerPacketRingBuffer != null) {
stopLoggingRingBuffer(mPerPacketRingBuffer);
} else {
if (DBG) Log.d(TAG, "There is no per packet ring buffer");
}
}
public synchronized void stopLogging() {
if (mLogLevel != VERBOSE_NO_LOG) {
//resetLogHandler only can be used when you terminate all logging since all handler will
//be removed. This also stop alert logging
if(!WifiNative.resetLogHandler()) {
Log.e(TAG, "Fail to reset log handler");
} else {
if (DBG) Log.d(TAG,"Reset log handler");
}
stopLoggingAllBuffers();
mRingBuffers = null;
mLogLevel = VERBOSE_NO_LOG;
}
}
public synchronized void captureBugReportData(int reason) {
BugReport report = captureBugreport(reason, true);
mLastBugReports.addLast(report);
}
public synchronized void captureAlertData(int errorCode, byte[] alertData) {
BugReport report = captureBugreport(errorCode, /* captureFWDump = */ true);
report.alertData = alertData;
mLastAlerts.addLast(report);
}
public synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("Chipset information :-----------------------------------------------");
pw.println("FW Version is: " + mFirmwareVersion);
pw.println("Driver Version is: " + mDriverVersion);
pw.println("Supported Feature set: " + mSupportedFeatureSet);
for (int i = 0; i < mLastAlerts.size(); i++) {
pw.println("--------------------------------------------------------------------");
pw.println("Alert dump " + i);
pw.print(mLastAlerts.get(i));
pw.println("--------------------------------------------------------------------");
}
for (int i = 0; i < mLastBugReports.size(); i++) {
pw.println("--------------------------------------------------------------------");
pw.println("Bug dump " + i);
pw.print(mLastBugReports.get(i));
pw.println("--------------------------------------------------------------------");
}
pw.println("--------------------------------------------------------------------");
}
/* private methods and data */
private static class BugReport {
long systemTimeMs;
long kernelTimeNanos;
int errorCode;
HashMap<String, byte[][]> ringBuffers = new HashMap();
byte[] fwMemoryDump;
byte[] alertData;
public String toString() {
StringBuilder builder = new StringBuilder();
Calendar c = Calendar.getInstance();
c.setTimeInMillis(systemTimeMs);
builder.append("system time = ").append(
String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c)).append("\n");
long kernelTimeMs = kernelTimeNanos/(1000*1000);
builder.append("kernel time = ").append(kernelTimeMs/1000).append(".").append
(kernelTimeMs%1000).append("\n");
if (alertData == null)
builder.append("reason = ").append(errorCode).append("\n");
else {
builder.append("errorCode = ").append(errorCode);
builder.append("data \n");
builder.append(compressToBase64(alertData)).append("\n");
}
for (HashMap.Entry<String, byte[][]> e : ringBuffers.entrySet()) {
String ringName = e.getKey();
byte[][] buffers = e.getValue();
builder.append("ring-buffer = ").append(ringName).append("\n");
int size = 0;
for (int i = 0; i < buffers.length; i++) {
size += buffers[i].length;
}
byte[] buffer = new byte[size];
int index = 0;
for (int i = 0; i < buffers.length; i++) {
System.arraycopy(buffers[i], 0, buffer, index, buffers[i].length);
index += buffers[i].length;
}
builder.append(compressToBase64(buffer));
builder.append("\n");
}
if (fwMemoryDump != null) {
builder.append("FW Memory dump \n");
builder.append(compressToBase64(fwMemoryDump));
}
return builder.toString();
}
}
static class LimitedCircularArray<E> {
private CircularArray<E> mArray;
private int mMax;
LimitedCircularArray(int max) {
mArray = new CircularArray<E>();
mMax = max;
}
public final void addLast(E e) {
if (mArray.size() >= mMax)
mArray.popFirst();
mArray.addLast(e);
}
public final int size() {
return mArray.size();
}
public final E get(int i) {
return mArray.get(i);
}
}
private final LimitedCircularArray<BugReport> mLastAlerts =
new LimitedCircularArray<BugReport>(MAX_ALERT_REPORTS);
private final LimitedCircularArray<BugReport> mLastBugReports =
new LimitedCircularArray<BugReport>(MAX_BUG_REPORTS);
private final HashMap<String, LimitedCircularArray<byte[]>> mRingBufferData = new HashMap();
private final WifiNative.WifiLoggerEventHandler mHandler =
new WifiNative.WifiLoggerEventHandler() {
@Override
public void onRingBufferData(WifiNative.RingBufferStatus status, byte[] buffer) {
WifiLogger.this.onRingBufferData(status, buffer);
}
@Override
public void onWifiAlert(int errorCode, byte[] buffer) {
WifiLogger.this.onWifiAlert(errorCode, buffer);
}
};
synchronized void onRingBufferData(WifiNative.RingBufferStatus status, byte[] buffer) {
LimitedCircularArray<byte[]> ring = mRingBufferData.get(status.name);
if (ring != null) {
ring.addLast(buffer);
}
}
synchronized void onWifiAlert(int errorCode, byte[] buffer) {
if (mWifiStateMachine != null) {
mWifiStateMachine.sendMessage(
WifiStateMachine.CMD_FIRMWARE_ALERT, errorCode, 0, buffer);
}
}
private boolean fetchRingBuffers() {
if (mRingBuffers != null) return true;
mRingBuffers = WifiNative.getRingBufferStatus();
if (mRingBuffers != null) {
for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
if (DBG) Log.d(TAG, "RingBufferStatus is: \n" + buffer.name);
if (mRingBufferData.containsKey(buffer.name) == false) {
mRingBufferData.put(buffer.name,
new LimitedCircularArray<byte[]>(MAX_RING_BUFFERS));
}
if ((buffer.flag & RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES) != 0) {
mPerPacketRingBuffer = buffer;
}
}
} else {
Log.e(TAG, "no ring buffers found");
}
return mRingBuffers != null;
}
private boolean startLoggingAllExceptPerPacketBuffers() {
if (mRingBuffers == null) {
if (DBG) Log.d(TAG, "No ring buffers to log anything!");
return false;
}
for (WifiNative.RingBufferStatus buffer : mRingBuffers){
if ((buffer.flag & RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES) != 0) {
/* skip per-packet-buffer */
if (DBG) Log.d(TAG, "skipped per packet logging ring " + buffer.name);
continue;
}
startLoggingRingBuffer(buffer);
}
return true;
}
private boolean startLoggingRingBuffer(WifiNative.RingBufferStatus buffer) {
int minInterval = MinWakeupIntervals[mLogLevel];
int minDataSize = MinBufferSizes[mLogLevel];
if (WifiNative.startLoggingRingBuffer(
mLogLevel, 0, minInterval, minDataSize, buffer.name) == false) {
if (DBG) Log.e(TAG, "Could not start logging ring " + buffer.name);
return false;
}
return true;
}
private boolean stopLoggingRingBuffer(WifiNative.RingBufferStatus buffer) {
if (WifiNative.startLoggingRingBuffer(0, 0, 0, 0, buffer.name) == false) {
if (DBG) Log.e(TAG, "Could not stop logging ring " + buffer.name);
}
return true;
}
private boolean stopLoggingAllBuffers() {
if (mRingBuffers != null) {
for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
stopLoggingRingBuffer(buffer);
}
}
return true;
}
private boolean getAllRingBufferData() {
if (mRingBuffers == null) {
Log.e(TAG, "Not ring buffers available to collect data!");
return false;
}
for (WifiNative.RingBufferStatus element : mRingBuffers){
boolean result = WifiNative.getRingBufferData(element.name);
if (!result) {
Log.e(TAG, "Fail to get ring buffer data of: " + element.name);
return false;
}
}
Log.d(TAG, "getAllRingBufferData Successfully!");
return true;
}
private BugReport captureBugreport(int errorCode, boolean captureFWDump) {
BugReport report = new BugReport();
report.errorCode = errorCode;
report.systemTimeMs = System.currentTimeMillis();
report.kernelTimeNanos = System.nanoTime();
if (mRingBuffers != null) {
for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
/* this will push data in mRingBuffers */
WifiNative.getRingBufferData(buffer.name);
LimitedCircularArray<byte[]> data = mRingBufferData.get(buffer.name);
byte[][] buffers = new byte[data.size()][];
for (int i = 0; i < data.size(); i++) {
buffers[i] = data.get(i).clone();
}
report.ringBuffers.put(buffer.name, buffers);
}
}
if (captureFWDump) {
report.fwMemoryDump = WifiNative.getFwMemoryDump();
}
return report;
}
private static String compressToBase64(byte[] input) {
String result;
//compress
Deflater compressor = new Deflater();
compressor.setLevel(Deflater.BEST_COMPRESSION);
compressor.setInput(input);
compressor.finish();
ByteArrayOutputStream bos = new ByteArrayOutputStream(input.length);
final byte[] buf = new byte[1024];
while (!compressor.finished()) {
int count = compressor.deflate(buf);
bos.write(buf, 0, count);
}
try {
compressor.end();
bos.close();
} catch (IOException e) {
Log.e(TAG, "ByteArrayOutputStream close error");
result = android.util.Base64.encodeToString(input, Base64.DEFAULT);
return result;
}
byte[] compressed = bos.toByteArray();
if (DBG) {
Log.d(TAG," length is:" + (compressed == null? "0" : compressed.length));
}
//encode
result = android.util.Base64.encodeToString(
compressed.length < input.length ? compressed : input , Base64.DEFAULT);
if (DBG) {
Log.d(TAG, "FwMemoryDump length is :" + result.length());
}
return result;
}
}