1 /* 2 * Copyright (C) 2016 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 <nvram/core/storage.h> 18 19 #include <errno.h> 20 #include <fcntl.h> 21 #include <stdio.h> 22 #include <sys/stat.h> 23 #include <sys/types.h> 24 #include <unistd.h> 25 26 #include <android-base/file.h> 27 #include <android-base/logging.h> 28 #include <android-base/unique_fd.h> 29 30 #include <nvram/core/logger.h> 31 32 // An NVRAM storage layer implementation backed by the file system. 33 // 34 // NOTE: This does not meet the tamper evidence requirements for 35 // access-controlled NVRAM implementations, since the file system can't provide 36 // sufficient protection against tampering by attackers. 37 38 namespace { 39 40 // Name of the storage object holding the header. 41 const char kHeaderFileName[] = "header"; 42 43 // Pattern for space data storage object names. 44 const char kSpaceDataFileNamePattern[] = "space_%08x"; 45 46 // Temporary file name used in write-rename atomic write operations. 47 const char kTempFileName[] = "temp"; 48 49 // Maximum size of objects we're willing to read and write. 50 const off_t kMaxFileSize = 2048; 51 52 // Buffer size for formatting names. 53 using NameBuffer = char[16]; 54 55 // Global data directory descriptor. 56 int g_data_dir_fd = -1; 57 58 // Formats the storage object name for the given space index. 59 bool FormatSpaceFileName(NameBuffer name, uint32_t index) { 60 int ret = 61 snprintf(name, sizeof(NameBuffer), kSpaceDataFileNamePattern, index); 62 return ret >= 0 && ret < static_cast<int>(sizeof(NameBuffer)); 63 }; 64 65 nvram::storage::Status DeleteFile(const char* name) { 66 if (TEMP_FAILURE_RETRY(unlinkat(g_data_dir_fd, name, 0))) { 67 if (errno == ENOENT) { 68 return nvram::storage::Status::kNotFound; 69 } 70 PLOG(ERROR) << "Failed to remove " << name; 71 return nvram::storage::Status::kStorageError; 72 } 73 74 return nvram::storage::Status::kSuccess; 75 } 76 77 // Loads the storage object identified by |name|. 78 nvram::storage::Status LoadFile(const char* name, nvram::Blob* blob) { 79 android::base::unique_fd data_file_fd( 80 TEMP_FAILURE_RETRY(openat(g_data_dir_fd, name, O_RDONLY))); 81 if (data_file_fd.get() < 0) { 82 if (errno == ENOENT) { 83 return nvram::storage::Status::kNotFound; 84 } 85 PLOG(ERROR) << "Failed to open " << name; 86 return nvram::storage::Status::kStorageError; 87 } 88 89 struct stat data_file_stat; 90 if (TEMP_FAILURE_RETRY(fstat(data_file_fd.get(), &data_file_stat))) { 91 PLOG(ERROR) << "Failed to stat " << name; 92 return nvram::storage::Status::kStorageError; 93 } 94 95 if (data_file_stat.st_size > kMaxFileSize) { 96 LOG(ERROR) << "Bad size for " << name << ":" << data_file_stat.st_size; 97 return nvram::storage::Status::kStorageError; 98 } 99 100 if (!blob->Resize(data_file_stat.st_size)) { 101 LOG(ERROR) << "Failed to allocate read buffer for " << name; 102 return nvram::storage::Status::kStorageError; 103 } 104 105 if (!android::base::ReadFully(data_file_fd.get(), blob->data(), 106 blob->size())) { 107 PLOG(ERROR) << "Failed to read " << name; 108 return nvram::storage::Status::kStorageError; 109 } 110 111 return nvram::storage::Status::kSuccess; 112 } 113 114 // Writes blob to the storage object indicated by |name|. 115 nvram::storage::Status StoreFile(const char* name, const nvram::Blob& blob) { 116 android::base::unique_fd data_file_fd(TEMP_FAILURE_RETRY( 117 openat(g_data_dir_fd, kTempFileName, O_WRONLY | O_CREAT | O_TRUNC, 118 S_IRUSR | S_IWUSR))); 119 if (data_file_fd.get() < 0) { 120 if (errno == ENOENT) { 121 return nvram::storage::Status::kNotFound; 122 } 123 PLOG(ERROR) << "Failed to open " << kTempFileName; 124 return nvram::storage::Status::kStorageError; 125 } 126 127 if (!android::base::WriteFully(data_file_fd.get(), blob.data(), 128 blob.size())) { 129 PLOG(ERROR) << "Failed to write " << kTempFileName; 130 DeleteFile(kTempFileName); 131 return nvram::storage::Status::kStorageError; 132 } 133 134 // Force the file contents to be written to disk. 135 if (TEMP_FAILURE_RETRY(fdatasync(data_file_fd.get()))) { 136 PLOG(ERROR) << "Failed to sync " << kTempFileName; 137 DeleteFile(kTempFileName); 138 return nvram::storage::Status::kStorageError; 139 } 140 141 data_file_fd.reset(); 142 143 // Move the file into place. 144 if (TEMP_FAILURE_RETRY( 145 renameat(g_data_dir_fd, kTempFileName, g_data_dir_fd, name))) { 146 PLOG(ERROR) << "Failed to move " << kTempFileName << " to " << name; 147 DeleteFile(kTempFileName); 148 return nvram::storage::Status::kStorageError; 149 } 150 151 // Force the directory meta data to be written to disk. 152 if (TEMP_FAILURE_RETRY(fsync(g_data_dir_fd))) { 153 PLOG(ERROR) << "Failed to sync data directory"; 154 return nvram::storage::Status::kStorageError; 155 } 156 157 return nvram::storage::Status::kSuccess; 158 } 159 160 } // namespace 161 162 // Initializes the storage layer with the provided data directory descriptor. 163 void InitStorage(int data_dir_fd) { 164 g_data_dir_fd = data_dir_fd; 165 } 166 167 namespace nvram { 168 namespace storage { 169 170 Status LoadHeader(Blob* blob) { 171 return LoadFile(kHeaderFileName, blob); 172 } 173 174 Status StoreHeader(const Blob& blob) { 175 return StoreFile(kHeaderFileName, blob); 176 } 177 178 Status LoadSpace(uint32_t index, Blob* blob) { 179 NameBuffer name; 180 if (!FormatSpaceFileName(name, index)) { 181 return Status::kStorageError; 182 } 183 return LoadFile(name, blob); 184 } 185 186 Status StoreSpace(uint32_t index, const Blob& blob) { 187 NameBuffer name; 188 if (!FormatSpaceFileName(name, index)) { 189 return Status::kStorageError; 190 } 191 return StoreFile(name, blob); 192 } 193 194 Status DeleteSpace(uint32_t index) { 195 NameBuffer name; 196 if (!FormatSpaceFileName(name, index)) { 197 return Status::kStorageError; 198 } 199 200 return DeleteFile(name); 201 } 202 203 } // namespace storage 204 } // namespace nvram 205
