1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "components/metrics/serialization/serialization_utils.h" 6 7 #include <sys/file.h> 8 9 #include <string> 10 #include <vector> 11 12 #include "base/files/file_path.h" 13 #include "base/files/file_util.h" 14 #include "base/files/scoped_file.h" 15 #include "base/logging.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/memory/scoped_vector.h" 18 #include "base/strings/string_split.h" 19 #include "base/strings/string_util.h" 20 #include "components/metrics/serialization/metric_sample.h" 21 22 #define READ_WRITE_ALL_FILE_FLAGS \ 23 (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) 24 25 namespace metrics { 26 namespace { 27 28 // Reads the next message from |file_descriptor| into |message|. 29 // 30 // |message| will be set to the empty string if no message could be read (EOF) 31 // or the message was badly constructed. 32 // 33 // Returns false if no message can be read from this file anymore (EOF or 34 // unrecoverable error). 35 bool ReadMessage(int fd, std::string* message) { 36 CHECK(message); 37 38 int result; 39 int32 message_size; 40 // The file containing the metrics do not leave the device so the writer and 41 // the reader will always have the same endianness. 42 result = HANDLE_EINTR(read(fd, &message_size, sizeof(message_size))); 43 if (result < 0) { 44 DPLOG(ERROR) << "reading metrics message header"; 45 return false; 46 } 47 if (result == 0) { 48 // This indicates a normal EOF. 49 return false; 50 } 51 if (result < static_cast<int>(sizeof(message_size))) { 52 DLOG(ERROR) << "bad read size " << result << ", expecting " 53 << sizeof(message_size); 54 return false; 55 } 56 57 // kMessageMaxLength applies to the entire message: the 4-byte 58 // length field and the content. 59 if (message_size > metrics::SerializationUtils::kMessageMaxLength) { 60 DLOG(ERROR) << "message too long : " << message_size; 61 if (HANDLE_EINTR(lseek(fd, message_size - 4, SEEK_CUR)) == -1) { 62 DLOG(ERROR) << "error while skipping message. abort"; 63 return false; 64 } 65 // Badly formatted message was skipped. Treat the badly formatted sample as 66 // an empty sample. 67 message->clear(); 68 return true; 69 } 70 71 message_size -= sizeof(message_size); // The message size includes itself. 72 char buffer[metrics::SerializationUtils::kMessageMaxLength]; 73 if (!base::ReadFromFD(fd, buffer, message_size)) { 74 DPLOG(ERROR) << "reading metrics message body"; 75 return false; 76 } 77 *message = std::string(buffer, message_size); 78 return true; 79 } 80 81 } // namespace 82 83 scoped_ptr<MetricSample> SerializationUtils::ParseSample( 84 const std::string& sample) { 85 if (sample.empty()) 86 return scoped_ptr<MetricSample>(); 87 88 std::vector<std::string> parts; 89 base::SplitString(sample, '\0', &parts); 90 // We should have two null terminated strings so split should produce 91 // three chunks. 92 if (parts.size() != 3) { 93 DLOG(ERROR) << "splitting message on \\0 produced " << parts.size() 94 << " parts (expected 3)"; 95 return scoped_ptr<MetricSample>(); 96 } 97 const std::string& name = parts[0]; 98 const std::string& value = parts[1]; 99 100 if (LowerCaseEqualsASCII(name, "crash")) { 101 return MetricSample::CrashSample(value); 102 } else if (LowerCaseEqualsASCII(name, "histogram")) { 103 return MetricSample::ParseHistogram(value); 104 } else if (LowerCaseEqualsASCII(name, "linearhistogram")) { 105 return MetricSample::ParseLinearHistogram(value); 106 } else if (LowerCaseEqualsASCII(name, "sparsehistogram")) { 107 return MetricSample::ParseSparseHistogram(value); 108 } else if (LowerCaseEqualsASCII(name, "useraction")) { 109 return MetricSample::UserActionSample(value); 110 } else { 111 DLOG(ERROR) << "invalid event type: " << name << ", value: " << value; 112 } 113 return scoped_ptr<MetricSample>(); 114 } 115 116 void SerializationUtils::ReadAndTruncateMetricsFromFile( 117 const std::string& filename, 118 ScopedVector<MetricSample>* metrics) { 119 struct stat stat_buf; 120 int result; 121 122 result = stat(filename.c_str(), &stat_buf); 123 if (result < 0) { 124 if (errno != ENOENT) 125 DPLOG(ERROR) << filename << ": bad metrics file stat"; 126 127 // Nothing to collect---try later. 128 return; 129 } 130 if (stat_buf.st_size == 0) { 131 // Also nothing to collect. 132 return; 133 } 134 base::ScopedFD fd(open(filename.c_str(), O_RDWR)); 135 if (fd.get() < 0) { 136 DPLOG(ERROR) << filename << ": cannot open"; 137 return; 138 } 139 result = flock(fd.get(), LOCK_EX); 140 if (result < 0) { 141 DPLOG(ERROR) << filename << ": cannot lock"; 142 return; 143 } 144 145 // This processes all messages in the log. When all messages are 146 // read and processed, or an error occurs, truncate the file to zero size. 147 for (;;) { 148 std::string message; 149 150 if (!ReadMessage(fd.get(), &message)) 151 break; 152 153 scoped_ptr<MetricSample> sample = ParseSample(message); 154 if (sample) 155 metrics->push_back(sample.release()); 156 } 157 158 result = ftruncate(fd.get(), 0); 159 if (result < 0) 160 DPLOG(ERROR) << "truncate metrics log"; 161 162 result = flock(fd.get(), LOCK_UN); 163 if (result < 0) 164 DPLOG(ERROR) << "unlock metrics log"; 165 } 166 167 bool SerializationUtils::WriteMetricToFile(const MetricSample& sample, 168 const std::string& filename) { 169 if (!sample.IsValid()) 170 return false; 171 172 base::ScopedFD file_descriptor(open(filename.c_str(), 173 O_WRONLY | O_APPEND | O_CREAT, 174 READ_WRITE_ALL_FILE_FLAGS)); 175 176 if (file_descriptor.get() < 0) { 177 DLOG(ERROR) << "error openning the file"; 178 return false; 179 } 180 181 fchmod(file_descriptor.get(), READ_WRITE_ALL_FILE_FLAGS); 182 // Grab a lock to avoid chrome truncating the file 183 // underneath us. Keep the file locked as briefly as possible. 184 // Freeing file_descriptor will close the file and and remove the lock. 185 if (HANDLE_EINTR(flock(file_descriptor.get(), LOCK_EX)) < 0) { 186 DLOG(ERROR) << "error locking" << filename << " : " << errno; 187 return false; 188 } 189 190 std::string msg = sample.ToString(); 191 int32 size = msg.length() + sizeof(int32); 192 if (size > kMessageMaxLength) { 193 DLOG(ERROR) << "cannot write message: too long"; 194 return false; 195 } 196 197 // The file containing the metrics samples will only be read by programs on 198 // the same device so we do not check endianness. 199 if (base::WriteFileDescriptor(file_descriptor.get(), 200 reinterpret_cast<char*>(&size), 201 sizeof(size)) != sizeof(size)) { 202 DLOG(ERROR) << "error writing message length " << errno; 203 return false; 204 } 205 206 if (base::WriteFileDescriptor( 207 file_descriptor.get(), msg.c_str(), msg.length()) != 208 static_cast<int>(msg.length())) { 209 DLOG(ERROR) << "error writing message" << errno; 210 return false; 211 } 212 213 return true; 214 } 215 216 } // namespace metrics 217