ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/features/storage/flash-journal/flash-journal-strategy-sequ.../strategy.c

270 lines
11 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2016, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "flash-journal-strategy-sequential/flash_journal_private.h"
#include "flash-journal-strategy-sequential/flash_journal_strategy_sequential.h"
#include "support_funcs.h"
#include <string.h>
#include <stdio.h>
SequentialFlashJournal_t *activeJournal;
/* forward declarations */
void mtdHandler(int32_t status, ARM_STORAGE_OPERATION operation);
static inline int32_t mtdGetTotalCapacity(ARM_DRIVER_STORAGE *mtd, uint64_t *capacityP)
{
/* fetch MTD's INFO */
ARM_STORAGE_INFO mtdInfo;
int32_t rc = mtd->GetInfo(&mtdInfo);
if (rc != ARM_DRIVER_OK) {
return JOURNAL_STATUS_STORAGE_API_ERROR;
}
*capacityP = mtdInfo.total_storage;
return JOURNAL_STATUS_OK;
}
static inline int32_t flashJournalStrategySequential_read_sanityChecks(SequentialFlashJournal_t *journal, const void *blob, size_t sizeofBlob)
{
if ((journal == NULL) || (blob == NULL) || (sizeofBlob == 0)) {
return JOURNAL_STATUS_PARAMETER;
}
if ((journal->state == SEQUENTIAL_JOURNAL_STATE_NOT_INITIALIZED) || (journal->state == SEQUENTIAL_JOURNAL_STATE_INIT_SCANNING_LOG_HEADERS)) {
return JOURNAL_STATUS_NOT_INITIALIZED;
}
if (journal->state != SEQUENTIAL_JOURNAL_STATE_INITIALIZED) {
return JOURNAL_STATUS_ERROR; /* journal is in an un-expected state. */
}
// printf("read sanity checks: totalDataRead = %lu, sizeofJournaledBlob = %lu\n", (uint32_t)journal->read.totalDataRead, (uint32_t)journal->info.sizeofJournaledBlob);
if ((journal->info.sizeofJournaledBlob == 0) || (journal->read.totalDataRead == journal->info.sizeofJournaledBlob)) {
journal->read.totalDataRead = 0;
return JOURNAL_STATUS_EMPTY;
}
return JOURNAL_STATUS_OK;
}
static inline int32_t flashJournalStrategySequential_log_sanityChecks(SequentialFlashJournal_t *journal, const void *blob, size_t sizeofBlob)
{
if ((journal == NULL) || (blob == NULL) || (sizeofBlob == 0)) {
return JOURNAL_STATUS_PARAMETER;
}
if ((journal->state == SEQUENTIAL_JOURNAL_STATE_NOT_INITIALIZED) || (journal->state == SEQUENTIAL_JOURNAL_STATE_INIT_SCANNING_LOG_HEADERS)) {
return JOURNAL_STATUS_NOT_INITIALIZED;
}
if ((journal->state != SEQUENTIAL_JOURNAL_STATE_INITIALIZED) && (journal->state != SEQUENTIAL_JOURNAL_STATE_LOGGING_BODY)) {
return JOURNAL_STATUS_ERROR; /* journal is in an un-expected state. */
}
if (journal->state == SEQUENTIAL_JOURNAL_STATE_INITIALIZED) {
if (sizeofBlob > journal->info.capacity) {
return JOURNAL_STATUS_BOUNDED_CAPACITY; /* adding this log chunk would cause us to exceed capacity (write past the tail). */
}
} else if (journal->state == SEQUENTIAL_JOURNAL_STATE_LOGGING_BODY) {
if (journal->log.offset + sizeofBlob > journal->log.tailOffset) {
return JOURNAL_STATUS_BOUNDED_CAPACITY; /* adding this log chunk would cause us to exceed capacity (write past the tail). */
}
}
return JOURNAL_STATUS_OK;
}
static inline int32_t flashJournalStrategySequential_commit_sanityChecks(SequentialFlashJournal_t *journal)
{
if (journal == NULL) {
return JOURNAL_STATUS_PARAMETER;
}
if (journal->state == SEQUENTIAL_JOURNAL_STATE_LOGGING_BODY) {
if (journal->prevCommand != FLASH_JOURNAL_OPCODE_LOG_BLOB) {
return JOURNAL_STATUS_ERROR;
}
if ((journal->log.offset == ARM_STORAGE_INVALID_OFFSET) ||
(journal->log.tailOffset == ARM_STORAGE_INVALID_OFFSET) ||
(journal->log.tailOffset < journal->log.offset) ||
(journal->log.tail.sizeofBlob == 0) ||
(journal->log.tail.sizeofBlob > journal->info.capacity)) {
return JOURNAL_STATUS_ERROR; /* journal is in an un-expected state. */
}
}
return JOURNAL_STATUS_OK;
}
int32_t flashJournalStrategySequential_initialize(FlashJournal_t *_journal,
ARM_DRIVER_STORAGE *mtd,
const FlashJournal_Ops_t *ops,
FlashJournal_Callback_t callback)
{
int32_t rc;
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
journal->state = SEQUENTIAL_JOURNAL_STATE_NOT_INITIALIZED;
/* fetch MTD's total capacity */
uint64_t mtdCapacity;
if ((rc = mtdGetTotalCapacity(mtd, &mtdCapacity)) != JOURNAL_STATUS_OK) {
return rc;
}
ARM_STORAGE_INFO mtdInfo;
if ((rc = mtd->GetInfo(&mtdInfo)) != ARM_DRIVER_OK) {
return JOURNAL_STATUS_STORAGE_API_ERROR;
}
/* initialize the journal structure */
memcpy(&journal->ops, ops, sizeof(FlashJournal_Ops_t));
journal->mtd = mtd;
journal->mtdCapabilities = mtd->GetCapabilities(); /* fetch MTD's capabilities */
journal->sequentialSkip = mtdCapacity / SEQUENTIAL_FLASH_JOURNAL_MAX_LOGGED_BLOBS;
journal->info.capacity = journal->sequentialSkip - (sizeof(SequentialFlashJournalLogHead_t) + sizeof(SequentialFlashJournalLogTail_t)); /* effective capacity */
journal->info.program_unit = mtdInfo.program_unit;
journal->callback = callback;
journal->prevCommand = FLASH_JOURNAL_OPCODE_INITIALIZE;
/* initialize MTD */
ARM_STORAGE_CAPABILITIES mtdCaps = mtd->GetCapabilities();
rc = mtd->Initialize(mtdHandler);
if (rc < ARM_DRIVER_OK) {
memset(journal, 0, sizeof(FlashJournal_t));
return JOURNAL_STATUS_STORAGE_API_ERROR;
}
if ((mtdCaps.asynchronous_ops) && (rc == ARM_DRIVER_OK)) {
return JOURNAL_STATUS_OK; /* we've got pending asynchronous activity. */
}
if ((rc = discoverLatestLoggedBlob(journal)) != JOURNAL_STATUS_OK) {
return rc;
}
return 1; /* synchronous completion */
}
FlashJournal_Status_t flashJournalStrategySequential_getInfo(FlashJournal_t *_journal, FlashJournal_Info_t *infoP)
{
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
memcpy(infoP, &journal->info, sizeof(FlashJournal_Info_t));
return JOURNAL_STATUS_OK;
}
int32_t flashJournalStrategySequential_read(FlashJournal_t *_journal, void *blob, size_t sizeofBlob)
{
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
int32_t rc;
if ((rc = flashJournalStrategySequential_read_sanityChecks(journal, blob, sizeofBlob)) != JOURNAL_STATUS_OK) {
return rc;
}
journal->read.blob = blob;
journal->read.sizeofBlob = sizeofBlob;
if ((journal->prevCommand != FLASH_JOURNAL_OPCODE_READ_BLOB) || (journal->read.totalDataRead == 0)) {
journal->read.offset = journal->mtdStartOffset
+ (journal->currentBlobIndex * journal->sequentialSkip)
+ sizeof(SequentialFlashJournalLogHead_t);
journal->read.totalDataRead = 0;
} else {
/* journal->read.offset is already set from the previous read execution */
// printf("flashJournalStrategySequential_read: continuing read of %lu from offset %lu\n", sizeofBlob, (uint32_t)journal->read.offset);
}
journal->read.dataBeingRead = blob;
journal->read.amountLeftToRead = ((journal->info.sizeofJournaledBlob - journal->read.totalDataRead) < sizeofBlob) ?
(journal->info.sizeofJournaledBlob - journal->read.totalDataRead) : sizeofBlob;
// printf("amount left to read %u\n", journal->read.amountLeftToRead);
journal->state = SEQUENTIAL_JOURNAL_STATE_READING;
journal->prevCommand = FLASH_JOURNAL_OPCODE_READ_BLOB;
return flashJournalStrategySequential_read_progress();
}
int32_t flashJournalStrategySequential_log(FlashJournal_t *_journal, const void *blob, size_t size)
{
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
int32_t rc;
if ((rc = flashJournalStrategySequential_log_sanityChecks(journal, blob, size)) != JOURNAL_STATUS_OK) {
return rc;
}
journal->log.blob = blob;
journal->log.sizeofBlob = size;
if (journal->prevCommand != FLASH_JOURNAL_OPCODE_LOG_BLOB) {
uint32_t logBlobIndex = journal->currentBlobIndex + 1;
if (logBlobIndex == SEQUENTIAL_FLASH_JOURNAL_MAX_LOGGED_BLOBS) {
logBlobIndex = 0;
}
journal->log.eraseOffset = journal->mtdStartOffset + (logBlobIndex * journal->sequentialSkip);
/* ensure that the request is at least as large as the minimum program unit */
if (size < journal->info.program_unit) {
return JOURNAL_STATUS_SMALL_LOG_REQUEST;
}
journal->state = SEQUENTIAL_JOURNAL_STATE_LOGGING_ERASE; /* start with erasing the log region */
journal->prevCommand = FLASH_JOURNAL_OPCODE_LOG_BLOB;
} else {
journal->log.dataBeingLogged = blob;
journal->log.amountLeftToLog = size;
}
return flashJournalStrategySequential_log_progress();
}
int32_t flashJournalStrategySequential_commit(FlashJournal_t *_journal)
{
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
int32_t rc;
if ((rc = flashJournalStrategySequential_commit_sanityChecks(journal)) != JOURNAL_STATUS_OK) {
return rc;
}
if (journal->prevCommand == FLASH_JOURNAL_OPCODE_LOG_BLOB) {
journal->log.offset = journal->log.tailOffset;
journal->log.dataBeingLogged = (const uint8_t *)&journal->log.tail;
journal->log.amountLeftToLog = sizeof(SequentialFlashJournalLogTail_t);
journal->state = SEQUENTIAL_JOURNAL_STATE_LOGGING_TAIL;
} else {
uint32_t logBlobIndex = journal->currentBlobIndex + 1;
if (logBlobIndex == SEQUENTIAL_FLASH_JOURNAL_MAX_LOGGED_BLOBS) {
logBlobIndex = 0;
}
journal->log.eraseOffset = journal->mtdStartOffset + (logBlobIndex * journal->sequentialSkip);
journal->state = SEQUENTIAL_JOURNAL_STATE_LOGGING_ERASE;
}
journal->prevCommand = FLASH_JOURNAL_OPCODE_COMMIT;
return flashJournalStrategySequential_log_progress();
}
int32_t flashJournalStrategySequential_reset(FlashJournal_t *_journal)
{
SequentialFlashJournal_t *journal;
activeJournal = journal = (SequentialFlashJournal_t *)_journal;
journal->state = SEQUENTIAL_JOURNAL_STATE_RESETING;
journal->prevCommand = FLASH_JOURNAL_OPCODE_RESET;
return flashJournalStrategySequential_reset_progress();
}
Reference in New Issue View Git Blame Copy Permalink