Enlarge event queue in test_socket_attach()

Author: betzw

TESTS/netsocket/socket_sigio/main.cpp

@@ -110,7 +110,7 @@ void test_socket_attach() {
 
     // Dispatch event queue
     Thread eventThread;
-    EventQueue queue(4*EVENTS_EVENT_SIZE);
+    EventQueue queue(10*EVENTS_EVENT_SIZE);
     eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
 
     printf("TCP client IP Address is %s\r\n", net->get_ip_address());

features/FEATURE_UVISOR/uvisor-tests.txt

@@ -1 +1 @@
-36664e60639dda2b364e6e8b5ecf9a23116d280a
+70a8b3b546ebfde84cde7f14525a7b754c819e69

features/TESTS/filesystem/heap_block_device/main.cpp

@@ -23,6 +23,11 @@
 
 using namespace utest::v1;
 
+// TODO HACK, replace with available ram/heap property
+#if defined(TARGET_MTB_MTS_XDOT)
+    #error [NOT_SUPPORTED] Insufficient heap for heap block device tests
+#endif
+
 #define TEST_BLOCK_SIZE 128
 #define TEST_BLOCK_DEVICE_SIZE 32*TEST_BLOCK_SIZE
 #define TEST_BLOCK_COUNT 10

features/TESTS/filesystem/mbr_block_device/main.cpp

@@ -24,6 +24,11 @@
 
 using namespace utest::v1;
 
+// TODO HACK, replace with available ram/heap property
+#if defined(TARGET_MTB_MTS_XDOT)
+    #error [NOT_SUPPORTED] Insufficient heap for heap block device tests
+#endif
+
 #define BLOCK_COUNT 16
 #define BLOCK_SIZE 512
 

features/TESTS/filesystem/util_block_device/main.cpp

@@ -26,6 +26,11 @@
 
 using namespace utest::v1;
 
+// TODO HACK, replace with available ram/heap property
+#if defined(TARGET_MTB_MTS_XDOT)
+    #error [NOT_SUPPORTED] Insufficient heap for heap block device tests
+#endif
+
 #define BLOCK_COUNT 16
 #define BLOCK_SIZE 512
 

features/filesystem/bd/BlockDevice.h

@@ -59,6 +59,15 @@ class BlockDevice
      */
     virtual int deinit() = 0;
 
+    /** Ensure data on storage is in sync with the driver
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int sync()
+    {
+        return 0;
+    }
+
     /** Read blocks from a block device
      *
      *  If a failure occurs, it is not possible to determine how many bytes succeeded
@@ -85,7 +94,8 @@ class BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -135,6 +145,20 @@ class BlockDevice
         return get_program_size();
     }
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const
+    {
+        return -1;
+    }
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes

features/filesystem/bd/ChainingBlockDevice.cpp

@@ -20,6 +20,7 @@
 ChainingBlockDevice::ChainingBlockDevice(BlockDevice **bds, size_t bd_count)
     : _bds(bds), _bd_count(bd_count)
     , _read_size(0), _program_size(0), _erase_size(0), _size(0)
+    , _erase_value(-1)
 {
 }
 
@@ -33,6 +34,7 @@ int ChainingBlockDevice::init()
     _read_size = 0;
     _program_size = 0;
     _erase_size = 0;
+    _erase_value = -1;
     _size = 0;
 
     // Initialize children block devices, find all sizes and
@@ -66,6 +68,13 @@ int ChainingBlockDevice::init()
             MBED_ASSERT(_erase_size > erase && is_aligned(_erase_size, erase));
         }
 
+        int value = _bds[i]->get_erase_value();
+        if (i == 0 || value == _erase_value) {
+            _erase_value = value;
+        } else {
+            _erase_value = -1;
+        }
+
         _size += _bds[i]->size();
     }
 
@@ -84,6 +93,18 @@ int ChainingBlockDevice::deinit()
     return 0;
 }
 
+int ChainingBlockDevice::sync()
+{
+    for (size_t i = 0; i < _bd_count; i++) {
+        int err = _bds[i]->sync();
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
 int ChainingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_read(addr, size));
@@ -190,6 +211,11 @@ bd_size_t ChainingBlockDevice::get_erase_size() const
     return _erase_size;
 }
 
+int ChainingBlockDevice::get_erase_value() const
+{
+    return _erase_value;
+}
+
 bd_size_t ChainingBlockDevice::size() const
 {
     return _size;

features/filesystem/bd/ChainingBlockDevice.h

@@ -85,6 +85,12 @@ class ChainingBlockDevice : public BlockDevice
      */
     virtual int deinit();
 
+    /** Ensure data on storage is in sync with the driver
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int sync();
+
     /** Read blocks from a block device
      *
      *  @param buffer   Buffer to write blocks to
@@ -107,7 +113,8 @@ class ChainingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -135,6 +142,17 @@ class ChainingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes
@@ -148,6 +166,7 @@ class ChainingBlockDevice : public BlockDevice
     bd_size_t _program_size;
     bd_size_t _erase_size;
     bd_size_t _size;
+    int _erase_value;
 };
 
 

features/filesystem/bd/ExhaustibleBlockDevice.cpp

@@ -53,6 +53,11 @@ int ExhaustibleBlockDevice::deinit()
     return _bd->deinit();
 }
 
+int ExhaustibleBlockDevice::sync()
+{
+    return _bd->sync();
+}
+
 int ExhaustibleBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
 {
     return _bd->read(buffer, addr, size);
@@ -102,6 +107,11 @@ bd_size_t ExhaustibleBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ExhaustibleBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ExhaustibleBlockDevice::size() const
 {
     return _bd->size();

features/filesystem/bd/ExhaustibleBlockDevice.h

@@ -70,6 +70,12 @@ class ExhaustibleBlockDevice : public BlockDevice
      */
     virtual int deinit();
 
+    /** Ensure data on storage is in sync with the driver
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int sync();
+
     /** Read blocks from a block device
      *
      *  @param buffer   Buffer to read blocks into
@@ -92,7 +98,8 @@ class ExhaustibleBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -118,6 +125,17 @@ class ExhaustibleBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes

features/filesystem/bd/MBRBlockDevice.cpp

@@ -234,6 +234,11 @@ int MBRBlockDevice::deinit()
     return _bd->deinit();
 }
 
+int MBRBlockDevice::sync()
+{
+    return _bd->sync();
+}
+
 int MBRBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size)
 {
     MBED_ASSERT(is_valid_read(addr, size));
@@ -267,6 +272,11 @@ bd_size_t MBRBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int MBRBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t MBRBlockDevice::size() const
 {
     return _size;

features/filesystem/bd/MBRBlockDevice.h

@@ -139,6 +139,12 @@ class MBRBlockDevice : public BlockDevice
      */
     virtual int deinit();
 
+    /** Ensure data on storage is in sync with the driver
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int sync();
+
     /** Read blocks from a block device
      *
      *  @param buffer   Buffer to read blocks into
@@ -161,7 +167,8 @@ class MBRBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -189,6 +196,17 @@ class MBRBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes

features/filesystem/bd/ObservingBlockDevice.cpp

@@ -51,6 +51,11 @@ int ObservingBlockDevice::deinit()
     return _bd->deinit();
 }
 
+int ObservingBlockDevice::sync()
+{
+    return _bd->sync();
+}
+
 int ObservingBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
 {
     return _bd->read(buffer, addr, size);
@@ -91,6 +96,11 @@ bd_size_t ObservingBlockDevice::get_erase_size() const
     return _bd->get_erase_size();
 }
 
+int ObservingBlockDevice::get_erase_value() const
+{
+    return _bd->get_erase_value();
+}
+
 bd_size_t ObservingBlockDevice::size() const
 {
     return _bd->size();

features/filesystem/bd/ObservingBlockDevice.h

@@ -56,6 +56,12 @@ class ObservingBlockDevice : public BlockDevice
      */
     virtual int deinit();
 
+    /** Ensure data on storage is in sync with the driver
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int sync();
+
     /** Read blocks from a block device
      *
      *  @param buffer   Buffer to read blocks into
@@ -78,7 +84,8 @@ class ObservingBlockDevice : public BlockDevice
 
     /** Erase blocks on a block device
      *
-     *  The state of an erased block is undefined until it has been programmed
+     *  The state of an erased block is undefined until it has been programmed,
+     *  unless get_erase_value returns a non-negative byte value
      *
      *  @param addr     Address of block to begin erasing
      *  @param size     Size to erase in bytes, must be a multiple of erase block size
@@ -104,6 +111,17 @@ class ObservingBlockDevice : public BlockDevice
      */
     virtual bd_size_t get_erase_size() const;
 
+    /** Get the value of storage when erased
+     *
+     *  If get_erase_value returns a non-negative byte value, the underlying
+     *  storage is set to that value when erased, and storage containing
+     *  that value can be programmed without another erase.
+     *
+     *  @return         The value of storage when erased, or -1 if you can't
+     *                  rely on the value of erased storage
+     */
+    virtual int get_erase_value() const;
+
     /** Get the total size of the underlying device
      *
      *  @return         Size of the underlying device in bytes