1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "utils.h" 18 19 #include <dirent.h> 20 #include <errno.h> 21 #include <fcntl.h> 22 #include <inttypes.h> 23 #include <stdarg.h> 24 #include <stdio.h> 25 #include <sys/stat.h> 26 #include <unistd.h> 27 28 #include <algorithm> 29 #include <map> 30 #include <string> 31 32 #include <android-base/file.h> 33 #include <android-base/logging.h> 34 35 #include <7zCrc.h> 36 #include <Xz.h> 37 #include <XzCrc64.h> 38 39 void OneTimeFreeAllocator::Clear() { 40 for (auto& p : v_) { 41 delete[] p; 42 } 43 v_.clear(); 44 cur_ = nullptr; 45 end_ = nullptr; 46 } 47 48 const char* OneTimeFreeAllocator::AllocateString(const std::string& s) { 49 size_t size = s.size() + 1; 50 if (cur_ + size > end_) { 51 size_t alloc_size = std::max(size, unit_size_); 52 char* p = new char[alloc_size]; 53 v_.push_back(p); 54 cur_ = p; 55 end_ = p + alloc_size; 56 } 57 strcpy(cur_, s.c_str()); 58 const char* result = cur_; 59 cur_ += size; 60 return result; 61 } 62 63 64 FileHelper FileHelper::OpenReadOnly(const std::string& filename) { 65 int fd = TEMP_FAILURE_RETRY(open(filename.c_str(), O_RDONLY | O_BINARY)); 66 return FileHelper(fd); 67 } 68 69 FileHelper FileHelper::OpenWriteOnly(const std::string& filename) { 70 int fd = TEMP_FAILURE_RETRY(open(filename.c_str(), O_WRONLY | O_BINARY | O_CREAT, 0644)); 71 return FileHelper(fd); 72 } 73 74 FileHelper::~FileHelper() { 75 if (fd_ != -1) { 76 close(fd_); 77 } 78 } 79 80 ArchiveHelper::ArchiveHelper(int fd, const std::string& debug_filename) : valid_(false) { 81 int rc = OpenArchiveFd(fd, "", &handle_, false); 82 if (rc == 0) { 83 valid_ = true; 84 } else { 85 LOG(ERROR) << "Failed to open archive " << debug_filename << ": " << ErrorCodeString(rc); 86 } 87 } 88 89 ArchiveHelper::~ArchiveHelper() { 90 if (valid_) { 91 CloseArchive(handle_); 92 } 93 } 94 95 void PrintIndented(size_t indent, const char* fmt, ...) { 96 va_list ap; 97 va_start(ap, fmt); 98 printf("%*s", static_cast<int>(indent * 2), ""); 99 vprintf(fmt, ap); 100 va_end(ap); 101 } 102 103 void FprintIndented(FILE* fp, size_t indent, const char* fmt, ...) { 104 va_list ap; 105 va_start(ap, fmt); 106 fprintf(fp, "%*s", static_cast<int>(indent * 2), ""); 107 vfprintf(fp, fmt, ap); 108 va_end(ap); 109 } 110 111 bool IsPowerOfTwo(uint64_t value) { 112 return (value != 0 && ((value & (value - 1)) == 0)); 113 } 114 115 std::vector<std::string> GetEntriesInDir(const std::string& dirpath) { 116 std::vector<std::string> result; 117 DIR* dir = opendir(dirpath.c_str()); 118 if (dir == nullptr) { 119 PLOG(DEBUG) << "can't open dir " << dirpath; 120 return result; 121 } 122 dirent* entry; 123 while ((entry = readdir(dir)) != nullptr) { 124 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) { 125 continue; 126 } 127 result.push_back(entry->d_name); 128 } 129 closedir(dir); 130 return result; 131 } 132 133 std::vector<std::string> GetSubDirs(const std::string& dirpath) { 134 std::vector<std::string> entries = GetEntriesInDir(dirpath); 135 std::vector<std::string> result; 136 for (size_t i = 0; i < entries.size(); ++i) { 137 if (IsDir(dirpath + "/" + entries[i])) { 138 result.push_back(std::move(entries[i])); 139 } 140 } 141 return result; 142 } 143 144 bool IsDir(const std::string& dirpath) { 145 struct stat st; 146 if (stat(dirpath.c_str(), &st) == 0) { 147 if (S_ISDIR(st.st_mode)) { 148 return true; 149 } 150 } 151 return false; 152 } 153 154 bool IsRegularFile(const std::string& filename) { 155 struct stat st; 156 if (stat(filename.c_str(), &st) == 0) { 157 if (S_ISREG(st.st_mode)) { 158 return true; 159 } 160 } 161 return false; 162 } 163 164 uint64_t GetFileSize(const std::string& filename) { 165 struct stat st; 166 if (stat(filename.c_str(), &st) == 0) { 167 return static_cast<uint64_t>(st.st_size); 168 } 169 return 0; 170 } 171 172 bool MkdirWithParents(const std::string& path) { 173 size_t prev_end = 0; 174 while (prev_end < path.size()) { 175 size_t next_end = path.find('/', prev_end + 1); 176 if (next_end == std::string::npos) { 177 break; 178 } 179 std::string dir_path = path.substr(0, next_end); 180 if (!IsDir(dir_path)) { 181 #if defined(_WIN32) 182 int ret = mkdir(dir_path.c_str()); 183 #else 184 int ret = mkdir(dir_path.c_str(), 0755); 185 #endif 186 if (ret != 0) { 187 PLOG(ERROR) << "failed to create dir " << dir_path; 188 return false; 189 } 190 } 191 prev_end = next_end; 192 } 193 return true; 194 } 195 196 static void* xz_alloc(void*, size_t size) { 197 return malloc(size); 198 } 199 200 static void xz_free(void*, void* address) { 201 free(address); 202 } 203 204 bool XzDecompress(const std::string& compressed_data, std::string* decompressed_data) { 205 ISzAlloc alloc; 206 CXzUnpacker state; 207 alloc.Alloc = xz_alloc; 208 alloc.Free = xz_free; 209 XzUnpacker_Construct(&state, &alloc); 210 CrcGenerateTable(); 211 Crc64GenerateTable(); 212 size_t src_offset = 0; 213 size_t dst_offset = 0; 214 std::string dst(compressed_data.size(), ' '); 215 216 ECoderStatus status = CODER_STATUS_NOT_FINISHED; 217 while (status == CODER_STATUS_NOT_FINISHED) { 218 dst.resize(dst.size() * 2); 219 size_t src_remaining = compressed_data.size() - src_offset; 220 size_t dst_remaining = dst.size() - dst_offset; 221 int res = XzUnpacker_Code(&state, reinterpret_cast<Byte*>(&dst[dst_offset]), &dst_remaining, 222 reinterpret_cast<const Byte*>(&compressed_data[src_offset]), 223 &src_remaining, CODER_FINISH_ANY, &status); 224 if (res != SZ_OK) { 225 LOG(ERROR) << "LZMA decompression failed with error " << res; 226 XzUnpacker_Free(&state); 227 return false; 228 } 229 src_offset += src_remaining; 230 dst_offset += dst_remaining; 231 } 232 XzUnpacker_Free(&state); 233 if (!XzUnpacker_IsStreamWasFinished(&state)) { 234 LOG(ERROR) << "LZMA decompresstion failed due to incomplete stream"; 235 return false; 236 } 237 dst.resize(dst_offset); 238 *decompressed_data = std::move(dst); 239 return true; 240 } 241 242 bool GetLogSeverity(const std::string& name, android::base::LogSeverity* severity) { 243 static std::map<std::string, android::base::LogSeverity> log_severity_map = { 244 {"verbose", android::base::VERBOSE}, 245 {"debug", android::base::DEBUG}, 246 {"info", android::base::INFO}, 247 {"warning", android::base::WARNING}, 248 {"error", android::base::ERROR}, 249 {"fatal", android::base::FATAL}, 250 }; 251 auto it = log_severity_map.find(name); 252 if (it != log_severity_map.end()) { 253 *severity = it->second; 254 return true; 255 } 256 return false; 257 } 258 259 bool IsRoot() { 260 static int is_root = -1; 261 if (is_root == -1) { 262 #if defined(__linux__) 263 is_root = (getuid() == 0) ? 1 : 0; 264 #else 265 is_root = 0; 266 #endif 267 } 268 return is_root == 1; 269 } 270 271 bool ProcessKernelSymbols(std::string& symbol_data, 272 const std::function<bool(const KernelSymbol&)>& callback) { 273 char* p = &symbol_data[0]; 274 char* data_end = p + symbol_data.size(); 275 while (p < data_end) { 276 char* line_end = strchr(p, '\n'); 277 if (line_end != nullptr) { 278 *line_end = '\0'; 279 } 280 size_t line_size = (line_end != nullptr) ? (line_end - p) : (data_end - p); 281 // Parse line like: ffffffffa005c4e4 d __warned.41698 [libsas] 282 char name[line_size]; 283 char module[line_size]; 284 strcpy(module, ""); 285 286 KernelSymbol symbol; 287 int ret = sscanf(p, "%" PRIx64 " %c %s%s", &symbol.addr, &symbol.type, name, module); 288 if (line_end != nullptr) { 289 *line_end = '\n'; 290 p = line_end + 1; 291 } else { 292 p = data_end; 293 } 294 if (ret >= 3) { 295 symbol.name = name; 296 size_t module_len = strlen(module); 297 if (module_len > 2 && module[0] == '[' && module[module_len - 1] == ']') { 298 module[module_len - 1] = '\0'; 299 symbol.module = &module[1]; 300 } else { 301 symbol.module = nullptr; 302 } 303 304 if (callback(symbol)) { 305 return true; 306 } 307 } 308 } 309 return false; 310 } 311 312 size_t GetPageSize() { 313 #if defined(__linux__) 314 return sysconf(_SC_PAGE_SIZE); 315 #else 316 return 4096; 317 #endif 318 } 319 320 uint64_t ConvertBytesToValue(const char* bytes, uint32_t size) { 321 if (size > 8) { 322 LOG(FATAL) << "unexpected size " << size << " in ConvertBytesToValue"; 323 } 324 uint64_t result = 0; 325 int shift = 0; 326 for (uint32_t i = 0; i < size; ++i) { 327 uint64_t tmp = static_cast<unsigned char>(bytes[i]); 328 result |= tmp << shift; 329 shift += 8; 330 } 331 return result; 332 } 333 334 timeval SecondToTimeval(double time_in_sec) { 335 timeval tv; 336 tv.tv_sec = static_cast<time_t>(time_in_sec); 337 tv.tv_usec = static_cast<int>((time_in_sec - tv.tv_sec) * 1000000); 338 return tv; 339 } 340
