ChainingBlockDevice
ChainingBlockDevice class hierarchy
The ChainingBlockDevice class provides a way to chain together multiple block devices. You can then interact with the chained block devices as if they were a single block device of size equal to the sum of each substorage unit. The ChainingBlockDevice acts as an opposite of the SlicingBlockDevice.
Note that each block device's block size must be a multiple of the other devices' block sizes (512, 1024 and so on).
The constructor takes in an array of block device pointers and provides an object from which you can access the grouped block devices as a single device.
To configure this class, please see our BlockDevice configuration documentation.
ChainingBlockDevice class reference
| Public Member Functions | |
| ChainingBlockDevice (BlockDevice **bds, size_t bd_count) | |
| Lifetime of the memory block device. More... | |
| template<size_t Size> | |
| ChainingBlockDevice (BlockDevice *(&bds)[Size]) | |
| Lifetime of the memory block device. More... | |
| virtual | ~ChainingBlockDevice () |
| Lifetime of the memory block device. More... | |
| virtual int | init () |
| Initialize a block device. More... | |
| virtual int | deinit () |
| Deinitialize a block device. More... | |
| virtual int | sync () |
| Ensure data on storage is in sync with the driver. More... | |
| virtual int | read (void *buffer, bd_addr_t addr, bd_size_t size) |
| Read blocks from a block device. More... | |
| virtual int | program (const void *buffer, bd_addr_t addr, bd_size_t size) |
| Program blocks to a block device. More... | |
| virtual int | erase (bd_addr_t addr, bd_size_t size) |
| Erase blocks on a block device. More... | |
| virtual bd_size_t | get_read_size () const |
| Get the size of a readable block. More... | |
| virtual bd_size_t | get_program_size () const |
| Get the size of a programmable block. More... | |
| virtual bd_size_t | get_erase_size () const |
| Get the size of an eraseable block. More... | |
| virtual bd_size_t | get_erase_size (bd_addr_t addr) const |
| Get the size of an erasable block given address. More... | |
| virtual int | get_erase_value () const |
| Get the value of storage when erased. More... | |
| virtual bd_size_t | size () const |
| Get the total size of the underlying device. More... | |
| virtual const char * | get_type () const |
| Get the BlockDevice class type. More... | |
| virtual int | trim (bd_addr_t addr, bd_size_t size) |
| Mark blocks as no longer in use. More... | |
| virtual bool | is_valid_read (bd_addr_t addr, bd_size_t size) const |
| Convenience function for checking block read validity. More... | |
| virtual bool | is_valid_program (bd_addr_t addr, bd_size_t size) const |
| Convenience function for checking block program validity. More... | |
| virtual bool | is_valid_erase (bd_addr_t addr, bd_size_t size) const |
| Convenience function for checking block erase validity. More... | |
| Static Public Member Functions | |
| static BlockDevice * | get_default_instance () |
| Return the default block device. More... | |
ChainingBlockDevice example
This ChainingBlockDevice example creates a FAT file system across multiple HeapBlockDevices.
#include "mbed.h"
#include "HeapBlockDevice.h"
#include "ChainingBlockDevice.h"
#include "FATFileSystem.h"
int main(void) {
// Create two smaller block devices with
// 64 and 32 blocks of size 512 bytes
HeapBlockDevice mem1(64*512, 512);
HeapBlockDevice mem2(32*512, 512);
// Create a block device backed by mem1 and mem2
// contains 96 blocks of size 512 bytes
BlockDevice *bds[] = {&mem1, &mem2};
ChainingBlockDevice chainmem(bds);
// Format the new chained block device with a FAT filesystem
FATFileSystem::format(&chainmem);
// Create the FAT filesystem instance, files can now be written to
// the FAT filesystem as if to a single 96 x 512 byte storage device
FATFileSystem fat("fat", &chainmem);
}
This ChainingBlockDevice example shows how to program and read back data from a chained group of HeapBlockDevices.
#include "mbed.h"
#include "HeapBlockDevice.h"
#include "ChainingBlockDevice.h"
#define BLOCKSIZE 512
char buffer1[512];
char buffer2[512];
int main(void) {
// Create two smaller block devices with
// 64 and 32 blocks of size 512 bytes
HeapBlockDevice mem1(64*BLOCKSIZE, BLOCKSIZE);
HeapBlockDevice mem2(32*BLOCKSIZE, BLOCKSIZE);
// Create a block device backed by mem1 and mem2
// contains 96 blocks of size 512 bytes
BlockDevice *bds[] = {&mem1, &mem2};
ChainingBlockDevice chainmem(bds);
// Initialize the block devices
chainmem.init();
// Erase the block device to prepare for programming. 64 and 32 refer to
// the respective number of blocks in mem1 and mem2
chainmem.erase(0, (BLOCKSIZE * (64 + 32)));
// Program strings to the block device at byte-addressable locations that
// span both sub blocks. The second program will write past the end of the
// first block
chainmem.program("data for block", 0, BLOCKSIZE);
chainmem.program("Some more data", (65 * BLOCKSIZE), BLOCKSIZE);
// Readback the written values
chainmem.read(&buffer1, 0, BLOCKSIZE);
chainmem.read(&buffer2, (65 * BLOCKSIZE), BLOCKSIZE);
printf("Read back: %s, %s\r\n", buffer1, buffer2);
}
Related content
- SlicingBlockDevice API reference.
- HeapBlockDevice API reference.
- BlockDevice configuration documentation.