Merge "liblp: Expose MockPropertyFetcher for liblp-dependent tests."
diff --git a/fs_mgr/liblp/Android.bp b/fs_mgr/liblp/Android.bp
index 2b11da2..f0142bb 100644
--- a/fs_mgr/liblp/Android.bp
+++ b/fs_mgr/liblp/Android.bp
@@ -55,13 +55,14 @@
export_include_dirs: ["include"],
}
-cc_test {
- name: "liblp_test_static",
+cc_defaults {
+ name: "liblp_test_defaults",
defaults: ["fs_mgr_defaults"],
cppflags: [
"-Wno-unused-parameter",
],
static_libs: [
+ "libcutils",
"libgmock",
"libfs_mgr",
"liblp",
@@ -74,11 +75,20 @@
"test_partition_opener.cpp",
"utility_test.cpp",
],
- target: {
- android: {
- static_libs: [
- "libcutils",
- ],
- },
- },
}
+
+cc_test {
+ name: "liblp_test",
+ defaults: ["liblp_test_defaults"],
+ test_config: "liblp_test.xml",
+ test_suites: [
+ "device-tests",
+ "vts-core",
+ ],
+}
+
+cc_test {
+ name: "vts_kernel_liblp_test",
+ defaults: ["liblp_test_defaults"],
+}
+
diff --git a/fs_mgr/liblp/AndroidTest.xml b/fs_mgr/liblp/AndroidTest.xml
index fe1002c..2eb0ad1 100644
--- a/fs_mgr/liblp/AndroidTest.xml
+++ b/fs_mgr/liblp/AndroidTest.xml
@@ -21,8 +21,8 @@
</target_preparer>
<test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
<option name="test-module-name" value="VtsKernelLiblpTest"/>
- <option name="binary-test-source" value="_32bit::DATA/nativetest/liblp_test_static/liblp_test_static" />
- <option name="binary-test-source" value="_64bit::DATA/nativetest64/liblp_test_static/liblp_test_static" />
+ <option name="binary-test-source" value="_32bit::DATA/nativetest/vts_kernel_liblp_test/vts_kernel_liblp_test" />
+ <option name="binary-test-source" value="_64bit::DATA/nativetest64/vts_kernel_liblp_test/vts_kernel_liblp_test" />
<option name="binary-test-type" value="gtest"/>
<option name="test-timeout" value="1m"/>
<option name="precondition-first-api-level" value="29" />
diff --git a/fs_mgr/liblp/TEST_MAPPING b/fs_mgr/liblp/TEST_MAPPING
new file mode 100644
index 0000000..04bcbda
--- /dev/null
+++ b/fs_mgr/liblp/TEST_MAPPING
@@ -0,0 +1,7 @@
+{
+ "presubmit": [
+ {
+ "name": "liblp_test"
+ }
+ ]
+}
diff --git a/fs_mgr/liblp/liblp_test.xml b/fs_mgr/liblp/liblp_test.xml
new file mode 100644
index 0000000..d9ee12e
--- /dev/null
+++ b/fs_mgr/liblp/liblp_test.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2019 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.
+-->
+<configuration description="Config for liblp_test">
+ <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer"/>
+ <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
+ <option name="cleanup" value="true" />
+ <option name="push" value="liblp_test->/data/local/tmp/liblp_test" />
+ </target_preparer>
+ <option name="test-suite-tag" value="vts-core" />
+ <test class="com.android.tradefed.testtype.GTest" >
+ <option name="native-test-device-path" value="/data/local/tmp" />
+ <option name="module-name" value="liblp_test" />
+ </test>
+</configuration>
diff --git a/libprocinfo/Android.bp b/libprocinfo/Android.bp
index 15f03d0..0c9a2b8 100644
--- a/libprocinfo/Android.bp
+++ b/libprocinfo/Android.bp
@@ -34,6 +34,7 @@
host_supported: true,
srcs: [
"process.cpp",
+ "process_map.cpp",
],
local_include_dirs: ["include"],
@@ -58,6 +59,7 @@
name: "libprocinfo_test",
defaults: ["libprocinfo_defaults"],
host_supported: true,
+ isolated: true,
srcs: [
"process_test.cpp",
"process_map_test.cpp",
diff --git a/libprocinfo/include/procinfo/process_map.h b/libprocinfo/include/procinfo/process_map.h
index b6ec3cb..569a022 100644
--- a/libprocinfo/include/procinfo/process_map.h
+++ b/libprocinfo/include/procinfo/process_map.h
@@ -176,5 +176,9 @@
const char* name) { maps->emplace_back(start, end, flags, pgoff, inode, name); });
}
+bool ReadMapFileAsyncSafe(const char* map_file, void* buffer, size_t buffer_size,
+ const std::function<void(uint64_t, uint64_t, uint16_t, uint64_t, ino_t,
+ const char*)>& callback);
+
} /* namespace procinfo */
} /* namespace android */
diff --git a/libprocinfo/process_map.cpp b/libprocinfo/process_map.cpp
new file mode 100644
index 0000000..5e240b9
--- /dev/null
+++ b/libprocinfo/process_map.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+#include <procinfo/process_map.h>
+
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <procinfo/process.h>
+
+namespace android {
+namespace procinfo {
+
+bool ReadMapFileAsyncSafe(const char* map_file, void* buffer, size_t buffer_size,
+ const std::function<void(uint64_t, uint64_t, uint16_t, uint64_t, ino_t,
+ const char*)>& callback) {
+ if (buffer == nullptr || buffer_size == 0) {
+ return false;
+ }
+
+ int fd = open(map_file, O_RDONLY | O_CLOEXEC);
+ if (fd == -1) {
+ return false;
+ }
+
+ char* char_buffer = reinterpret_cast<char*>(buffer);
+ size_t start = 0;
+ size_t read_bytes = 0;
+ char* line = nullptr;
+ bool read_complete = false;
+ while (true) {
+ ssize_t bytes =
+ TEMP_FAILURE_RETRY(read(fd, char_buffer + read_bytes, buffer_size - read_bytes - 1));
+ if (bytes <= 0) {
+ if (read_bytes == 0) {
+ close(fd);
+ return bytes == 0;
+ }
+ // Treat the last piece of data as the last line.
+ char_buffer[start + read_bytes] = '\n';
+ bytes = 1;
+ read_complete = true;
+ }
+ read_bytes += bytes;
+
+ while (read_bytes > 0) {
+ char* newline = reinterpret_cast<char*>(memchr(&char_buffer[start], '\n', read_bytes));
+ if (newline == nullptr) {
+ break;
+ }
+ *newline = '\0';
+ line = &char_buffer[start];
+ start = newline - char_buffer + 1;
+ read_bytes -= newline - line + 1;
+
+ // Ignore the return code, errors are okay.
+ ReadMapFileContent(line, callback);
+ }
+
+ if (read_complete) {
+ close(fd);
+ return true;
+ }
+
+ if (start == 0 && read_bytes == buffer_size - 1) {
+ // The buffer provided is too small to contain this line, give up
+ // and indicate failure.
+ close(fd);
+ return false;
+ }
+
+ // Copy any leftover data to the front of the buffer.
+ if (start > 0) {
+ if (read_bytes > 0) {
+ memmove(char_buffer, &char_buffer[start], read_bytes);
+ }
+ start = 0;
+ }
+ }
+}
+
+} /* namespace procinfo */
+} /* namespace android */
diff --git a/libprocinfo/process_map_test.cpp b/libprocinfo/process_map_test.cpp
index 562d864..b1bdc08 100644
--- a/libprocinfo/process_map_test.cpp
+++ b/libprocinfo/process_map_test.cpp
@@ -16,9 +16,14 @@
#include <procinfo/process_map.h>
+#include <inttypes.h>
+#include <sys/mman.h>
+
#include <string>
+#include <vector>
#include <android-base/file.h>
+#include <android-base/stringprintf.h>
#include <gtest/gtest.h>
@@ -63,3 +68,215 @@
ASSERT_TRUE(android::procinfo::ReadProcessMaps(getpid(), &maps));
ASSERT_GT(maps.size(), 0u);
}
+
+extern "C" void malloc_disable();
+extern "C" void malloc_enable();
+
+struct TestMapInfo {
+ TestMapInfo() = default;
+ TestMapInfo(uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t inode,
+ const char* new_name)
+ : start(start), end(end), flags(flags), pgoff(pgoff), inode(inode) {
+ strcpy(name, new_name);
+ }
+ uint64_t start = 0;
+ uint64_t end = 0;
+ uint16_t flags = 0;
+ uint64_t pgoff = 0;
+ ino_t inode = 0;
+ char name[100] = {};
+};
+
+void VerifyReadMapFileAsyncSafe(const char* maps_data,
+ const std::vector<TestMapInfo>& expected_info) {
+ TemporaryFile tf;
+ ASSERT_TRUE(android::base::WriteStringToFd(maps_data, tf.fd));
+
+ std::vector<TestMapInfo> saved_info(expected_info.size());
+ size_t num_maps = 0;
+
+ auto callback = [&](uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t inode,
+ const char* name) {
+ if (num_maps != saved_info.size()) {
+ TestMapInfo& saved = saved_info[num_maps];
+ saved.start = start;
+ saved.end = end;
+ saved.flags = flags;
+ saved.pgoff = pgoff;
+ saved.inode = inode;
+ strcpy(saved.name, name);
+ }
+ num_maps++;
+ };
+
+ std::vector<char> buffer(64 * 1024);
+
+#if defined(__BIONIC__)
+ // Any allocations will block after this call.
+ malloc_disable();
+#endif
+
+ bool parsed =
+ android::procinfo::ReadMapFileAsyncSafe(tf.path, buffer.data(), buffer.size(), callback);
+
+#if defined(__BIONIC__)
+ malloc_enable();
+#endif
+
+ ASSERT_TRUE(parsed) << "Parsing of data failed:\n" << maps_data;
+ ASSERT_EQ(expected_info.size(), num_maps);
+ for (size_t i = 0; i < expected_info.size(); i++) {
+ const TestMapInfo& expected = expected_info[i];
+ const TestMapInfo& saved = saved_info[i];
+ EXPECT_EQ(expected.start, saved.start);
+ EXPECT_EQ(expected.end, saved.end);
+ EXPECT_EQ(expected.flags, saved.flags);
+ EXPECT_EQ(expected.pgoff, saved.pgoff);
+ EXPECT_EQ(expected.inode, saved.inode);
+ EXPECT_STREQ(expected.name, saved.name);
+ }
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_invalid) {
+ std::vector<TestMapInfo> expected_info;
+
+ VerifyReadMapFileAsyncSafe("12c00000-2ac00000", expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_single) {
+ std::vector<TestMapInfo> expected_info;
+ expected_info.emplace_back(0x12c00000, 0x2ac00000, PROT_READ | PROT_WRITE, 0x100, 10267643,
+ "/lib/fake.so");
+
+ VerifyReadMapFileAsyncSafe("12c00000-2ac00000 rw-p 00000100 00:05 10267643 /lib/fake.so",
+ expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_single_with_newline) {
+ std::vector<TestMapInfo> expected_info;
+ expected_info.emplace_back(0x12c00000, 0x2ac00000, PROT_READ | PROT_WRITE, 0x100, 10267643,
+ "/lib/fake.so");
+
+ VerifyReadMapFileAsyncSafe("12c00000-2ac00000 rw-p 00000100 00:05 10267643 /lib/fake.so\n",
+ expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_single_no_library) {
+ std::vector<TestMapInfo> expected_info;
+ expected_info.emplace_back(0xa0000, 0xc0000, PROT_READ | PROT_WRITE | PROT_EXEC, 0xb00, 101, "");
+
+ VerifyReadMapFileAsyncSafe("a0000-c0000 rwxp 00000b00 00:05 101", expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_multiple) {
+ std::vector<TestMapInfo> expected_info;
+ expected_info.emplace_back(0xa0000, 0xc0000, PROT_READ | PROT_WRITE | PROT_EXEC, 1, 100, "");
+ expected_info.emplace_back(0xd0000, 0xe0000, PROT_READ, 2, 101, "/lib/libsomething1.so");
+ expected_info.emplace_back(0xf0000, 0x100000, PROT_WRITE, 3, 102, "/lib/libsomething2.so");
+ expected_info.emplace_back(0x110000, 0x120000, PROT_EXEC, 4, 103, "[anon:something or another]");
+
+ std::string map_data =
+ "0a0000-0c0000 rwxp 00000001 00:05 100\n"
+ "0d0000-0e0000 r--p 00000002 00:05 101 /lib/libsomething1.so\n"
+ "0f0000-100000 -w-p 00000003 00:05 102 /lib/libsomething2.so\n"
+ "110000-120000 --xp 00000004 00:05 103 [anon:something or another]\n";
+
+ VerifyReadMapFileAsyncSafe(map_data.c_str(), expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_multiple_reads) {
+ std::vector<TestMapInfo> expected_info;
+ std::string map_data;
+ uint64_t start = 0xa0000;
+ for (size_t i = 0; i < 10000; i++) {
+ map_data += android::base::StringPrintf("%" PRIx64 "-%" PRIx64 " r--p %zx 01:20 %zu fake.so\n",
+ start, start + 0x1000, i, 1000 + i);
+ expected_info.emplace_back(start, start + 0x1000, PROT_READ, i, 1000 + i, "fake.so");
+ }
+
+ VerifyReadMapFileAsyncSafe(map_data.c_str(), expected_info);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_buffer_nullptr) {
+ size_t num_calls = 0;
+ auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; };
+
+#if defined(__BIONIC__)
+ // Any allocations will block after this call.
+ malloc_disable();
+#endif
+
+ bool parsed = android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", nullptr, 10, callback);
+
+#if defined(__BIONIC__)
+ malloc_enable();
+#endif
+
+ ASSERT_FALSE(parsed);
+ EXPECT_EQ(0UL, num_calls);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_buffer_size_zero) {
+ size_t num_calls = 0;
+ auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; };
+
+#if defined(__BIONIC__)
+ // Any allocations will block after this call.
+ malloc_disable();
+#endif
+
+ char buffer[10];
+ bool parsed = android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", buffer, 0, callback);
+
+#if defined(__BIONIC__)
+ malloc_enable();
+#endif
+
+ ASSERT_FALSE(parsed);
+ EXPECT_EQ(0UL, num_calls);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_buffer_too_small_no_calls) {
+ size_t num_calls = 0;
+ auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; };
+
+#if defined(__BIONIC__)
+ // Any allocations will block after this call.
+ malloc_disable();
+#endif
+
+ char buffer[10];
+ bool parsed =
+ android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", buffer, sizeof(buffer), callback);
+
+#if defined(__BIONIC__)
+ malloc_enable();
+#endif
+
+ ASSERT_FALSE(parsed);
+ EXPECT_EQ(0UL, num_calls);
+}
+
+TEST(process_map, ReadMapFileAsyncSafe_buffer_too_small_could_parse) {
+ TemporaryFile tf;
+ ASSERT_TRUE(android::base::WriteStringToFd(
+ "0a0000-0c0000 rwxp 00000001 00:05 100 /fake/lib.so\n", tf.fd));
+
+ size_t num_calls = 0;
+ auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; };
+
+#if defined(__BIONIC__)
+ // Any allocations will block after this call.
+ malloc_disable();
+#endif
+
+ char buffer[39];
+ bool parsed = android::procinfo::ReadMapFileAsyncSafe(tf.path, buffer, sizeof(buffer), callback);
+
+#if defined(__BIONIC__)
+ malloc_enable();
+#endif
+
+ ASSERT_FALSE(parsed);
+ EXPECT_EQ(0UL, num_calls);
+}
diff --git a/logd/LogBufferElement.cpp b/logd/LogBufferElement.cpp
index 2fd9f95..82c4fb9 100644
--- a/logd/LogBufferElement.cpp
+++ b/logd/LogBufferElement.cpp
@@ -56,14 +56,7 @@
mLogId(elem.mLogId),
mDropped(elem.mDropped) {
if (mDropped) {
- if (elem.isBinary() && elem.mMsg != nullptr) {
- // for the following "len" value, refer to : setDropped(uint16_t value), getTag()
- const int len = sizeof(android_event_header_t);
- mMsg = new char[len];
- memcpy(mMsg, elem.mMsg, len);
- } else {
- mMsg = nullptr;
- }
+ mTag = elem.getTag();
} else {
mMsg = new char[mMsgLen];
memcpy(mMsg, elem.mMsg, mMsgLen);
@@ -71,31 +64,43 @@
}
LogBufferElement::~LogBufferElement() {
- delete[] mMsg;
+ if (!mDropped) {
+ delete[] mMsg;
+ }
}
uint32_t LogBufferElement::getTag() const {
- return (isBinary() &&
- ((mDropped && mMsg != nullptr) ||
- (!mDropped && mMsgLen >= sizeof(android_event_header_t))))
- ? reinterpret_cast<const android_event_header_t*>(mMsg)->tag
- : 0;
+ // Binary buffers have no tag.
+ if (!isBinary()) {
+ return 0;
+ }
+
+ // Dropped messages store the tag in place of mMsg.
+ if (mDropped) {
+ return mTag;
+ }
+
+ // For non-dropped messages, we get the tag from the message header itself.
+ if (mMsgLen < sizeof(android_event_header_t)) {
+ return 0;
+ }
+
+ return reinterpret_cast<const android_event_header_t*>(mMsg)->tag;
}
uint16_t LogBufferElement::setDropped(uint16_t value) {
- // The tag information is saved in mMsg data, if the tag is non-zero
- // save only the information needed to get the tag.
- if (getTag() != 0) {
- if (mMsgLen > sizeof(android_event_header_t)) {
- char* truncated_msg = new char[sizeof(android_event_header_t)];
- memcpy(truncated_msg, mMsg, sizeof(android_event_header_t));
- delete[] mMsg;
- mMsg = truncated_msg;
- } // mMsgLen == sizeof(android_event_header_t), already at minimum.
- } else {
- delete[] mMsg;
- mMsg = nullptr;
+ if (mDropped) {
+ return mDroppedCount = value;
}
+
+ // The tag information is saved in mMsg data, which is in a union with mTag, used after mDropped
+ // is set to true. Therefore we save the tag value aside, delete mMsg, then set mTag to the tag
+ // value in its place.
+ auto old_tag = getTag();
+ delete[] mMsg;
+ mMsg = nullptr;
+
+ mTag = old_tag;
mDropped = true;
return mDroppedCount = value;
}
diff --git a/logd/LogBufferElement.h b/logd/LogBufferElement.h
index 57b0a95..da4991b 100644
--- a/logd/LogBufferElement.h
+++ b/logd/LogBufferElement.h
@@ -41,7 +41,10 @@
const uint32_t mPid;
const uint32_t mTid;
log_time mRealTime;
- char* mMsg;
+ union {
+ char* mMsg; // mDropped == false
+ int32_t mTag; // mDropped == true
+ };
union {
const uint16_t mMsgLen; // mDropped == false
uint16_t mDroppedCount; // mDropped == true
diff --git a/storaged/storaged_info.cpp b/storaged/storaged_info.cpp
index ca2421b..6668cf3 100644
--- a/storaged/storaged_info.cpp
+++ b/storaged/storaged_info.cpp
@@ -41,7 +41,6 @@
using android::hardware::health::V2_0::StorageInfo;
const string emmc_info_t::emmc_sysfs = "/sys/bus/mmc/devices/mmc0:0001/";
-const string emmc_info_t::emmc_debugfs = "/d/mmc0/mmc0:0001/ext_csd";
const char* emmc_info_t::emmc_ver_str[9] = {
"4.0", "4.1", "4.2", "4.3", "Obsolete", "4.41", "4.5", "5.0", "5.1"
};
@@ -62,10 +61,8 @@
if (healthService != nullptr) {
return new health_storage_info_t(healthService);
}
- if (FileExists(emmc_info_t::emmc_sysfs) ||
- FileExists(emmc_info_t::emmc_debugfs)) {
- return new emmc_info_t;
- }
+ if (FileExists(emmc_info_t::emmc_sysfs)) return new emmc_info_t;
+
if (FileExists(ufs_info_t::health_file)) {
return new ufs_info_t;
}
@@ -241,8 +238,7 @@
void emmc_info_t::report()
{
- if (!report_sysfs() && !report_debugfs())
- return;
+ if (!report_sysfs()) return;
publish();
}
@@ -284,54 +280,6 @@
return true;
}
-namespace {
-
-const size_t EXT_CSD_FILE_MIN_SIZE = 1024;
-/* 2 characters in string for each byte */
-const size_t EXT_CSD_REV_IDX = 192 * 2;
-const size_t EXT_PRE_EOL_INFO_IDX = 267 * 2;
-const size_t EXT_DEVICE_LIFE_TIME_EST_A_IDX = 268 * 2;
-const size_t EXT_DEVICE_LIFE_TIME_EST_B_IDX = 269 * 2;
-
-} // namespace
-
-bool emmc_info_t::report_debugfs()
-{
- string buffer;
- uint16_t rev = 0;
-
- if (!ReadFileToString(emmc_debugfs, &buffer) ||
- buffer.length() < (size_t)EXT_CSD_FILE_MIN_SIZE) {
- return false;
- }
-
- string str = buffer.substr(EXT_CSD_REV_IDX, 2);
- if (!ParseUint(str, &rev) ||
- rev < 7 || rev > ARRAY_SIZE(emmc_ver_str)) {
- return false;
- }
-
- version = "emmc ";
- version += emmc_ver_str[rev];
-
- str = buffer.substr(EXT_PRE_EOL_INFO_IDX, 2);
- if (!ParseUint(str, &eol)) {
- return false;
- }
-
- str = buffer.substr(EXT_DEVICE_LIFE_TIME_EST_A_IDX, 2);
- if (!ParseUint(str, &lifetime_a)) {
- return false;
- }
-
- str = buffer.substr(EXT_DEVICE_LIFE_TIME_EST_B_IDX, 2);
- if (!ParseUint(str, &lifetime_b)) {
- return false;
- }
-
- return true;
-}
-
void ufs_info_t::report()
{
string buffer;