INTN
EFIAPI
ShellAppMain (
IN UINTN Argc,
IN CHAR16 **Argv
)
{
EFI_STATUS Status;
UINTN Index;
UINT32 FileSize;
UINT32 BufferSize;
UINT8 *FileBuffer;
UINT8 *Buffer;
EFI_PHYSICAL_ADDRESS Address;
UINTN CountOfBlocks;
EFI_TPL OldTpl;
BOOLEAN ResetRequired;
BOOLEAN FlashError;
Index = 0;
FileSize = 0;
BufferSize = 0;
FileBuffer = NULL;
Buffer = NULL;
Address = 0;
CountOfBlocks = 0;
ResetRequired = FALSE;
FlashError = FALSE;
Status = EFI_SUCCESS;
mInputData.FullFlashUpdate = TRUE;
//
// Publish our HII data.
//
HiiHandle = HiiAddPackages (
&gEfiCallerIdGuid,
NULL,
FirmwareUpdateStrings,
NULL
);
if (HiiHandle == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
//
// Locate the SPI protocol.
//
Status = gBS->LocateProtocol (
&gEfiSpiProtocolGuid,
NULL,
(VOID **)&mSpiProtocol
);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_SPI_NOT_FOUND), HiiHandle);
return EFI_DEVICE_ERROR;
}
//
// Parse the command line.
//
Status = ParseCommandLine (Argc, Argv);
if (EFI_ERROR (Status)) {
PrintHelpInfo ();
Status = EFI_SUCCESS;
goto Done;
}
//
// Display sign-on information.
//
PrintToken (STRING_TOKEN (STR_FWUPDATE_FIRMWARE_VOL_UPDATE), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_VERSION), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_COPYRIGHT), HiiHandle);
//
// Test to see if the firmware needs to be updated.
//
if (mInputData.UpdateFromFile) {
//
// Get the file to use in the update.
//
PrintToken (STRING_TOKEN (STR_FWUPDATE_READ_FILE), HiiHandle, mInputData.FileName);
Status = ReadFileData (mInputData.FileName, &FileBuffer, &FileSize);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_FWUPDATE_READ_FILE_ERROR), HiiHandle, mInputData.FileName);
goto Done;
}
//
// Check that the file and flash sizes match.
//
if (FileSize != PcdGet32 (PcdFlashChipSize)) {
PrintToken (STRING_TOKEN (STR_FWUPDATE_SIZE), HiiHandle);
Status = EFI_UNSUPPORTED;
goto Done;
}
//
// Display flash update information.
//
PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATING_FIRMWARE), HiiHandle);
//
// Update it.
//
Buffer = FileBuffer;
BufferSize = FileSize;
Address = PcdGet32 (PcdFlashChipBase);
CountOfBlocks = (UINTN) (BufferSize / BLOCK_SIZE);
//
// Raise TPL to TPL_NOTIFY to block any event handler,
// while still allowing RaiseTPL(TPL_NOTIFY) within
// output driver during Print().
//
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
for (Index = 0; Index < CountOfBlocks; Index++) {
//
// Handle block based on address and contents.
//
if (!UpdateBlock (Address)) {
DEBUG((EFI_D_INFO, "Skipping block at 0x%lx\n", Address));
} else if (!EFI_ERROR (InternalCompareBlock (Address, Buffer))) {
DEBUG((EFI_D_INFO, "Skipping block at 0x%lx (already programmed)\n", Address));
} else {
//
// Display a dot for each block being updated.
//
Print (L".");
//
// Flag that the flash image will be changed and the system must be rebooted
// to use the change.
//
ResetRequired = TRUE;
//
// Make updating process uninterruptable,
// so that the flash memory area is not accessed by other entities
// which may interfere with the updating process.
//
Status = InternalEraseBlock (Address);
ASSERT_EFI_ERROR(Status);
if (EFI_ERROR (Status)) {
gBS->RestoreTPL (OldTpl);
FlashError = TRUE;
goto Done;
}
Status = InternalWriteBlock (
Address,
Buffer,
(BufferSize > BLOCK_SIZE ? BLOCK_SIZE : BufferSize)
);
if (EFI_ERROR (Status)) {
gBS->RestoreTPL (OldTpl);
FlashError = TRUE;
goto Done;
}
}
//
// Move to next block to update.
//
Address += BLOCK_SIZE;
Buffer += BLOCK_SIZE;
if (BufferSize > BLOCK_SIZE) {
BufferSize -= BLOCK_SIZE;
} else {
BufferSize = 0;
}
}
gBS->RestoreTPL (OldTpl);
//
// Print result of update.
//
if (!FlashError) {
if (ResetRequired) {
Print (L"\n");
PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATE_SUCCESS), HiiHandle);
} else {
PrintToken (STRING_TOKEN (STR_FWUPDATE_NO_RESET), HiiHandle);
}
} else {
goto Done;
}
}
//
// All flash updates are done so see if the system needs to be reset.
//
if (ResetRequired && !FlashError) {
//
// Update successful.
//
for (Index = 5; Index > 0; Index--) {
PrintToken (STRING_TOKEN (STR_FWUPDATE_SHUTDOWN), HiiHandle, Index);
gBS->Stall (1000000);
}
gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);
PrintToken (STRING_TOKEN (STR_FWUPDATE_MANUAL_RESET), HiiHandle);
CpuDeadLoop ();
}
Done:
//
// Print flash update failure message if error detected.
//
if (FlashError) {
PrintToken (STRING_TOKEN (STR_FWUPDATE_UPDATE_FAILED), HiiHandle, Index);
}
//
// Do cleanup.
//
if (HiiHandle != NULL) {
HiiRemovePackages (HiiHandle);
}
if (FileBuffer) {
gBS->FreePool (FileBuffer);
}
return Status;
}
/***********************************************************************
* HandleCmdLineArgs
* This function handles the command line arguments.
* output: stack size
***********************************************************************/
void HandleCmdLineArgs(
int argc, /* number of command-line arguments */
char *argv[]) /* ptrs to command-line arguments */
{
int argNum; /* argument number */
if (argc > (int) 1) {
for (argNum = (int) 1; argNum < argc; argNum++) {
/* The command line contains an argument. */
if ((strcmp(argv[argNum],"--version") == STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-v") == STRINGS_EQUAL)) {
/* Print version information and exit. */
PrintVersionInfo();
exit(0);
}
else if ((strcmp(argv[argNum],"--help") == STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-h") == STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-?") == STRINGS_EQUAL)) {
/* Print help information and exit. */
PrintHelpInfo();
exit(0);
}
else if ((strcmp(argv[argNum],"--file") == STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-f") == STRINGS_EQUAL)) {
/* Set the name of the output file. */
++argNum;
if (argNum < argc) {
SetFileName(argv[argNum]);
}
else {
printf("*** Output file name not specified. ***\n");
printf("Default output file name will be used.\n");
}
}
else if ((strcmp(argv[argNum],"--time") == STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-t") == STRINGS_EQUAL)) {
/* Set the interrupt period. */
++argNum;
if (argNum < argc) {
SetInterruptPeriod(argv[argNum]);
}
else {
printf("*** Interrupt period not specified. ***\n");
printf("Default interrupt period will be used.\n");
}
}
else if ((strcmp(argv[argNum],"--priority") ==
STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-p") == STRINGS_EQUAL)) {
/* Set the scheduler priority. */
++argNum;
if (argNum < argc) {
SetSchedulerPriority(argv[argNum]);
}
else {
printf("*** Scheduler priority not specified. ***\n");
printf("Default scheduler priority will be used.\n");
}
}
else if ((strcmp(argv[argNum],"--readfile") ==
STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-r") == STRINGS_EQUAL)) {
/* Set the file to read*/
++argNum;
strncpy(ReadFile, argv[argNum], sizeof(ReadFile));
DoRead = TRUE;
}
else if ((strcmp(argv[argNum],"--write_bytes") ==
STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-w") == STRINGS_EQUAL)) {
/* Set the file to read*/
++argNum;
WriteBytes = atoi(argv[argNum]);
if(WriteBytes < MIN_WRITE_BYTES)
{
printf("Writing less than %i bytes is not allowed. Bye.\n",
MIN_WRITE_BYTES);
exit(0);
}
}
else if ((strcmp(argv[argNum],"--consolefile") ==
STRINGS_EQUAL) ||
(strcmp(argv[argNum],"-c") == STRINGS_EQUAL)) {
/* Set the file to log console log on. */
++argNum;
strncpy(LogFile, argv[argNum], sizeof(LogFile));
}
else if ((strcmp(argv[argNum],"--grab_kprofile") ==
STRINGS_EQUAL))
{
/* We will read the /proc/profile file on configurable timeout */
GrabKProfile = TRUE;
++argNum;
/* If the jittter is > this #, then the profile is grabbed. */
ProfileTriggerMSecs = (long) atoi(argv[argNum]);
if(ProfileTriggerMSecs <= 0){
printf("Illegal value for profile trigger threshold.\n");
exit(0);
}
}
else if ((strcmp(argv[argNum],"--siggc") ==
STRINGS_EQUAL))
{
/* We will SIGSTOP/SIGCONT the specified pid */
SignalGCTask = TRUE;
++argNum;
GCTaskPID = atoi(argv[argNum]);
if(ProfileTriggerMSecs <= 0){
printf("Illegal value for JFFS(2) GC task pid.\n");
exit(0);
}
}
else {
/* Unknown argument. Print help information and exit. */
printf("Invalid option %s\n", argv[argNum]);
printf("Try 'JitterTest --help' for more information.\n");
exit(0);
}
}
}
return;
}
int main(int argc, char **argv) {
if (argc == 1)
PrintHelpInfo();
else {
if (!ReadParameter(argc, argv)) {
std::cerr << "Bad Parameters.\n";
return 1;
}
ReadConfig(configFileName);
if (compress) {
// Compress
db_compress::Compressor compressor(outputFileName, schema, config);
int iter_cnt = 0;
while (1) {
std::cout << "Iteration " << ++iter_cnt << " Starts\n";
std::ifstream inFile(inputFileName);
std::string str;
int tuple_cnt = 0;
while (std::getline(inFile,str)) {
std::stringstream sstream(str);
std::string item;
db_compress::Tuple tuple(schema.attr_type.size());
size_t count = 0;
while (std::getline(sstream, item, ',')) {
AppendAttr(&tuple, item, attr_type[count], count);
++ count;
}
// The last item might be empty string
if (str[str.length() - 1] == ',') {
AppendAttr(&tuple, "", attr_type[count], count);
++ count;
}
if (count != attr_type.size()) {
std::cerr << "File Format Error!\n";
}
compressor.ReadTuple(tuple);
if (!compressor.RequireFullPass() &&
++ tuple_cnt >= NonFullPassStopPoint) {
break;
}
}
compressor.EndOfData();
if (!compressor.RequireMoreIterations())
break;
}
} else {
// Decompress
db_compress::Decompressor decompressor(inputFileName, schema);
std::ofstream outFile(outputFileName);
decompressor.Init();
while (decompressor.HasNext()) {
db_compress::Tuple tuple(attr_type.size());
decompressor.ReadNextTuple(&tuple);
for (size_t i = 0; i < attr_type.size(); ++i) {
std::string str = ExtractAttr(tuple, attr_type[i], i);
outFile << str << (i == attr_type.size() - 1 ? '\n' : ',');
}
}
}
}
return 0;
}
