simpleperf/record_file_writer.cpp

   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 "record_file.h"
  18
  19 #include <fcntl.h>
  20 #include <string.h>
  21 #include <sys/mman.h>
  22 #include <unistd.h>
  23 #include <set>
  24 #include <string>
  25 #include <vector>
  26
  27 #include <android-base/file.h>
  28 #include <android-base/logging.h>
  29
  30 #include "perf_event.h"
  31 #include "record.h"
  32 #include "utils.h"
  33
  34 using namespace PerfFileFormat;
  35
  36 std::unique_ptr<RecordFileWriter> RecordFileWriter::CreateInstance(const std::string& filename) {
  37   // Remove old perf.data to avoid file ownership problems.
  38   std::string err;
  39   if (!android::base::RemoveFileIfExists(filename, &err)) {
  40     LOG(ERROR) << "failed to remove file " << filename << ": " << err;
  41     return nullptr;
  42   }
  43   FILE* fp = fopen(filename.c_str(), "web+");
  44   if (fp == nullptr) {
  45     PLOG(ERROR) << "failed to open record file '" << filename << "'";
  46     return nullptr;
  47   }
  48
  49   return std::unique_ptr<RecordFileWriter>(new RecordFileWriter(filename, fp));
  50 }
  51
  52 RecordFileWriter::RecordFileWriter(const std::string& filename, FILE* fp)
  53     : filename_(filename),
  54       record_fp_(fp),
  55       attr_section_offset_(0),
  56       attr_section_size_(0),
  57       data_section_offset_(0),
  58       data_section_size_(0),
  59       feature_count_(0),
  60       current_feature_index_(0) {
  61 }
  62
  63 RecordFileWriter::~RecordFileWriter() {
  64   if (record_fp_ != nullptr) {
  65     Close();
  66   }
  67 }
  68
  69 bool RecordFileWriter::WriteAttrSection(const std::vector<AttrWithId>& attr_ids) {
  70   if (attr_ids.empty()) {
  71     return false;
  72   }
  73
  74   // Skip file header part.
  75   if (fseek(record_fp_, sizeof(FileHeader), SEEK_SET) == -1) {
  76     return false;
  77   }
  78
  79   // Write id section.
  80   long id_section_offset = ftell(record_fp_);
  81   if (id_section_offset == -1) {
  82     return false;
  83   }
  84   for (auto& attr_id : attr_ids) {
  85     if (!Write(attr_id.ids.data(), attr_id.ids.size() * sizeof(uint64_t))) {
  86       return false;
  87     }
  88   }
  89
  90   // Write attr section.
  91   long attr_section_offset = ftell(record_fp_);
  92   if (attr_section_offset == -1) {
  93     return false;
  94   }
  95   for (auto& attr_id : attr_ids) {
  96     FileAttr file_attr;
  97     file_attr.attr = *attr_id.attr;
  98     file_attr.ids.offset = id_section_offset;
  99     file_attr.ids.size = attr_id.ids.size() * sizeof(uint64_t);
 100     id_section_offset += file_attr.ids.size;
 101     if (!Write(&file_attr, sizeof(file_attr))) {
 102       return false;
 103     }
 104   }
 105
 106   long data_section_offset = ftell(record_fp_);
 107   if (data_section_offset == -1) {
 108     return false;
 109   }
 110
 111   attr_section_offset_ = attr_section_offset;
 112   attr_section_size_ = data_section_offset - attr_section_offset;
 113   data_section_offset_ = data_section_offset;
 114
 115   // Save event_attr for use when reading records.
 116   event_attr_ = *attr_ids[0].attr;
 117   return true;
 118 }
 119
 120 bool RecordFileWriter::WriteData(const void* buf, size_t len) {
 121   if (!Write(buf, len)) {
 122     return false;
 123   }
 124   data_section_size_ += len;
 125   return true;
 126 }
 127
 128 bool RecordFileWriter::Write(const void* buf, size_t len) {
 129   if (fwrite(buf, len, 1, record_fp_) != 1) {
 130     PLOG(ERROR) << "failed to write to record file '" << filename_ << "'";
 131     return false;
 132   }
 133   return true;
 134 }
 135
 136 bool RecordFileWriter::SeekFileEnd(uint64_t* file_end) {
 137   if (fseek(record_fp_, 0, SEEK_END) == -1) {
 138     PLOG(ERROR) << "fseek() failed";
 139     return false;
 140   }
 141   long offset = ftell(record_fp_);
 142   if (offset == -1) {
 143     PLOG(ERROR) << "ftell() failed";
 144     return false;
 145   }
 146   *file_end = static_cast<uint64_t>(offset);
 147   return true;
 148 }
 149
 150 bool RecordFileWriter::WriteFeatureHeader(size_t feature_count) {
 151   feature_count_ = feature_count;
 152   current_feature_index_ = 0;
 153   uint64_t feature_header_size = feature_count * sizeof(SectionDesc);
 154
 155   // Reserve enough space in the record file for the feature header.
 156   std::vector<unsigned char> zero_data(feature_header_size);
 157   if (fseek(record_fp_, data_section_offset_ + data_section_size_, SEEK_SET) == -1) {
 158     PLOG(ERROR) << "fseek() failed";
 159     return false;
 160   }
 161   return Write(zero_data.data(), zero_data.size());
 162 }
 163
 164 bool RecordFileWriter::WriteBuildIdFeature(const std::vector<BuildIdRecord>& build_id_records) {
 165   uint64_t start_offset;
 166   if (!WriteFeatureBegin(&start_offset)) {
 167     return false;
 168   }
 169   for (auto& record : build_id_records) {
 170     std::vector<char> data = record.BinaryFormat();
 171     if (!Write(data.data(), data.size())) {
 172       return false;
 173     }
 174   }
 175   return WriteFeatureEnd(FEAT_BUILD_ID, start_offset);
 176 }
 177
 178 bool RecordFileWriter::WriteFeatureString(int feature, const std::string& s) {
 179   uint64_t start_offset;
 180   if (!WriteFeatureBegin(&start_offset)) {
 181     return false;
 182   }
 183   uint32_t len = static_cast<uint32_t>(ALIGN(s.size() + 1, 64));
 184   if (!Write(&len, sizeof(len))) {
 185     return false;
 186   }
 187   std::vector<char> v(len, '\0');
 188   std::copy(s.begin(), s.end(), v.begin());
 189   if (!Write(v.data(), v.size())) {
 190     return false;
 191   }
 192   return WriteFeatureEnd(feature, start_offset);
 193 }
 194
 195 bool RecordFileWriter::WriteCmdlineFeature(const std::vector<std::string>& cmdline) {
 196   uint64_t start_offset;
 197   if (!WriteFeatureBegin(&start_offset)) {
 198     return false;
 199   }
 200   uint32_t arg_count = cmdline.size();
 201   if (!Write(&arg_count, sizeof(arg_count))) {
 202     return false;
 203   }
 204   for (auto& arg : cmdline) {
 205     uint32_t len = static_cast<uint32_t>(ALIGN(arg.size() + 1, 64));
 206     if (!Write(&len, sizeof(len))) {
 207       return false;
 208     }
 209     std::vector<char> array(len, '\0');
 210     std::copy(arg.begin(), arg.end(), array.begin());
 211     if (!Write(array.data(), array.size())) {
 212       return false;
 213     }
 214   }
 215   return WriteFeatureEnd(FEAT_CMDLINE, start_offset);
 216 }
 217
 218 bool RecordFileWriter::WriteBranchStackFeature() {
 219   uint64_t start_offset;
 220   if (!WriteFeatureBegin(&start_offset)) {
 221     return false;
 222   }
 223   return WriteFeatureEnd(FEAT_BRANCH_STACK, start_offset);
 224 }
 225
 226 bool RecordFileWriter::WriteFeatureBegin(uint64_t* start_offset) {
 227   CHECK_LT(current_feature_index_, feature_count_);
 228   if (!SeekFileEnd(start_offset)) {
 229     return false;
 230   }
 231   return true;
 232 }
 233
 234 bool RecordFileWriter::WriteFeatureEnd(int feature, uint64_t start_offset) {
 235   uint64_t end_offset;
 236   if (!SeekFileEnd(&end_offset)) {
 237     return false;
 238   }
 239   SectionDesc desc;
 240   desc.offset = start_offset;
 241   desc.size = end_offset - start_offset;
 242   uint64_t feature_offset = data_section_offset_ + data_section_size_;
 243   if (fseek(record_fp_, feature_offset + current_feature_index_ * sizeof(SectionDesc), SEEK_SET) ==
 244       -1) {
 245     PLOG(ERROR) << "fseek() failed";
 246     return false;
 247   }
 248   if (!Write(&desc, sizeof(SectionDesc))) {
 249     return false;
 250   }
 251   ++current_feature_index_;
 252   features_.push_back(feature);
 253   return true;
 254 }
 255
 256 bool RecordFileWriter::WriteFileHeader() {
 257   FileHeader header;
 258   memset(&header, 0, sizeof(header));
 259   memcpy(header.magic, PERF_MAGIC, sizeof(header.magic));
 260   header.header_size = sizeof(header);
 261   header.attr_size = sizeof(FileAttr);
 262   header.attrs.offset = attr_section_offset_;
 263   header.attrs.size = attr_section_size_;
 264   header.data.offset = data_section_offset_;
 265   header.data.size = data_section_size_;
 266   for (auto& feature : features_) {
 267     int i = feature / 8;
 268     int j = feature % 8;
 269     header.features[i] |= (1 << j);
 270   }
 271
 272   if (fseek(record_fp_, 0, SEEK_SET) == -1) {
 273     return false;
 274   }
 275   if (!Write(&header, sizeof(header))) {
 276     return false;
 277   }
 278   return true;
 279 }
 280
 281 bool RecordFileWriter::Close() {
 282   CHECK(record_fp_ != nullptr);
 283   bool result = true;
 284
 285   // Write file header. We gather enough information to write file header only after
 286   // writing data section and feature section.
 287   if (!WriteFileHeader()) {
 288     result = false;
 289   }
 290
 291   if (fclose(record_fp_) != 0) {
 292     PLOG(ERROR) << "failed to close record file '" << filename_ << "'";
 293     result = false;
 294   }
 295   record_fp_ = nullptr;
 296   return result;
 297 }