Mistake on this page?
Report an issue in GitHub or email us

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...
bool is_valid_read (bd_addr_t addr, bd_size_t size) const
 Convenience function for checking block read validity. More...
bool is_valid_program (bd_addr_t addr, bd_size_t size) const
 Convenience function for checking block program validity. More...
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 BlockDeviceget_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);
}
Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.