Gilad Arnold | d7b513d | 2012-05-10 14:25:27 -0700 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Alex Deymo | 759c275 | 2014-03-17 21:09:36 -0700 | [diff] [blame] | 5 | #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_ |
| 6 | #define CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_ |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 7 | |
Andrew de los Reyes | 81ebcd8 | 2010-03-09 15:56:18 -0800 | [diff] [blame] | 8 | #include <algorithm> |
Han Shen | 2643cb7 | 2012-06-26 14:45:33 -0700 | [diff] [blame] | 9 | #include <errno.h> |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 10 | #include <set> |
| 11 | #include <string> |
Han Shen | 2643cb7 | 2012-06-26 14:45:33 -0700 | [diff] [blame] | 12 | #include <unistd.h> |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 13 | #include <vector> |
Darin Petkov | c6c135c | 2010-08-11 13:36:18 -0700 | [diff] [blame] | 14 | |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 15 | #include <base/files/file_path.h> |
Chris Sosa | fc661a1 | 2013-02-26 14:43:21 -0800 | [diff] [blame] | 16 | #include <base/posix/eintr_wrapper.h> |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 17 | #include <base/time/time.h> |
Thieu Le | 5c7d975 | 2010-12-15 16:09:28 -0800 | [diff] [blame] | 18 | #include <ext2fs/ext2fs.h> |
Andrew de los Reyes | c702078 | 2010-04-28 10:46:04 -0700 | [diff] [blame] | 19 | #include <glib.h> |
Jay Srinivasan | f057205 | 2012-10-23 18:12:56 -0700 | [diff] [blame] | 20 | #include "metrics/metrics_library.h" |
Darin Petkov | c6c135c | 2010-08-11 13:36:18 -0700 | [diff] [blame] | 21 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 22 | #include "update_engine/action.h" |
David Zeuthen | b281f07 | 2014-04-02 10:20:19 -0700 | [diff] [blame^] | 23 | #include "update_engine/action_processor.h" |
| 24 | #include "update_engine/connection_manager.h" |
Jay Srinivasan | 19409b7 | 2013-04-12 19:23:36 -0700 | [diff] [blame] | 25 | #include "update_engine/constants.h" |
David Zeuthen | 33bae49 | 2014-02-25 16:16:18 -0800 | [diff] [blame] | 26 | #include "update_engine/metrics.h" |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 27 | |
| 28 | namespace chromeos_update_engine { |
| 29 | |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 30 | class SystemState; |
| 31 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 32 | namespace utils { |
| 33 | |
David Zeuthen | 27a48bc | 2013-08-06 12:06:29 -0700 | [diff] [blame] | 34 | // Converts a struct timespec representing a number of seconds since |
| 35 | // the Unix epoch to a base::Time. Sub-microsecond time is rounded |
| 36 | // down. |
| 37 | base::Time TimeFromStructTimespec(struct timespec *ts); |
| 38 | |
| 39 | // Converts a vector of strings to a NULL-terminated array of |
| 40 | // strings. The resulting array should be freed with g_strfreev() |
| 41 | // when are you done with it. |
| 42 | gchar** StringVectorToGStrv(const std::vector<std::string> &vector); |
| 43 | |
| 44 | // Formats |vector| as a string of the form ["<elem1>", "<elem2>"]. |
| 45 | // Does no escaping, only use this for presentation in error messages. |
| 46 | std::string StringVectorToString(const std::vector<std::string> &vector); |
| 47 | |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 48 | // Calculates the p2p file id from payload hash and size |
| 49 | std::string CalculateP2PFileId(const std::string& payload_hash, |
| 50 | size_t payload_size); |
| 51 | |
J. Richard Barnette | 63137e5 | 2013-10-28 10:57:29 -0700 | [diff] [blame] | 52 | // Parse the firmware version from one line of output from the |
| 53 | // "mosys" command. |
| 54 | std::string ParseECVersion(std::string input_line); |
| 55 | |
J. Richard Barnette | 3084293 | 2013-10-28 15:04:23 -0700 | [diff] [blame] | 56 | // Given the name of the block device of a boot partition, return the |
| 57 | // name of the associated kernel partition (e.g. given "/dev/sda3", |
| 58 | // return "/dev/sda2"). |
| 59 | const std::string KernelDeviceOfBootDevice(const std::string& boot_device); |
| 60 | |
Andrew de los Reyes | 970bb28 | 2009-12-09 16:34:04 -0800 | [diff] [blame] | 61 | // Writes the data passed to path. The file at path will be overwritten if it |
| 62 | // exists. Returns true on success, false otherwise. |
| 63 | bool WriteFile(const char* path, const char* data, int data_len); |
| 64 | |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 65 | // Calls write() or pwrite() repeatedly until all count bytes at buf are |
| 66 | // written to fd or an error occurs. Returns true on success. |
| 67 | bool WriteAll(int fd, const void* buf, size_t count); |
| 68 | bool PWriteAll(int fd, const void* buf, size_t count, off_t offset); |
| 69 | |
| 70 | // Calls pread() repeatedly until count bytes are read, or EOF is reached. |
| 71 | // Returns number of bytes read in *bytes_read. Returns true on success. |
| 72 | bool PReadAll(int fd, void* buf, size_t count, off_t offset, |
| 73 | ssize_t* out_bytes_read); |
Andrew de los Reyes | b10320d | 2010-03-31 16:44:44 -0700 | [diff] [blame] | 74 | |
Gilad Arnold | 19a45f0 | 2012-07-19 12:36:10 -0700 | [diff] [blame] | 75 | // Opens |path| for reading and appends its entire content to the container |
| 76 | // pointed to by |out_p|. Returns true upon successfully reading all of the |
| 77 | // file's content, false otherwise, in which case the state of the output |
Darin Petkov | 8e447e0 | 2013-04-16 16:23:50 +0200 | [diff] [blame] | 78 | // container is unknown. ReadFileChunk starts reading the file from |offset|; if |
| 79 | // |size| is not -1, only up to |size| bytes are read in. |
Gilad Arnold | 19a45f0 | 2012-07-19 12:36:10 -0700 | [diff] [blame] | 80 | bool ReadFile(const std::string& path, std::vector<char>* out_p); |
| 81 | bool ReadFile(const std::string& path, std::string* out_p); |
Darin Petkov | 8e447e0 | 2013-04-16 16:23:50 +0200 | [diff] [blame] | 82 | bool ReadFileChunk(const std::string& path, off_t offset, off_t size, |
| 83 | std::vector<char>* out_p); |
Gilad Arnold | 19a45f0 | 2012-07-19 12:36:10 -0700 | [diff] [blame] | 84 | |
| 85 | // Invokes |cmd| in a pipe and appends its stdout to the container pointed to by |
| 86 | // |out_p|. Returns true upon successfully reading all of the output, false |
| 87 | // otherwise, in which case the state of the output container is unknown. |
| 88 | bool ReadPipe(const std::string& cmd, std::vector<char>* out_p); |
| 89 | bool ReadPipe(const std::string& cmd, std::string* out_p); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 90 | |
Andrew de los Reyes | f4c7ef1 | 2010-04-30 10:37:00 -0700 | [diff] [blame] | 91 | // Returns the size of the file at path. If the file doesn't exist or some |
| 92 | // error occurrs, -1 is returned. |
| 93 | off_t FileSize(const std::string& path); |
| 94 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 95 | std::string ErrnoNumberAsString(int err); |
| 96 | |
| 97 | // Strips duplicate slashes, and optionally removes all trailing slashes. |
| 98 | // Does not compact /./ or /../. |
| 99 | std::string NormalizePath(const std::string& path, bool strip_trailing_slash); |
| 100 | |
| 101 | // Returns true if the file exists for sure. Returns false if it doesn't exist, |
| 102 | // or an error occurs. |
| 103 | bool FileExists(const char* path); |
| 104 | |
Darin Petkov | 30291ed | 2010-11-12 10:23:06 -0800 | [diff] [blame] | 105 | // Returns true if |path| exists and is a symbolic link. |
| 106 | bool IsSymlink(const char* path); |
| 107 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 108 | // The last 6 chars of path must be XXXXXX. They will be randomly changed |
| 109 | // and a non-existent path will be returned. Intentionally makes a copy |
| 110 | // of the string passed in. |
| 111 | // NEVER CALL THIS FUNCTION UNLESS YOU ARE SURE |
| 112 | // THAT YOUR PROCESS WILL BE THE ONLY THING WRITING FILES IN THIS DIRECTORY. |
Andrew de los Reyes | 4fe15d0 | 2009-12-10 19:01:36 -0800 | [diff] [blame] | 113 | std::string TempFilename(std::string path); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 114 | |
Gilad Arnold | d04f8e2 | 2014-01-09 13:13:40 -0800 | [diff] [blame] | 115 | // If |base_filename_template| is neither absolute (starts with "/") nor |
| 116 | // explicitly relative to the current working directory (starts with "./" or |
| 117 | // "../"), then it is prepended the value of TMPDIR, which defaults to /tmp if |
| 118 | // it isn't set or is empty. It then calls mkstemp(3) with the resulting |
| 119 | // template. Writes the name of a new temporary file to |filename|. If |fd| is |
| 120 | // non-NULL, the file descriptor returned by mkstemp is written to it and kept |
| 121 | // open; otherwise, it is closed. The template must end with "XXXXXX". Returns |
| 122 | // true on success. |
| 123 | bool MakeTempFile(const std::string& base_filename_template, |
Andrew de los Reyes | b10320d | 2010-03-31 16:44:44 -0700 | [diff] [blame] | 124 | std::string* filename, |
| 125 | int* fd); |
| 126 | |
Gilad Arnold | d04f8e2 | 2014-01-09 13:13:40 -0800 | [diff] [blame] | 127 | // If |base_filename_template| is neither absolute (starts with "/") nor |
| 128 | // explicitly relative to the current working directory (starts with "./" or |
| 129 | // "../"), then it is prepended the value of TMPDIR, which defaults to /tmp if |
| 130 | // it isn't set or is empty. It then calls mkdtemp() with the resulting |
| 131 | // template. Writes the name of the new temporary directory to |dirname|. |
| 132 | // The template must end with "XXXXXX". Returns true on success. |
| 133 | bool MakeTempDirectory(const std::string& base_dirname_template, |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 134 | std::string* dirname); |
| 135 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 136 | // Deletes a directory and all its contents synchronously. Returns true |
| 137 | // on success. This may be called with a regular file--it will just unlink it. |
| 138 | // This WILL cross filesystem boundaries. |
| 139 | bool RecursiveUnlinkDir(const std::string& path); |
| 140 | |
Alex Vakulenko | 4f5b144 | 2014-02-21 12:19:44 -0800 | [diff] [blame] | 141 | // Returns the disk device name for a partition. For example, |
| 142 | // GetDiskName("/dev/sda3") returns "/dev/sda". Returns an empty string |
| 143 | // if the input device is not of the "/dev/xyz#" form. |
| 144 | std::string GetDiskName(const std::string& partition_name); |
Andrew de los Reyes | f971443 | 2010-05-04 10:21:23 -0700 | [diff] [blame] | 145 | |
Alex Vakulenko | 4f5b144 | 2014-02-21 12:19:44 -0800 | [diff] [blame] | 146 | // Returns the partition number, of partition device name. For example, |
| 147 | // GetPartitionNumber("/dev/sda3") returns 3. |
| 148 | // Returns 0 on failure |
| 149 | int GetPartitionNumber(const std::string& partition_name); |
| 150 | |
| 151 | // Splits the partition device name into the block device name and partition |
| 152 | // number. For example, "/dev/sda3" will be split into {"/dev/sda", 3} and |
| 153 | // "/dev/mmcblk0p2" into {"/dev/mmcblk0", 2} |
| 154 | // Returns false when malformed device name is passed in. |
| 155 | // If both output parameters are omitted (nullptr), can be used |
| 156 | // just to test the validity of the device name. Note that the function |
| 157 | // simply checks if the device name looks like a valid device, no other |
| 158 | // checks are performed (i.e. it doesn't check if the device actually exists). |
| 159 | bool SplitPartitionName(const std::string& partition_name, |
| 160 | std::string* out_disk_name, |
| 161 | int* out_partition_num); |
| 162 | |
| 163 | // Builds a partition device name from the block device name and partition |
| 164 | // number. For example: |
| 165 | // {"/dev/sda", 1} => "/dev/sda1" |
| 166 | // {"/dev/mmcblk2", 12} => "/dev/mmcblk2p12" |
| 167 | // Returns empty string when invalid parameters are passed in |
| 168 | std::string MakePartitionName(const std::string& disk_name, |
| 169 | int partition_num); |
Andrew de los Reyes | f971443 | 2010-05-04 10:21:23 -0700 | [diff] [blame] | 170 | |
Darin Petkov | f74eb65 | 2010-08-04 12:08:38 -0700 | [diff] [blame] | 171 | // Returns the sysfs block device for a root block device. For |
| 172 | // example, SysfsBlockDevice("/dev/sda") returns |
| 173 | // "/sys/block/sda". Returns an empty string if the input device is |
| 174 | // not of the "/dev/xyz" form. |
| 175 | std::string SysfsBlockDevice(const std::string& device); |
| 176 | |
| 177 | // Returns true if the root |device| (e.g., "/dev/sdb") is known to be |
| 178 | // removable, false otherwise. |
| 179 | bool IsRemovableDevice(const std::string& device); |
| 180 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 181 | // Synchronously mount or unmount a filesystem. Return true on success. |
| 182 | // Mounts as ext3 with default options. |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 183 | bool MountFilesystem(const std::string& device, const std::string& mountpoint, |
| 184 | unsigned long flags); |
Andrew de los Reyes | 4fe15d0 | 2009-12-10 19:01:36 -0800 | [diff] [blame] | 185 | bool UnmountFilesystem(const std::string& mountpoint); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 186 | |
Darin Petkov | d3f8c89 | 2010-10-12 21:38:45 -0700 | [diff] [blame] | 187 | // Returns the block count and the block byte size of the ext3 file system on |
| 188 | // |device| (which may be a real device or a path to a filesystem image) or on |
| 189 | // an opened file descriptor |fd|. The actual file-system size is |block_count| |
| 190 | // * |block_size| bytes. Returns true on success, false otherwise. |
| 191 | bool GetFilesystemSize(const std::string& device, |
| 192 | int* out_block_count, |
| 193 | int* out_block_size); |
| 194 | bool GetFilesystemSizeFromFD(int fd, |
| 195 | int* out_block_count, |
| 196 | int* out_block_size); |
| 197 | |
Alex Deymo | 032e772 | 2014-03-25 17:53:56 -0700 | [diff] [blame] | 198 | |
| 199 | // Returns a human-readable string with the file format based on magic constants |
| 200 | // on the header of the file. |
| 201 | std::string GetFileFormat(const std::string& path); |
| 202 | |
Jay Srinivasan | 480ddfa | 2012-06-01 19:15:26 -0700 | [diff] [blame] | 203 | // Returns the string representation of the given UTC time. |
| 204 | // such as "11/14/2011 14:05:30 GMT". |
| 205 | std::string ToString(const base::Time utc_time); |
| 206 | |
Jay Srinivasan | ae4697c | 2013-03-18 17:08:08 -0700 | [diff] [blame] | 207 | // Returns true or false depending on the value of b. |
| 208 | std::string ToString(bool b); |
| 209 | |
Jay Srinivasan | 19409b7 | 2013-04-12 19:23:36 -0700 | [diff] [blame] | 210 | // Returns a string representation of the given enum. |
| 211 | std::string ToString(DownloadSource source); |
| 212 | |
Alex Deymo | 1c656c4 | 2013-06-28 11:02:14 -0700 | [diff] [blame] | 213 | // Returns a string representation of the given enum. |
| 214 | std::string ToString(PayloadType payload_type); |
| 215 | |
Andrew de los Reyes | f971443 | 2010-05-04 10:21:23 -0700 | [diff] [blame] | 216 | enum BootLoader { |
| 217 | BootLoader_SYSLINUX = 0, |
| 218 | BootLoader_CHROME_FIRMWARE = 1 |
| 219 | }; |
| 220 | // Detects which bootloader this system uses and returns it via the out |
| 221 | // param. Returns true on success. |
| 222 | bool GetBootloader(BootLoader* out_bootloader); |
| 223 | |
Darin Petkov | a0b9e77 | 2011-10-06 05:05:56 -0700 | [diff] [blame] | 224 | // Returns the error message, if any, from a GError pointer. Frees the GError |
| 225 | // object and resets error to NULL. |
| 226 | std::string GetAndFreeGError(GError** error); |
Andrew de los Reyes | c702078 | 2010-04-28 10:46:04 -0700 | [diff] [blame] | 227 | |
Darin Petkov | 296889c | 2010-07-23 16:20:54 -0700 | [diff] [blame] | 228 | // Initiates a system reboot. Returns true on success, false otherwise. |
| 229 | bool Reboot(); |
| 230 | |
Andrew de los Reyes | 712b3ac | 2011-01-07 13:47:52 -0800 | [diff] [blame] | 231 | // Schedules a Main Loop callback to trigger the crash reporter to perform an |
| 232 | // upload as if this process had crashed. |
| 233 | void ScheduleCrashReporterUpload(); |
| 234 | |
Darin Petkov | 5c0a8af | 2010-08-24 13:39:13 -0700 | [diff] [blame] | 235 | // Fuzzes an integer |value| randomly in the range: |
| 236 | // [value - range / 2, value + range - range / 2] |
| 237 | int FuzzInt(int value, unsigned int range); |
| 238 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 239 | // Log a string in hex to LOG(INFO). Useful for debugging. |
| 240 | void HexDumpArray(const unsigned char* const arr, const size_t length); |
| 241 | inline void HexDumpString(const std::string& str) { |
| 242 | HexDumpArray(reinterpret_cast<const unsigned char*>(str.data()), str.size()); |
| 243 | } |
| 244 | inline void HexDumpVector(const std::vector<char>& vect) { |
| 245 | HexDumpArray(reinterpret_cast<const unsigned char*>(&vect[0]), vect.size()); |
| 246 | } |
| 247 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 248 | bool StringHasSuffix(const std::string& str, const std::string& suffix); |
| 249 | bool StringHasPrefix(const std::string& str, const std::string& prefix); |
| 250 | |
| 251 | template<typename KeyType, typename ValueType> |
| 252 | bool MapContainsKey(const std::map<KeyType, ValueType>& m, const KeyType& k) { |
| 253 | return m.find(k) != m.end(); |
| 254 | } |
Andrew de los Reyes | 4fe15d0 | 2009-12-10 19:01:36 -0800 | [diff] [blame] | 255 | template<typename KeyType> |
| 256 | bool SetContainsKey(const std::set<KeyType>& s, const KeyType& k) { |
| 257 | return s.find(k) != s.end(); |
| 258 | } |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 259 | |
| 260 | template<typename ValueType> |
| 261 | std::set<ValueType> SetWithValue(const ValueType& value) { |
| 262 | std::set<ValueType> ret; |
| 263 | ret.insert(value); |
| 264 | return ret; |
| 265 | } |
| 266 | |
Andrew de los Reyes | 0ce161b | 2010-02-22 15:27:01 -0800 | [diff] [blame] | 267 | template<typename T> |
| 268 | bool VectorContainsValue(const std::vector<T>& vect, const T& value) { |
Darin Petkov | c1a8b42 | 2010-07-19 11:34:49 -0700 | [diff] [blame] | 269 | return std::find(vect.begin(), vect.end(), value) != vect.end(); |
Andrew de los Reyes | 0ce161b | 2010-02-22 15:27:01 -0800 | [diff] [blame] | 270 | } |
| 271 | |
Andrew de los Reyes | b10320d | 2010-03-31 16:44:44 -0700 | [diff] [blame] | 272 | template<typename T> |
| 273 | bool VectorIndexOf(const std::vector<T>& vect, const T& value, |
| 274 | typename std::vector<T>::size_type* out_index) { |
| 275 | typename std::vector<T>::const_iterator it = std::find(vect.begin(), |
| 276 | vect.end(), |
| 277 | value); |
| 278 | if (it == vect.end()) { |
| 279 | return false; |
| 280 | } else { |
| 281 | *out_index = it - vect.begin(); |
| 282 | return true; |
| 283 | } |
| 284 | } |
| 285 | |
Andrew de los Reyes | cc92cd3 | 2010-10-05 16:56:14 -0700 | [diff] [blame] | 286 | template<typename ValueType> |
| 287 | void ApplyMap(std::vector<ValueType>* collection, |
| 288 | const std::map<ValueType, ValueType>& the_map) { |
| 289 | for (typename std::vector<ValueType>::iterator it = collection->begin(); |
| 290 | it != collection->end(); ++it) { |
| 291 | typename std::map<ValueType, ValueType>::const_iterator map_it = |
| 292 | the_map.find(*it); |
| 293 | if (map_it != the_map.end()) { |
| 294 | *it = map_it->second; |
| 295 | } |
| 296 | } |
| 297 | } |
| 298 | |
Chris Sosa | 4f8ee27 | 2012-11-30 13:01:54 -0800 | [diff] [blame] | 299 | // Cgroups cpu shares constants. 1024 is the default shares a standard process |
| 300 | // gets and 2 is the minimum value. We set High as a value that gives the |
| 301 | // update-engine 2x the cpu share of a standard process. |
| 302 | enum CpuShares { |
| 303 | kCpuSharesHigh = 2048, |
| 304 | kCpuSharesNormal = 1024, |
| 305 | kCpuSharesLow = 2, |
Darin Petkov | c6c135c | 2010-08-11 13:36:18 -0700 | [diff] [blame] | 306 | }; |
| 307 | |
Chris Sosa | 4f8ee27 | 2012-11-30 13:01:54 -0800 | [diff] [blame] | 308 | // Compares cpu shares and returns an integer that is less |
| 309 | // than, equal to or greater than 0 if |shares_lhs| is, |
| 310 | // respectively, lower than, same as or higher than |shares_rhs|. |
| 311 | int CompareCpuShares(CpuShares shares_lhs, |
| 312 | CpuShares shares_rhs); |
Darin Petkov | c6c135c | 2010-08-11 13:36:18 -0700 | [diff] [blame] | 313 | |
Chris Sosa | 4f8ee27 | 2012-11-30 13:01:54 -0800 | [diff] [blame] | 314 | // Sets the current process shares to |shares|. Returns true on |
Darin Petkov | c6c135c | 2010-08-11 13:36:18 -0700 | [diff] [blame] | 315 | // success, false otherwise. |
Chris Sosa | 4f8ee27 | 2012-11-30 13:01:54 -0800 | [diff] [blame] | 316 | bool SetCpuShares(CpuShares shares); |
Andrew de los Reyes | f918517 | 2010-05-03 11:07:05 -0700 | [diff] [blame] | 317 | |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 318 | // Assumes data points to a Closure. Runs it and returns FALSE; |
| 319 | gboolean GlibRunClosure(gpointer data); |
| 320 | |
Gilad Arnold | d7b513d | 2012-05-10 14:25:27 -0700 | [diff] [blame] | 321 | // Converts seconds into human readable notation including days, hours, minutes |
| 322 | // and seconds. For example, 185 will yield 3m5s, 4300 will yield 1h11m40s, and |
| 323 | // 360000 will yield 4d4h0m0s. Zero padding not applied. Seconds are always |
| 324 | // shown in the result. |
| 325 | std::string FormatSecs(unsigned secs); |
| 326 | |
| 327 | // Converts a TimeDelta into human readable notation including days, hours, |
| 328 | // minutes, seconds and fractions of a second down to microsecond granularity, |
| 329 | // as necessary; for example, an output of 5d2h0m15.053s means that the input |
| 330 | // time was precise to the milliseconds only. Zero padding not applied, except |
| 331 | // for fractions. Seconds are always shown, but fractions thereof are only shown |
| 332 | // when applicable. |
| 333 | std::string FormatTimeDelta(base::TimeDelta delta); |
Gilad Arnold | 1ebd813 | 2012-03-05 10:19:29 -0800 | [diff] [blame] | 334 | |
Jay Srinivasan | 2b5a0f0 | 2012-12-19 17:25:56 -0800 | [diff] [blame] | 335 | // This method transforms the given error code to be suitable for UMA and |
| 336 | // for error classification purposes by removing the higher order bits and |
| 337 | // aggregating error codes beyond the enum range, etc. This method is |
| 338 | // idempotent, i.e. if called with a value previously returned by this method, |
| 339 | // it'll return the same value again. |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 340 | ErrorCode GetBaseErrorCode(ErrorCode code); |
Jay Srinivasan | 2b5a0f0 | 2012-12-19 17:25:56 -0800 | [diff] [blame] | 341 | |
David Zeuthen | 33bae49 | 2014-02-25 16:16:18 -0800 | [diff] [blame] | 342 | // Transforms a ErrorCode value into a metrics::DownloadErrorCode. |
| 343 | // This obviously only works for errors related to downloading so if |code| |
| 344 | // is e.g. |kErrorCodeFilesystemCopierError| then |
| 345 | // |kDownloadErrorCodeInputMalformed| is returned. |
| 346 | metrics::DownloadErrorCode GetDownloadErrorCode(ErrorCode code); |
| 347 | |
| 348 | // Transforms a ErrorCode value into a metrics::AttemptResult. |
| 349 | // |
| 350 | // If metrics::AttemptResult::kPayloadDownloadError is returned, you |
| 351 | // can use utils::GetDownloadError() to get more detail. |
| 352 | metrics::AttemptResult GetAttemptResult(ErrorCode code); |
| 353 | |
David Zeuthen | b281f07 | 2014-04-02 10:20:19 -0700 | [diff] [blame^] | 354 | // Calculates the internet connection type given |type| and |tethering|. |
| 355 | metrics::ConnectionType GetConnectionType(NetworkConnectionType type, |
| 356 | NetworkTethering tethering); |
| 357 | |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 358 | // Sends the error code to UMA using the metrics interface object in the given |
| 359 | // system state. It also uses the system state to determine the right UMA |
| 360 | // bucket for the error code. |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 361 | void SendErrorCodeToUma(SystemState* system_state, ErrorCode code); |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 362 | |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 363 | // Returns a string representation of the ErrorCodes (either the base |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 364 | // error codes or the bit flags) for logging purposes. |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 365 | std::string CodeToString(ErrorCode code); |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 366 | |
Gilad Arnold | 30dedd8 | 2013-07-03 06:19:09 -0700 | [diff] [blame] | 367 | // Creates the powerwash marker file with the appropriate commands in it. Uses |
| 368 | // |file_path| as the path to the marker file if non-NULL, otherwise uses the |
| 369 | // global default. Returns true if successfully created. False otherwise. |
| 370 | bool CreatePowerwashMarkerFile(const char* file_path); |
Jay Srinivasan | 1c0fe79 | 2013-03-28 16:45:25 -0700 | [diff] [blame] | 371 | |
Gilad Arnold | 30dedd8 | 2013-07-03 06:19:09 -0700 | [diff] [blame] | 372 | // Deletes the marker file used to trigger Powerwash using clobber-state. Uses |
| 373 | // |file_path| as the path to the marker file if non-NULL, otherwise uses the |
| 374 | // global default. Returns true if successfully deleted. False otherwise. |
| 375 | bool DeletePowerwashMarkerFile(const char* file_path); |
Jay Srinivasan | 1c0fe79 | 2013-03-28 16:45:25 -0700 | [diff] [blame] | 376 | |
Chris Sosa | d317e40 | 2013-06-12 13:47:09 -0700 | [diff] [blame] | 377 | // Assumes you want to install on the "other" device, where the other |
| 378 | // device is what you get if you swap 1 for 2 or 3 for 4 or vice versa |
| 379 | // for the number at the end of the boot device. E.g., /dev/sda1 -> /dev/sda2 |
| 380 | // or /dev/sda4 -> /dev/sda3. See |
| 381 | // http://www.chromium.org/chromium-os/chromiumos-design-docs/disk-format |
| 382 | bool GetInstallDev(const std::string& boot_dev, std::string* install_dev); |
| 383 | |
David Zeuthen | 910ec5b | 2013-09-26 12:10:58 -0700 | [diff] [blame] | 384 | // Checks if xattr is supported in the directory specified by |
| 385 | // |dir_path| which must be writable. Returns true if the feature is |
| 386 | // supported, false if not or if an error occured. |
| 387 | bool IsXAttrSupported(const base::FilePath& dir_path); |
| 388 | |
David Zeuthen | e7f8917 | 2013-10-31 10:21:04 -0700 | [diff] [blame] | 389 | // Decodes the data in |base64_encoded| and stores it in a temporary |
| 390 | // file. Returns false if the given data is empty, not well-formed |
| 391 | // base64 or if an error occurred. If true is returned, the decoded |
| 392 | // data is stored in the file returned in |out_path|. The file should |
| 393 | // be deleted when no longer needed. |
| 394 | bool DecodeAndStoreBase64String(const std::string& base64_encoded, |
| 395 | base::FilePath *out_path); |
| 396 | |
David Zeuthen | 639aa36 | 2014-02-03 16:23:44 -0800 | [diff] [blame] | 397 | // Converts |time| to an Omaha InstallDate which is defined as "the |
| 398 | // number of PST8PDT calendar weeks since Jan 1st 2007 0:00 PST, times |
| 399 | // seven" with PST8PDT defined as "Pacific Time" (e.g. UTC-07:00 if |
| 400 | // daylight savings is observed and UTC-08:00 otherwise.) |
| 401 | // |
| 402 | // If the passed in |time| variable is before Monday January 1st 2007 |
| 403 | // 0:00 PST, False is returned and the value returned in |
| 404 | // |out_num_days| is undefined. Otherwise the number of PST8PDT |
| 405 | // calendar weeks since that date times seven is returned in |
| 406 | // |out_num_days| and the function returns True. |
| 407 | // |
| 408 | // (NOTE: This function does not currently take daylight savings time |
| 409 | // into account so the result may up to one hour off. This is because |
| 410 | // the glibc date and timezone routines depend on the TZ environment |
| 411 | // variable and changing environment variables is not thread-safe. An |
| 412 | // alternative, thread-safe API to use would be GDateTime/GTimeZone |
| 413 | // available in GLib 2.26 or later.) |
| 414 | bool ConvertToOmahaInstallDate(base::Time time, int *out_num_days); |
| 415 | |
David Zeuthen | 33bae49 | 2014-02-25 16:16:18 -0800 | [diff] [blame] | 416 | // This function returns the duration on the wallclock since the last |
| 417 | // time it was called for the same |state_variable_key| value. |
| 418 | // |
| 419 | // If the function returns |true|, the duration (always non-negative) |
| 420 | // is returned in |out_duration|. If the function returns |false| |
| 421 | // something went wrong or there was no previous measurement. |
| 422 | bool WallclockDurationHelper(SystemState* system_state, |
| 423 | const std::string& state_variable_key, |
| 424 | base::TimeDelta* out_duration); |
| 425 | |
| 426 | // This function returns the duration on the monotonic clock since the |
| 427 | // last time it was called for the same |storage| pointer. |
| 428 | // |
| 429 | // You should pass a pointer to a 64-bit integer in |storage| which |
| 430 | // should be initialized to 0. |
| 431 | // |
| 432 | // If the function returns |true|, the duration (always non-negative) |
| 433 | // is returned in |out_duration|. If the function returns |false| |
| 434 | // something went wrong or there was no previous measurement. |
| 435 | bool MonotonicDurationHelper(SystemState* system_state, |
| 436 | int64_t* storage, |
| 437 | base::TimeDelta* out_duration); |
| 438 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 439 | } // namespace utils |
| 440 | |
Jay Srinivasan | 08fce04 | 2012-06-07 16:31:01 -0700 | [diff] [blame] | 441 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 442 | // Class to unmount FS when object goes out of scope |
| 443 | class ScopedFilesystemUnmounter { |
| 444 | public: |
| 445 | explicit ScopedFilesystemUnmounter(const std::string& mountpoint) |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 446 | : mountpoint_(mountpoint), |
| 447 | should_unmount_(true) {} |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 448 | ~ScopedFilesystemUnmounter() { |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 449 | if (should_unmount_) { |
| 450 | utils::UnmountFilesystem(mountpoint_); |
| 451 | } |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 452 | } |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 453 | void set_should_unmount(bool unmount) { should_unmount_ = unmount; } |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 454 | private: |
| 455 | const std::string mountpoint_; |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 456 | bool should_unmount_; |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 457 | DISALLOW_COPY_AND_ASSIGN(ScopedFilesystemUnmounter); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 458 | }; |
| 459 | |
| 460 | // Utility class to close a file descriptor |
| 461 | class ScopedFdCloser { |
| 462 | public: |
| 463 | explicit ScopedFdCloser(int* fd) : fd_(fd), should_close_(true) {} |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 464 | ~ScopedFdCloser() { |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 465 | if (should_close_ && fd_ && (*fd_ >= 0)) { |
Gilad Arnold | f960911 | 2012-02-29 11:38:47 -0800 | [diff] [blame] | 466 | if (!close(*fd_)) |
| 467 | *fd_ = -1; |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 468 | } |
| 469 | } |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 470 | void set_should_close(bool should_close) { should_close_ = should_close; } |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 471 | private: |
| 472 | int* fd_; |
| 473 | bool should_close_; |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 474 | DISALLOW_COPY_AND_ASSIGN(ScopedFdCloser); |
| 475 | }; |
| 476 | |
Gilad Arnold | f960911 | 2012-02-29 11:38:47 -0800 | [diff] [blame] | 477 | // An EINTR-immune file descriptor closer. |
| 478 | class ScopedEintrSafeFdCloser { |
| 479 | public: |
| 480 | explicit ScopedEintrSafeFdCloser(int* fd) : fd_(fd), should_close_(true) {} |
| 481 | ~ScopedEintrSafeFdCloser() { |
| 482 | if (should_close_ && fd_ && (*fd_ >= 0)) { |
| 483 | if (!HANDLE_EINTR(close(*fd_))) |
| 484 | *fd_ = -1; |
| 485 | } |
| 486 | } |
| 487 | void set_should_close(bool should_close) { should_close_ = should_close; } |
| 488 | private: |
| 489 | int* fd_; |
| 490 | bool should_close_; |
| 491 | DISALLOW_COPY_AND_ASSIGN(ScopedEintrSafeFdCloser); |
| 492 | }; |
| 493 | |
Thieu Le | 5c7d975 | 2010-12-15 16:09:28 -0800 | [diff] [blame] | 494 | // Utility class to close a file system |
| 495 | class ScopedExt2fsCloser { |
| 496 | public: |
| 497 | explicit ScopedExt2fsCloser(ext2_filsys filsys) : filsys_(filsys) {} |
| 498 | ~ScopedExt2fsCloser() { ext2fs_close(filsys_); } |
| 499 | |
| 500 | private: |
| 501 | ext2_filsys filsys_; |
| 502 | DISALLOW_COPY_AND_ASSIGN(ScopedExt2fsCloser); |
| 503 | }; |
| 504 | |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 505 | // Utility class to delete a file when it goes out of scope. |
| 506 | class ScopedPathUnlinker { |
| 507 | public: |
Darin Petkov | 52dcaeb | 2011-01-14 15:33:06 -0800 | [diff] [blame] | 508 | explicit ScopedPathUnlinker(const std::string& path) |
| 509 | : path_(path), |
| 510 | should_remove_(true) {} |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 511 | ~ScopedPathUnlinker() { |
Darin Petkov | 52dcaeb | 2011-01-14 15:33:06 -0800 | [diff] [blame] | 512 | if (should_remove_ && unlink(path_.c_str()) < 0) { |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 513 | std::string err_message = strerror(errno); |
| 514 | LOG(ERROR) << "Unable to unlink path " << path_ << ": " << err_message; |
| 515 | } |
| 516 | } |
Darin Petkov | 52dcaeb | 2011-01-14 15:33:06 -0800 | [diff] [blame] | 517 | void set_should_remove(bool should_remove) { should_remove_ = should_remove; } |
| 518 | |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 519 | private: |
| 520 | const std::string path_; |
Darin Petkov | 52dcaeb | 2011-01-14 15:33:06 -0800 | [diff] [blame] | 521 | bool should_remove_; |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 522 | DISALLOW_COPY_AND_ASSIGN(ScopedPathUnlinker); |
| 523 | }; |
| 524 | |
| 525 | // Utility class to delete an empty directory when it goes out of scope. |
| 526 | class ScopedDirRemover { |
| 527 | public: |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 528 | explicit ScopedDirRemover(const std::string& path) |
| 529 | : path_(path), |
| 530 | should_remove_(true) {} |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 531 | ~ScopedDirRemover() { |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 532 | if (should_remove_ && (rmdir(path_.c_str()) < 0)) { |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 533 | PLOG(ERROR) << "Unable to remove dir " << path_; |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 534 | } |
| 535 | } |
| 536 | void set_should_remove(bool should_remove) { should_remove_ = should_remove; } |
| 537 | |
| 538 | protected: |
| 539 | const std::string path_; |
| 540 | |
| 541 | private: |
| 542 | bool should_remove_; |
| 543 | DISALLOW_COPY_AND_ASSIGN(ScopedDirRemover); |
| 544 | }; |
| 545 | |
| 546 | // Utility class to unmount a filesystem mounted on a temporary directory and |
| 547 | // delete the temporary directory when it goes out of scope. |
| 548 | class ScopedTempUnmounter : public ScopedDirRemover { |
| 549 | public: |
| 550 | explicit ScopedTempUnmounter(const std::string& path) : |
| 551 | ScopedDirRemover(path) {} |
| 552 | ~ScopedTempUnmounter() { |
| 553 | utils::UnmountFilesystem(path_); |
Andrew de los Reyes | 09e56d6 | 2010-04-23 13:45:53 -0700 | [diff] [blame] | 554 | } |
| 555 | private: |
Darin Petkov | 6f03a3b | 2010-11-10 14:27:14 -0800 | [diff] [blame] | 556 | DISALLOW_COPY_AND_ASSIGN(ScopedTempUnmounter); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 557 | }; |
| 558 | |
| 559 | // A little object to call ActionComplete on the ActionProcessor when |
| 560 | // it's destructed. |
| 561 | class ScopedActionCompleter { |
| 562 | public: |
| 563 | explicit ScopedActionCompleter(ActionProcessor* processor, |
| 564 | AbstractAction* action) |
| 565 | : processor_(processor), |
| 566 | action_(action), |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 567 | code_(kErrorCodeError), |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 568 | should_complete_(true) {} |
| 569 | ~ScopedActionCompleter() { |
| 570 | if (should_complete_) |
Darin Petkov | c1a8b42 | 2010-07-19 11:34:49 -0700 | [diff] [blame] | 571 | processor_->ActionComplete(action_, code_); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 572 | } |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 573 | void set_code(ErrorCode code) { code_ = code; } |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 574 | void set_should_complete(bool should_complete) { |
| 575 | should_complete_ = should_complete; |
| 576 | } |
David Zeuthen | 33bae49 | 2014-02-25 16:16:18 -0800 | [diff] [blame] | 577 | ErrorCode get_code() const { return code_; } |
Darin Petkov | c1a8b42 | 2010-07-19 11:34:49 -0700 | [diff] [blame] | 578 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 579 | private: |
| 580 | ActionProcessor* processor_; |
| 581 | AbstractAction* action_; |
David Zeuthen | a99981f | 2013-04-29 13:42:47 -0700 | [diff] [blame] | 582 | ErrorCode code_; |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 583 | bool should_complete_; |
| 584 | DISALLOW_COPY_AND_ASSIGN(ScopedActionCompleter); |
| 585 | }; |
| 586 | |
David Zeuthen | 27a48bc | 2013-08-06 12:06:29 -0700 | [diff] [blame] | 587 | // A base::FreeDeleter that frees memory using g_free(). Useful when |
| 588 | // integrating with GLib since it can be used with scoped_ptr to |
| 589 | // automatically free memory when going out of scope. |
| 590 | struct GLibFreeDeleter : public base::FreeDeleter { |
| 591 | inline void operator()(void *ptr) const { |
| 592 | g_free(reinterpret_cast<gpointer>(ptr)); |
| 593 | } |
| 594 | }; |
| 595 | |
| 596 | // A base::FreeDeleter that frees memory using g_strfreev(). Useful |
| 597 | // when integrating with GLib since it can be used with scoped_ptr to |
| 598 | // automatically free memory when going out of scope. |
| 599 | struct GLibStrvFreeDeleter : public base::FreeDeleter { |
| 600 | inline void operator()(void *ptr) const { |
| 601 | g_strfreev(reinterpret_cast<gchar**>(ptr)); |
| 602 | } |
| 603 | }; |
| 604 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 605 | } // namespace chromeos_update_engine |
| 606 | |
| 607 | #define TEST_AND_RETURN_FALSE_ERRNO(_x) \ |
| 608 | do { \ |
| 609 | bool _success = (_x); \ |
| 610 | if (!_success) { \ |
| 611 | std::string _msg = \ |
| 612 | chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ |
| 613 | LOG(ERROR) << #_x " failed: " << _msg; \ |
| 614 | return false; \ |
| 615 | } \ |
| 616 | } while (0) |
| 617 | |
| 618 | #define TEST_AND_RETURN_FALSE(_x) \ |
| 619 | do { \ |
| 620 | bool _success = (_x); \ |
| 621 | if (!_success) { \ |
| 622 | LOG(ERROR) << #_x " failed."; \ |
| 623 | return false; \ |
| 624 | } \ |
| 625 | } while (0) |
| 626 | |
| 627 | #define TEST_AND_RETURN_ERRNO(_x) \ |
| 628 | do { \ |
| 629 | bool _success = (_x); \ |
| 630 | if (!_success) { \ |
| 631 | std::string _msg = \ |
| 632 | chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ |
| 633 | LOG(ERROR) << #_x " failed: " << _msg; \ |
| 634 | return; \ |
| 635 | } \ |
| 636 | } while (0) |
| 637 | |
| 638 | #define TEST_AND_RETURN(_x) \ |
| 639 | do { \ |
| 640 | bool _success = (_x); \ |
| 641 | if (!_success) { \ |
| 642 | LOG(ERROR) << #_x " failed."; \ |
| 643 | return; \ |
| 644 | } \ |
| 645 | } while (0) |
| 646 | |
Thieu Le | 5c7d975 | 2010-12-15 16:09:28 -0800 | [diff] [blame] | 647 | #define TEST_AND_RETURN_FALSE_ERRCODE(_x) \ |
| 648 | do { \ |
| 649 | errcode_t _error = (_x); \ |
| 650 | if (_error) { \ |
| 651 | errno = _error; \ |
| 652 | LOG(ERROR) << #_x " failed: " << _error; \ |
| 653 | return false; \ |
| 654 | } \ |
| 655 | } while (0) |
| 656 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 657 | |
| 658 | |
Alex Deymo | 759c275 | 2014-03-17 21:09:36 -0700 | [diff] [blame] | 659 | #endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_ |