1 /*++ 2 3 Caution: This file is used for Duet platform only, do not use them in real platform. 4 All variable code, variable metadata, and variable data used by Duet platform are on 5 disk. They can be changed by user. BIOS is not able to protoect those. 6 Duet trusts all meta data from disk. If variable code, variable metadata and variable 7 data is modified in inproper way, the behavior is undefined. 8 9 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR> 10 This program and the accompanying materials 11 are licensed and made available under the terms and conditions of the BSD License 12 which accompanies this distribution. The full text of the license may be found at 13 http://opensource.org/licenses/bsd-license.php 14 15 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 16 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 17 18 Module Name: 19 20 FileStorage.c 21 22 Abstract: 23 24 handles variable store/reads on file 25 26 Revision History 27 28 --*/ 29 #include "FSVariable.h" 30 31 VOID *mSFSRegistration; 32 33 // 34 // Prototypes 35 // 36 37 VOID 38 EFIAPI 39 OnVirtualAddressChangeFs ( 40 IN EFI_EVENT Event, 41 IN VOID *Context 42 ); 43 44 EFI_STATUS 45 EFIAPI 46 FileEraseStore( 47 IN VARIABLE_STORAGE *This 48 ); 49 50 EFI_STATUS 51 EFIAPI 52 FileWriteStore ( 53 IN VARIABLE_STORAGE *This, 54 IN UINTN Offset, 55 IN UINTN BufferSize, 56 IN VOID *Buffer 57 ); 58 59 EFI_STATUS 60 OpenStore ( 61 IN EFI_DEVICE_PATH_PROTOCOL *Device, 62 IN CHAR16 *FilePathName, 63 IN UINT64 OpenMode, 64 OUT EFI_FILE_PROTOCOL **File 65 ); 66 67 // 68 // Implementation below: 69 // 70 VOID 71 FileClose ( 72 IN EFI_FILE_PROTOCOL *File 73 ) 74 { 75 EFI_STATUS Status; 76 77 Status = File->Flush (File); 78 ASSERT_EFI_ERROR (Status); 79 80 Status = File->Close (File); 81 ASSERT_EFI_ERROR (Status); 82 } 83 84 EFI_STATUS 85 CheckStore ( 86 IN EFI_HANDLE SimpleFileSystemHandle, 87 IN UINT32 VolumeId, 88 OUT EFI_DEVICE_PATH_PROTOCOL **Device 89 ) 90 { 91 #define BLOCK_SIZE 0x200 92 #define FAT16_VOLUME_ID_OFFSET 39 93 #define FAT32_VOLUME_ID_OFFSET 67 94 EFI_STATUS Status; 95 EFI_BLOCK_IO_PROTOCOL *BlkIo; 96 UINT8 BootSector[BLOCK_SIZE]; 97 98 *Device = NULL; 99 Status = gBS->HandleProtocol ( 100 SimpleFileSystemHandle, 101 &gEfiBlockIoProtocolGuid, // BlockIo should be supported if it supports SimpleFileSystem 102 (VOID*)&BlkIo 103 ); 104 105 if (EFI_ERROR (Status)) { 106 goto ErrHandle; 107 } 108 if (!BlkIo->Media->MediaPresent) { 109 DEBUG ((EFI_D_ERROR, "FileStorage: Media not present!\n")); 110 Status = EFI_NO_MEDIA; 111 goto ErrHandle; 112 } 113 if (BlkIo->Media->ReadOnly) { 114 DEBUG ((EFI_D_ERROR, "FileStorage: Media is read-only!\n")); 115 Status = EFI_ACCESS_DENIED; 116 goto ErrHandle; 117 } 118 119 Status = BlkIo->ReadBlocks( 120 BlkIo, 121 BlkIo->Media->MediaId, 122 0, 123 BLOCK_SIZE, 124 BootSector 125 ); 126 ASSERT_EFI_ERROR (Status); 127 if ((*(UINT32 *) &BootSector[FAT16_VOLUME_ID_OFFSET] != VolumeId) && 128 (*(UINT32 *) &BootSector[FAT32_VOLUME_ID_OFFSET] != VolumeId) 129 ) { 130 Status = EFI_NOT_FOUND; 131 goto ErrHandle; 132 } 133 134 *Device = DuplicateDevicePath (DevicePathFromHandle (SimpleFileSystemHandle)); 135 ASSERT (*Device != NULL); 136 137 ErrHandle: 138 return Status; 139 } 140 141 EFI_STATUS 142 CheckStoreExists ( 143 IN EFI_DEVICE_PATH_PROTOCOL *Device 144 ) 145 { 146 EFI_HANDLE Handle; 147 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume; 148 EFI_STATUS Status; 149 150 Status = gBS->LocateDevicePath ( 151 &gEfiSimpleFileSystemProtocolGuid, 152 &Device, 153 &Handle 154 ); 155 156 if (EFI_ERROR (Status)) { 157 return Status; 158 } 159 160 Status = gBS->HandleProtocol ( 161 Handle, 162 &gEfiSimpleFileSystemProtocolGuid, 163 (VOID **) &Volume 164 ); 165 if (EFI_ERROR (Status)) { 166 return Status; 167 } 168 169 return EFI_SUCCESS; 170 } 171 172 // this routine is still running in BS period, no limitation 173 // call FileInitStorage(), which load variable content file to memory 174 // read the store_header, init store_header if it has not been inited (read sth. about format/heathy) 175 // reclaim space using scratch memory 176 177 VOID 178 EFIAPI 179 OnSimpleFileSystemInstall ( 180 IN EFI_EVENT Event, 181 IN VOID *Context 182 ) 183 { 184 EFI_STATUS Status; 185 UINTN HandleSize; 186 EFI_HANDLE Handle; 187 EFI_DEVICE_PATH_PROTOCOL *Device; 188 VS_DEV *Dev; 189 EFI_FILE_PROTOCOL *File; 190 UINTN NumBytes; 191 192 Dev = (VS_DEV *) Context; 193 194 if (VAR_FILE_DEVICEPATH (Dev) != NULL && 195 !EFI_ERROR (CheckStoreExists (VAR_FILE_DEVICEPATH (Dev))) 196 ) { 197 DEBUG ((EFI_D_ERROR, "FileStorage: Already mapped!\n")); 198 return ; 199 } 200 201 while (TRUE) { 202 HandleSize = sizeof (EFI_HANDLE); 203 Status = gBS->LocateHandle ( 204 ByRegisterNotify, 205 NULL, 206 mSFSRegistration, 207 &HandleSize, 208 &Handle 209 ); 210 if (EFI_ERROR (Status)) { 211 return ; 212 } 213 214 Status = CheckStore (Handle, VAR_FILE_VOLUMEID (Dev), &Device); 215 if (!EFI_ERROR (Status)) { 216 break; 217 } 218 } 219 220 VAR_FILE_DEVICEPATH (Dev) = Device; 221 Status = OpenStore ( 222 VAR_FILE_DEVICEPATH (Dev), 223 VAR_FILE_FILEPATH (Dev), 224 EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ | EFI_FILE_MODE_CREATE, 225 &File 226 ); 227 ASSERT_EFI_ERROR (Status); 228 229 NumBytes = Dev->Size; 230 Status = File->Write (File, &NumBytes, VAR_DATA_PTR (Dev)); 231 ASSERT_EFI_ERROR (Status); 232 FileClose (File); 233 DEBUG ((EFI_D_ERROR, "FileStorage: Mapped to file!\n")); 234 } 235 236 EFI_STATUS 237 FileStorageConstructor ( 238 OUT VARIABLE_STORAGE **VarStore, 239 OUT EFI_EVENT_NOTIFY *GoVirtualEvent, 240 IN EFI_PHYSICAL_ADDRESS NvStorageBase, 241 IN UINTN Size, 242 IN UINT32 VolumeId, 243 IN CHAR16 *FilePath 244 ) 245 { 246 VS_DEV *Dev; 247 EFI_STATUS Status; 248 EFI_EVENT Event; 249 250 Status = gBS->AllocatePool (EfiRuntimeServicesData, sizeof(VS_DEV), (VOID **) &Dev); 251 ASSERT_EFI_ERROR (Status); 252 ZeroMem (Dev, sizeof(VS_DEV)); 253 254 Dev->Signature = VS_DEV_SIGNATURE; 255 Dev->Size = Size; 256 VAR_DATA_PTR (Dev) = (UINT8 *) (UINTN) NvStorageBase; 257 VAR_FILE_VOLUMEID (Dev) = VolumeId; 258 StrCpy (VAR_FILE_FILEPATH (Dev), FilePath); 259 Dev->VarStore.Erase = FileEraseStore; 260 Dev->VarStore.Write = FileWriteStore; 261 262 DEBUG ((EFI_D_ERROR, "FileStorageConstructor(0x%0x:0x%0x): added!\n", NvStorageBase, Size)); 263 264 // add notify on SFS's installation. 265 266 Status = gBS->CreateEvent ( 267 EVT_NOTIFY_SIGNAL, 268 TPL_CALLBACK, 269 OnSimpleFileSystemInstall, 270 Dev, 271 &Event 272 ); 273 ASSERT_EFI_ERROR (Status); 274 275 Status = gBS->RegisterProtocolNotify ( 276 &gEfiSimpleFileSystemProtocolGuid, 277 Event, 278 &mSFSRegistration 279 ); 280 ASSERT_EFI_ERROR (Status); 281 282 *VarStore = &Dev->VarStore; 283 *GoVirtualEvent = OnVirtualAddressChangeFs; 284 return EFI_SUCCESS; 285 } 286 287 EFI_STATUS 288 EFIAPI 289 FileEraseStore( 290 IN VARIABLE_STORAGE *This 291 ) 292 { 293 EFI_STATUS Status; 294 VS_DEV *Dev; 295 EFI_FILE_PROTOCOL *File; 296 UINTN NumBytes; 297 298 Status = EFI_SUCCESS; 299 Dev = DEV_FROM_THIS(This); 300 301 SetMem (VAR_DATA_PTR (Dev), Dev->Size, VAR_DEFAULT_VALUE); 302 303 if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) { 304 Status = OpenStore ( 305 VAR_FILE_DEVICEPATH (Dev), 306 VAR_FILE_FILEPATH (Dev), 307 EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 308 &File 309 ); 310 ASSERT_EFI_ERROR (Status); 311 NumBytes = Dev->Size; 312 Status = File->Write (File, &NumBytes, VAR_DATA_PTR (Dev)); 313 ASSERT_EFI_ERROR (Status); 314 FileClose (File); 315 } 316 317 return Status; 318 } 319 320 EFI_STATUS 321 EFIAPI 322 FileWriteStore ( 323 IN VARIABLE_STORAGE *This, 324 IN UINTN Offset, 325 IN UINTN BufferSize, 326 IN VOID *Buffer 327 ) 328 { 329 EFI_STATUS Status; 330 VS_DEV *Dev; 331 EFI_FILE_PROTOCOL *File; 332 333 Status = EFI_SUCCESS; 334 Dev = DEV_FROM_THIS(This); 335 336 ASSERT (Buffer != NULL); 337 ASSERT (Offset + BufferSize <= Dev->Size); 338 339 CopyMem (VAR_DATA_PTR (Dev) + Offset, Buffer, BufferSize); 340 341 if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) { 342 Status = OpenStore ( 343 VAR_FILE_DEVICEPATH (Dev), 344 VAR_FILE_FILEPATH (Dev), 345 EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 346 &File 347 ); 348 Status = File->SetPosition (File, Offset); 349 ASSERT_EFI_ERROR (Status); 350 Status = File->Write (File, &BufferSize, Buffer); 351 ASSERT_EFI_ERROR (Status); 352 FileClose (File); 353 } 354 return Status; 355 } 356 357 VOID 358 EFIAPI 359 OnVirtualAddressChangeFs ( 360 IN EFI_EVENT Event, 361 IN VOID *Context 362 ) 363 { 364 VS_DEV *Dev; 365 366 Dev = DEV_FROM_THIS (Context); 367 368 EfiConvertPointer (0, (VOID **) &VAR_DATA_PTR (Dev)); 369 EfiConvertPointer (0, (VOID **) &Dev->VarStore.Erase); 370 EfiConvertPointer (0, (VOID **) &Dev->VarStore.Write); 371 } 372 373 EFI_STATUS 374 OpenStore ( 375 IN EFI_DEVICE_PATH_PROTOCOL *Device, 376 IN CHAR16 *FilePathName, 377 IN UINT64 OpenMode, 378 OUT EFI_FILE_PROTOCOL **File 379 ) 380 { 381 EFI_HANDLE Handle; 382 EFI_FILE_HANDLE Root; 383 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume; 384 EFI_STATUS Status; 385 386 *File = NULL; 387 388 Status = gBS->LocateDevicePath ( 389 &gEfiSimpleFileSystemProtocolGuid, 390 &Device, 391 &Handle 392 ); 393 394 if (EFI_ERROR (Status)) { 395 return Status; 396 } 397 398 Status = gBS->HandleProtocol ( 399 Handle, 400 &gEfiSimpleFileSystemProtocolGuid, 401 (VOID **) &Volume 402 ); 403 if (EFI_ERROR (Status)) { 404 return Status; 405 } 406 407 // 408 // Open the root directory of the volume 409 // 410 Root = NULL; 411 Status = Volume->OpenVolume ( 412 Volume, 413 &Root 414 ); 415 ASSERT_EFI_ERROR (Status); 416 ASSERT (Root != NULL); 417 418 // 419 // Open file 420 // 421 Status = Root->Open ( 422 Root, 423 File, 424 FilePathName, 425 OpenMode, 426 0 427 ); 428 if (EFI_ERROR (Status)) { 429 *File = NULL; 430 } 431 432 // 433 // Close the Root directory 434 // 435 Root->Close (Root); 436 return Status; 437 } 438
