move ringbuffer interactions to wifi hal
Shallow copy of ringbuffer is stored inside the hal.
The maximum ringbuffer size is configured by the
framework.
overrides IBase::debug to:
1. write ringbuffers in memory to flash (wifi tombstones)
2. write wifi tombstones to lshal debug fd in archived format
Bug: 70171481
Test: compile, run on device
Test: run "lshal debug android.hardware.wifi@1.2::IWifi >>
archive.cpio" and compared archived files with originals using diff command
Change-Id: I33c30e37f245cfa36e005ba8cdc46e91f6de9237
diff --git a/wifi/1.2/default/wifi_chip.cpp b/wifi/1.2/default/wifi_chip.cpp
index adba054..8d39458 100644
--- a/wifi/1.2/default/wifi_chip.cpp
+++ b/wifi/1.2/default/wifi_chip.cpp
@@ -14,8 +14,13 @@
* limitations under the License.
*/
+#include <fcntl.h>
+
#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
#include <cutils/properties.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
#include "hidl_return_util.h"
#include "hidl_struct_util.h"
@@ -23,6 +28,7 @@
#include "wifi_status_util.h"
namespace {
+using android::base::unique_fd;
using android::hardware::hidl_string;
using android::hardware::hidl_vec;
using android::hardware::wifi::V1_0::ChipModeId;
@@ -39,6 +45,11 @@
// Mode ID for V2
constexpr ChipModeId kV2ChipModeId = 2;
+constexpr char kCpioMagic[] = "070701";
+constexpr size_t kMaxBufferSizeBytes = 1024 * 1024;
+constexpr uint32_t kMaxRingBufferFileAgeSeconds = 60 * 60;
+constexpr char kTombstoneFolderPath[] = "/data/vendor/tombstones/wifi/";
+
template <typename Iface>
void invalidateAndClear(std::vector<sp<Iface>>& ifaces, sp<Iface> iface) {
iface->invalidate();
@@ -93,6 +104,165 @@
return buffer.data();
}
+// delete files older than a predefined time in the wifi tombstone dir
+bool removeOldFilesInternal() {
+ time_t now = time(0);
+ const time_t delete_files_before = now - kMaxRingBufferFileAgeSeconds;
+ DIR* dir_dump = opendir(kTombstoneFolderPath);
+ if (!dir_dump) {
+ LOG(ERROR) << "Failed to open directory: " << strerror(errno);
+ return false;
+ }
+ unique_fd dir_auto_closer(dirfd(dir_dump));
+ struct dirent* dp;
+ bool success = true;
+ while ((dp = readdir(dir_dump))) {
+ if (dp->d_type != DT_REG) {
+ continue;
+ }
+ std::string cur_file_name(dp->d_name);
+ struct stat cur_file_stat;
+ std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
+ if (stat(cur_file_path.c_str(), &cur_file_stat) != -1) {
+ if (cur_file_stat.st_mtime < delete_files_before) {
+ if (unlink(cur_file_path.c_str()) != 0) {
+ LOG(ERROR) << "Error deleting file " << strerror(errno);
+ success = false;
+ }
+ }
+ } else {
+ LOG(ERROR) << "Failed to get file stat for " << cur_file_path
+ << ": " << strerror(errno);
+ success = false;
+ }
+ }
+ return success;
+}
+
+// Archives all files in |input_dir| and writes result into |out_fd|
+// Logic obtained from //external/toybox/toys/posix/cpio.c "Output cpio archive"
+// portion
+size_t cpioFilesInDir(int out_fd, const char* input_dir) {
+ struct dirent* dp;
+ size_t n_error = 0;
+ char read_buf[32 * 1024];
+ DIR* dir_dump = opendir(input_dir);
+ if (!dir_dump) {
+ LOG(ERROR) << "Failed to open directory: " << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+ unique_fd dir_auto_closer(dirfd(dir_dump));
+ while ((dp = readdir(dir_dump))) {
+ if (dp->d_type != DT_REG) {
+ continue;
+ }
+ std::string cur_file_name(dp->d_name);
+ const size_t file_name_len =
+ cur_file_name.size() + 1; // string.size() does not include the
+ // null terminator. The cpio FreeBSD file
+ // header expects the null character to
+ // be included in the length.
+ struct stat st;
+ ssize_t llen;
+ const std::string cur_file_path = kTombstoneFolderPath + cur_file_name;
+ if (stat(cur_file_path.c_str(), &st) != -1) {
+ const int fd_read = open(cur_file_path.c_str(), O_RDONLY);
+ unique_fd file_auto_closer(fd_read);
+ if (fd_read == -1) {
+ LOG(ERROR) << "Failed to read file " << cur_file_path << " "
+ << strerror(errno);
+ n_error++;
+ continue;
+ }
+ llen = sprintf(
+ read_buf,
+ "%s%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
+ kCpioMagic, static_cast<int>(st.st_ino), st.st_mode, st.st_uid,
+ st.st_gid, static_cast<int>(st.st_nlink),
+ static_cast<int>(st.st_mtime), static_cast<int>(st.st_size),
+ major(st.st_dev), minor(st.st_dev), major(st.st_rdev),
+ minor(st.st_rdev), static_cast<uint32_t>(file_name_len), 0);
+ if (write(out_fd, read_buf, llen) == -1) {
+ LOG(ERROR) << "Error writing cpio header to file "
+ << cur_file_path << " " << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+ if (write(out_fd, cur_file_name.c_str(), file_name_len) == -1) {
+ LOG(ERROR) << "Error writing filename to file " << cur_file_path
+ << " " << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+
+ // NUL Pad header up to 4 multiple bytes.
+ llen = (llen + file_name_len) % 4;
+ if (llen != 0) {
+ const uint32_t zero = 0;
+ if (write(out_fd, &zero, 4 - llen) == -1) {
+ LOG(ERROR) << "Error padding 0s to file " << cur_file_path
+ << " " << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+ }
+
+ // writing content of file
+ llen = st.st_size;
+ while (llen > 0) {
+ ssize_t bytes_read = read(fd_read, read_buf, sizeof(read_buf));
+ if (bytes_read == -1) {
+ LOG(ERROR) << "Error reading file " << cur_file_path << " "
+ << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+ llen -= bytes_read;
+ if (write(out_fd, read_buf, bytes_read) == -1) {
+ LOG(ERROR) << "Error writing data to file " << cur_file_path
+ << " " << strerror(errno);
+ n_error++;
+ return n_error;
+ }
+ if (bytes_read ==
+ 0) { // this should never happen, but just in case
+ // to unstuck from while loop
+ LOG(ERROR) << "Unexpected file size for " << cur_file_path
+ << " " << strerror(errno);
+ n_error++;
+ break;
+ }
+ }
+ llen = st.st_size % 4;
+ if (llen != 0) {
+ const uint32_t zero = 0;
+ write(out_fd, &zero, 4 - llen);
+ }
+ } else {
+ LOG(ERROR) << "Failed to get file stat for " << cur_file_path
+ << ": " << strerror(errno);
+ n_error++;
+ }
+ }
+ memset(read_buf, 0, sizeof(read_buf));
+ if (write(out_fd, read_buf,
+ sprintf(read_buf, "070701%040X%056X%08XTRAILER!!!", 1, 0x0b, 0) +
+ 4) == -1) {
+ LOG(ERROR) << "Error writing trailing bytes " << strerror(errno);
+ n_error++;
+ }
+ return n_error;
+}
+
+// Helper function to create a non-const char*.
+std::vector<char> makeCharVec(const std::string& str) {
+ std::vector<char> vec(str.size() + 1);
+ vec.assign(str.begin(), str.end());
+ vec.push_back('\0');
+ return vec;
+}
+
} // namespace
namespace android {
@@ -350,6 +520,24 @@
hidl_status_cb);
}
+Return<void> WifiChip::debug(const hidl_handle& handle,
+ const hidl_vec<hidl_string>&) {
+ if (handle != nullptr && handle->numFds >= 1) {
+ int fd = handle->data[0];
+ if (!writeRingbufferFilesInternal()) {
+ LOG(ERROR) << "Error writing files to flash";
+ }
+ uint32_t n_error = cpioFilesInDir(fd, kTombstoneFolderPath);
+ if (n_error != 0) {
+ LOG(ERROR) << n_error << " errors occured in cpio function";
+ }
+ fsync(fd);
+ } else {
+ LOG(ERROR) << "File handle error";
+ }
+ return Void();
+}
+
void WifiChip::invalidateAndRemoveAllIfaces() {
invalidateAndClearAll(ap_ifaces_);
invalidateAndClearAll(nan_ifaces_);
@@ -726,6 +914,8 @@
std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
verbose_level),
max_interval_in_sec, min_data_size_in_bytes);
+ ringbuffer_map_.insert(std::pair<std::string, Ringbuffer>(
+ ring_name, Ringbuffer(kMaxBufferSizeBytes)));
return createWifiStatusFromLegacyError(legacy_status);
}
@@ -737,6 +927,7 @@
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->getRingBufferData(getWlan0IfaceName(), ring_name);
+
return createWifiStatusFromLegacyError(legacy_status);
}
@@ -848,7 +1039,7 @@
android::wp<WifiChip> weak_ptr_this(this);
const auto& on_ring_buffer_data_callback =
- [weak_ptr_this](const std::string& /* name */,
+ [weak_ptr_this](const std::string& name,
const std::vector<uint8_t>& data,
const legacy_hal::wifi_ring_buffer_status& status) {
const auto shared_ptr_this = weak_ptr_this.promote();
@@ -862,13 +1053,13 @@
LOG(ERROR) << "Error converting ring buffer status";
return;
}
- for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
- if (!callback->onDebugRingBufferDataAvailable(hidl_status, data)
- .isOk()) {
- LOG(ERROR)
- << "Failed to invoke onDebugRingBufferDataAvailable"
- << " callback on: " << toString(callback);
- }
+ const auto& target = shared_ptr_this->ringbuffer_map_.find(name);
+ if (target != shared_ptr_this->ringbuffer_map_.end()) {
+ Ringbuffer& cur_buffer = target->second;
+ cur_buffer.append(data);
+ } else {
+ LOG(ERROR) << "Ringname " << name << " not found";
+ return;
}
};
legacy_hal::wifi_error legacy_status =
@@ -1079,6 +1270,35 @@
return {};
}
+bool WifiChip::writeRingbufferFilesInternal() {
+ if (!removeOldFilesInternal()) {
+ LOG(ERROR) << "Error occurred while deleting old tombstone files";
+ return false;
+ }
+ // write ringbuffers to file
+ for (const auto& item : ringbuffer_map_) {
+ const Ringbuffer& cur_buffer = item.second;
+ if (cur_buffer.getData().empty()) {
+ continue;
+ }
+ const std::string file_path_raw =
+ kTombstoneFolderPath + item.first + "XXXXXXXXXX";
+ const int dump_fd = mkstemp(makeCharVec(file_path_raw).data());
+ if (dump_fd == -1) {
+ LOG(ERROR) << "create file failed: " << strerror(errno);
+ return false;
+ }
+ unique_fd file_auto_closer(dump_fd);
+ for (const auto& cur_block : cur_buffer.getData()) {
+ if (write(dump_fd, cur_block.data(),
+ sizeof(cur_block[0]) * cur_block.size()) == -1) {
+ LOG(ERROR) << "Error writing to file " << strerror(errno);
+ }
+ }
+ }
+ return true;
+}
+
} // namespace implementation
} // namespace V1_2
} // namespace wifi