1 /** @file 2 Miscellaneous functions. 3 4 Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials are licensed and made available 6 under the terms and conditions of the BSD License which accompanies this 7 distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 14 **/ 15 16 #include "Fat.h" 17 UINT8 mMonthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 18 19 /** 20 21 Create the task 22 23 @param IFile - The instance of the open file. 24 @param Token - A pointer to the token associated with the transaction. 25 26 @return FAT_TASK * - Return the task instance. 27 28 **/ 29 FAT_TASK * 30 FatCreateTask ( 31 FAT_IFILE *IFile, 32 EFI_FILE_IO_TOKEN *Token 33 ) 34 { 35 FAT_TASK *Task; 36 37 Task = AllocateZeroPool (sizeof (*Task)); 38 if (Task != NULL) { 39 Task->Signature = FAT_TASK_SIGNATURE; 40 Task->IFile = IFile; 41 Task->FileIoToken = Token; 42 InitializeListHead (&Task->Subtasks); 43 InitializeListHead (&Task->Link); 44 } 45 return Task; 46 } 47 48 /** 49 50 Destroy the task. 51 52 @param Task - The task to be destroyed. 53 54 **/ 55 VOID 56 FatDestroyTask ( 57 FAT_TASK *Task 58 ) 59 { 60 LIST_ENTRY *Link; 61 FAT_SUBTASK *Subtask; 62 63 Link = GetFirstNode (&Task->Subtasks); 64 while (!IsNull (&Task->Subtasks, Link)) { 65 Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE); 66 Link = FatDestroySubtask (Subtask); 67 } 68 FreePool (Task); 69 } 70 71 /** 72 73 Wait all non-blocking requests complete. 74 75 @param IFile - The instance of the open file. 76 77 **/ 78 VOID 79 FatWaitNonblockingTask ( 80 FAT_IFILE *IFile 81 ) 82 { 83 BOOLEAN TaskQueueEmpty; 84 85 do { 86 EfiAcquireLock (&FatTaskLock); 87 TaskQueueEmpty = IsListEmpty (&IFile->Tasks); 88 EfiReleaseLock (&FatTaskLock); 89 } while (!TaskQueueEmpty); 90 } 91 92 /** 93 94 Remove the subtask from subtask list. 95 96 @param Subtask - The subtask to be removed. 97 98 @return LIST_ENTRY * - The next node in the list. 99 100 **/ 101 LIST_ENTRY * 102 FatDestroySubtask ( 103 FAT_SUBTASK *Subtask 104 ) 105 { 106 LIST_ENTRY *Link; 107 108 gBS->CloseEvent (Subtask->DiskIo2Token.Event); 109 110 Link = RemoveEntryList (&Subtask->Link); 111 FreePool (Subtask); 112 113 return Link; 114 } 115 116 /** 117 118 Execute the task. 119 120 @param IFile - The instance of the open file. 121 @param Task - The task to be executed. 122 123 @retval EFI_SUCCESS - The task was executed sucessfully. 124 @return other - An error occurred when executing the task. 125 126 **/ 127 EFI_STATUS 128 FatQueueTask ( 129 IN FAT_IFILE *IFile, 130 IN FAT_TASK *Task 131 ) 132 { 133 EFI_STATUS Status; 134 LIST_ENTRY *Link; 135 FAT_SUBTASK *Subtask; 136 137 // 138 // Sometimes the Task doesn't contain any subtasks, signal the event directly. 139 // 140 if (IsListEmpty (&Task->Subtasks)) { 141 Task->FileIoToken->Status = EFI_SUCCESS; 142 gBS->SignalEvent (Task->FileIoToken->Event); 143 FreePool (Task); 144 return EFI_SUCCESS; 145 } 146 147 EfiAcquireLock (&FatTaskLock); 148 InsertTailList (&IFile->Tasks, &Task->Link); 149 EfiReleaseLock (&FatTaskLock); 150 151 Status = EFI_SUCCESS; 152 for ( Link = GetFirstNode (&Task->Subtasks) 153 ; !IsNull (&Task->Subtasks, Link) 154 ; Link = GetNextNode (&Task->Subtasks, Link) 155 ) { 156 Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE); 157 if (Subtask->Write) { 158 159 Status = IFile->OFile->Volume->DiskIo2->WriteDiskEx ( 160 IFile->OFile->Volume->DiskIo2, 161 IFile->OFile->Volume->MediaId, 162 Subtask->Offset, 163 &Subtask->DiskIo2Token, 164 Subtask->BufferSize, 165 Subtask->Buffer 166 ); 167 } else { 168 Status = IFile->OFile->Volume->DiskIo2->ReadDiskEx ( 169 IFile->OFile->Volume->DiskIo2, 170 IFile->OFile->Volume->MediaId, 171 Subtask->Offset, 172 &Subtask->DiskIo2Token, 173 Subtask->BufferSize, 174 Subtask->Buffer 175 ); 176 } 177 if (EFI_ERROR (Status)) { 178 break; 179 } 180 } 181 182 if (EFI_ERROR (Status)) { 183 EfiAcquireLock (&FatTaskLock); 184 // 185 // Remove all the remaining subtasks when failure. 186 // We shouldn't remove all the tasks because the non-blocking requests have 187 // been submitted and cannot be canceled. 188 // 189 while (!IsNull (&Task->Subtasks, Link)) { 190 Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE); 191 Link = FatDestroySubtask (Subtask); 192 } 193 194 if (IsListEmpty (&Task->Subtasks)) { 195 RemoveEntryList (&Task->Link); 196 FreePool (Task); 197 } else { 198 // 199 // If one or more subtasks have been already submitted, set FileIoToken 200 // to NULL so that the callback won't signal the event. 201 // 202 Task->FileIoToken = NULL; 203 } 204 205 EfiReleaseLock (&FatTaskLock); 206 } 207 208 return Status; 209 } 210 211 /** 212 213 Set the volume as dirty or not. 214 215 @param Volume - FAT file system volume. 216 @param IoMode - The access mode. 217 @param DirtyValue - Set the volume as dirty or not. 218 219 @retval EFI_SUCCESS - Set the new FAT entry value sucessfully. 220 @return other - An error occurred when operation the FAT entries. 221 222 **/ 223 EFI_STATUS 224 FatAccessVolumeDirty ( 225 IN FAT_VOLUME *Volume, 226 IN IO_MODE IoMode, 227 IN VOID *DirtyValue 228 ) 229 { 230 UINTN WriteCount; 231 232 WriteCount = Volume->FatEntrySize; 233 return FatDiskIo (Volume, IoMode, Volume->FatPos + WriteCount, WriteCount, DirtyValue, NULL); 234 } 235 236 /** 237 Invoke a notification event. 238 239 @param Event Event whose notification function is being invoked. 240 @param Context The pointer to the notification function's context, 241 which is implementation-dependent. 242 243 **/ 244 VOID 245 EFIAPI 246 FatOnAccessComplete ( 247 IN EFI_EVENT Event, 248 IN VOID *Context 249 ) 250 { 251 EFI_STATUS Status; 252 FAT_SUBTASK *Subtask; 253 FAT_TASK *Task; 254 255 // 256 // Avoid someone in future breaks the below assumption. 257 // 258 ASSERT (EfiGetCurrentTpl () == FatTaskLock.Tpl); 259 260 Subtask = (FAT_SUBTASK *) Context; 261 Task = Subtask->Task; 262 Status = Subtask->DiskIo2Token.TransactionStatus; 263 264 ASSERT (Task->Signature == FAT_TASK_SIGNATURE); 265 ASSERT (Subtask->Signature == FAT_SUBTASK_SIGNATURE); 266 267 // 268 // Remove the task unconditionally 269 // 270 FatDestroySubtask (Subtask); 271 272 // 273 // Task->FileIoToken is NULL which means the task will be ignored (just recycle the subtask and task memory). 274 // 275 if (Task->FileIoToken != NULL) { 276 if (IsListEmpty (&Task->Subtasks) || EFI_ERROR (Status)) { 277 Task->FileIoToken->Status = Status; 278 gBS->SignalEvent (Task->FileIoToken->Event); 279 // 280 // Mark Task->FileIoToken to NULL so that the subtasks belonging to the task will be ignored. 281 // 282 Task->FileIoToken = NULL; 283 } 284 } 285 286 if (IsListEmpty (&Task->Subtasks)) { 287 RemoveEntryList (&Task->Link); 288 FreePool (Task); 289 } 290 } 291 292 /** 293 294 General disk access function. 295 296 @param Volume - FAT file system volume. 297 @param IoMode - The access mode (disk read/write or cache access). 298 @param Offset - The starting byte offset to read from. 299 @param BufferSize - Size of Buffer. 300 @param Buffer - Buffer containing read data. 301 @param Task point to task instance. 302 303 @retval EFI_SUCCESS - The operation is performed successfully. 304 @retval EFI_VOLUME_CORRUPTED - The accesss is 305 @return Others - The status of read/write the disk 306 307 **/ 308 EFI_STATUS 309 FatDiskIo ( 310 IN FAT_VOLUME *Volume, 311 IN IO_MODE IoMode, 312 IN UINT64 Offset, 313 IN UINTN BufferSize, 314 IN OUT VOID *Buffer, 315 IN FAT_TASK *Task 316 ) 317 { 318 EFI_STATUS Status; 319 EFI_DISK_IO_PROTOCOL *DiskIo; 320 EFI_DISK_READ IoFunction; 321 FAT_SUBTASK *Subtask; 322 323 // 324 // Verify the IO is in devices range 325 // 326 Status = EFI_VOLUME_CORRUPTED; 327 if (Offset + BufferSize <= Volume->VolumeSize) { 328 if (CACHE_ENABLED (IoMode)) { 329 // 330 // Access cache 331 // 332 Status = FatAccessCache (Volume, CACHE_TYPE (IoMode), RAW_ACCESS (IoMode), Offset, BufferSize, Buffer, Task); 333 } else { 334 // 335 // Access disk directly 336 // 337 if (Task == NULL) { 338 // 339 // Blocking access 340 // 341 DiskIo = Volume->DiskIo; 342 IoFunction = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk; 343 Status = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer); 344 } else { 345 // 346 // Non-blocking access 347 // 348 Subtask = AllocateZeroPool (sizeof (*Subtask)); 349 if (Subtask == NULL) { 350 Status = EFI_OUT_OF_RESOURCES; 351 } else { 352 Subtask->Signature = FAT_SUBTASK_SIGNATURE; 353 Subtask->Task = Task; 354 Subtask->Write = (BOOLEAN) (IoMode == WriteDisk); 355 Subtask->Offset = Offset; 356 Subtask->Buffer = Buffer; 357 Subtask->BufferSize = BufferSize; 358 Status = gBS->CreateEvent ( 359 EVT_NOTIFY_SIGNAL, 360 TPL_NOTIFY, 361 FatOnAccessComplete, 362 Subtask, 363 &Subtask->DiskIo2Token.Event 364 ); 365 if (!EFI_ERROR (Status)) { 366 InsertTailList (&Task->Subtasks, &Subtask->Link); 367 } else { 368 FreePool (Subtask); 369 } 370 } 371 } 372 } 373 } 374 375 if (EFI_ERROR (Status)) { 376 Volume->DiskError = TRUE; 377 DEBUG ((EFI_D_ERROR, "FatDiskIo: error %r\n", Status)); 378 } 379 380 return Status; 381 } 382 383 /** 384 385 Lock the volume. 386 387 **/ 388 VOID 389 FatAcquireLock ( 390 VOID 391 ) 392 { 393 EfiAcquireLock (&FatFsLock); 394 } 395 396 /** 397 398 Lock the volume. 399 If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned. 400 Otherwise, EFI_SUCCESS is returned. 401 402 @retval EFI_SUCCESS - The volume is locked. 403 @retval EFI_ACCESS_DENIED - The volume could not be locked because it is already locked. 404 405 **/ 406 EFI_STATUS 407 FatAcquireLockOrFail ( 408 VOID 409 ) 410 { 411 return EfiAcquireLockOrFail (&FatFsLock); 412 } 413 414 /** 415 416 Unlock the volume. 417 418 **/ 419 VOID 420 FatReleaseLock ( 421 VOID 422 ) 423 { 424 EfiReleaseLock (&FatFsLock); 425 } 426 427 /** 428 429 Free directory entry. 430 431 @param DirEnt - The directory entry to be freed. 432 433 **/ 434 VOID 435 FatFreeDirEnt ( 436 IN FAT_DIRENT *DirEnt 437 ) 438 { 439 if (DirEnt->FileString != NULL) { 440 FreePool (DirEnt->FileString); 441 } 442 443 FreePool (DirEnt); 444 } 445 446 /** 447 448 Free volume structure (including the contents of directory cache and disk cache). 449 450 @param Volume - The volume structure to be freed. 451 452 **/ 453 VOID 454 FatFreeVolume ( 455 IN FAT_VOLUME *Volume 456 ) 457 { 458 // 459 // Free disk cache 460 // 461 if (Volume->CacheBuffer != NULL) { 462 FreePool (Volume->CacheBuffer); 463 } 464 // 465 // Free directory cache 466 // 467 FatCleanupODirCache (Volume); 468 FreePool (Volume); 469 } 470 471 /** 472 473 Translate EFI time to FAT time. 474 475 @param ETime - The time of EFI_TIME. 476 @param FTime - The time of FAT_DATE_TIME. 477 478 **/ 479 VOID 480 FatEfiTimeToFatTime ( 481 IN EFI_TIME *ETime, 482 OUT FAT_DATE_TIME *FTime 483 ) 484 { 485 // 486 // ignores timezone info in source ETime 487 // 488 if (ETime->Year > 1980) { 489 FTime->Date.Year = (UINT16) (ETime->Year - 1980); 490 } 491 492 if (ETime->Year >= 1980 + FAT_MAX_YEAR_FROM_1980) { 493 FTime->Date.Year = FAT_MAX_YEAR_FROM_1980; 494 } 495 496 FTime->Date.Month = ETime->Month; 497 FTime->Date.Day = ETime->Day; 498 FTime->Time.Hour = ETime->Hour; 499 FTime->Time.Minute = ETime->Minute; 500 FTime->Time.DoubleSecond = (UINT16) (ETime->Second / 2); 501 } 502 503 /** 504 505 Translate Fat time to EFI time. 506 507 @param FTime - The time of FAT_DATE_TIME. 508 @param ETime - The time of EFI_TIME.. 509 510 **/ 511 VOID 512 FatFatTimeToEfiTime ( 513 IN FAT_DATE_TIME *FTime, 514 OUT EFI_TIME *ETime 515 ) 516 { 517 ETime->Year = (UINT16) (FTime->Date.Year + 1980); 518 ETime->Month = (UINT8) FTime->Date.Month; 519 ETime->Day = (UINT8) FTime->Date.Day; 520 ETime->Hour = (UINT8) FTime->Time.Hour; 521 ETime->Minute = (UINT8) FTime->Time.Minute; 522 ETime->Second = (UINT8) (FTime->Time.DoubleSecond * 2); 523 ETime->Nanosecond = 0; 524 ETime->TimeZone = EFI_UNSPECIFIED_TIMEZONE; 525 ETime->Daylight = 0; 526 } 527 528 /** 529 530 Get Current FAT time. 531 532 @param FatNow - Current FAT time. 533 534 **/ 535 VOID 536 FatGetCurrentFatTime ( 537 OUT FAT_DATE_TIME *FatNow 538 ) 539 { 540 EFI_STATUS Status; 541 EFI_TIME Now; 542 543 Status = gRT->GetTime (&Now, NULL); 544 if (!EFI_ERROR (Status)) { 545 FatEfiTimeToFatTime (&Now, FatNow); 546 } else { 547 ZeroMem (&Now, sizeof (EFI_TIME)); 548 Now.Year = 1980; 549 Now.Month = 1; 550 Now.Day = 1; 551 FatEfiTimeToFatTime (&Now, FatNow); 552 } 553 } 554 555 /** 556 557 Check whether a time is valid. 558 559 @param Time - The time of EFI_TIME. 560 561 @retval TRUE - The time is valid. 562 @retval FALSE - The time is not valid. 563 564 **/ 565 BOOLEAN 566 FatIsValidTime ( 567 IN EFI_TIME *Time 568 ) 569 { 570 UINTN Day; 571 BOOLEAN ValidTime; 572 573 ValidTime = TRUE; 574 575 // 576 // Check the fields for range problems 577 // Fat can only support from 1980 578 // 579 if (Time->Year < 1980 || 580 Time->Month < 1 || 581 Time->Month > 12 || 582 Time->Day < 1 || 583 Time->Day > 31 || 584 Time->Hour > 23 || 585 Time->Minute > 59 || 586 Time->Second > 59 || 587 Time->Nanosecond > 999999999 588 ) { 589 590 ValidTime = FALSE; 591 592 } else { 593 // 594 // Perform a more specific check of the day of the month 595 // 596 Day = mMonthDays[Time->Month - 1]; 597 if (Time->Month == 2 && IS_LEAP_YEAR (Time->Year)) { 598 Day += 1; 599 // 600 // 1 extra day this month 601 // 602 } 603 if (Time->Day > Day) { 604 ValidTime = FALSE; 605 } 606 } 607 608 return ValidTime; 609 } 610
