Merge pull request #8994 from tannewt/ww_default_writable

Grab FS lock to test writability

Author: dhalbert

ports/espressif/supervisor/internal_flash.c

@@ -151,7 +151,7 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32
         uint32_t block_address = lba + block;
         uint32_t sector_offset = block_address / blocks_per_sector * SECTOR_SIZE;
         uint8_t block_offset = block_address % blocks_per_sector;
-        if (_cache_lba != block_address) {
+        if (_cache_lba != sector_offset) {
             supervisor_flash_read_blocks(_cache, sector_offset / FILESYSTEM_BLOCK_SIZE, blocks_per_sector);
             _cache_lba = sector_offset;
         }

ports/raspberrypi/supervisor/internal_flash.c

@@ -127,7 +127,7 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32
         uint32_t sector_offset = block_address / blocks_per_sector * SECTOR_SIZE;
         uint8_t block_offset = block_address % blocks_per_sector;
 
-        if (_cache_lba != block_address) {
+        if (_cache_lba != sector_offset) {
             port_internal_flash_flush();
             memcpy(_cache,
                 (void *)(XIP_BASE + CIRCUITPY_CIRCUITPY_DRIVE_START_ADDR + sector_offset),

supervisor/filesystem.h

@@ -41,15 +41,23 @@ void filesystem_set_internal_writable_by_usb(bool usb_writable);
 void filesystem_set_internal_concurrent_write_protection(bool concurrent_write_protection);
 void filesystem_set_writable_by_usb(fs_user_mount_t *vfs, bool usb_writable);
 void filesystem_set_concurrent_write_protection(fs_user_mount_t *vfs, bool concurrent_write_protection);
+
+// Whether user code can modify the filesystem. It doesn't depend on the state
+// of USB. Don't use this for a workflow. In workflows, grab the shared file
+// system lock.
 bool filesystem_is_writable_by_python(fs_user_mount_t *vfs);
+
+// This controls whether USB tries to grab the underlying block device lock
+// during enumeration. If another workflow is modifying the filesystem when this
+// happens, then USB will be readonly.
 bool filesystem_is_writable_by_usb(fs_user_mount_t *vfs);
 
 fs_user_mount_t *filesystem_circuitpy(void);
 fs_user_mount_t *filesystem_for_path(const char *path_in, const char **path_under_mount);
 bool filesystem_native_fatfs(fs_user_mount_t *fs_mount);
 
 // We have two levels of locking. filesystem_* calls grab a shared blockdev lock to allow
-// CircuitPython's fatfs code edit the blocks. blockdev_* class grab a lock to mutate blocks
+// CircuitPython's fatfs code to edit the blocks. blockdev_* calls grab a lock to mutate blocks
 // directly, excluding any filesystem_* locks.
 
 bool filesystem_lock(fs_user_mount_t *fs_mount);

supervisor/shared/web_workflow/web_workflow.c

@@ -698,7 +698,11 @@ static void _reply_directory_json(socketpool_socket_obj_t *socket, _request *req
     uint32_t total_clusters = fatfs->n_fatent - 2;
 
     const char *writable = "false";
-    if (filesystem_is_writable_by_python(fs_mount)) {
+    // Test to see if we can grab the write lock. USB will grab the underlying
+    // blockdev lock once it says it is writable. Unlock immediately since we
+    // aren't actually writing.
+    if (filesystem_lock(fs_mount)) {
+        filesystem_unlock(fs_mount);
         writable = "true";
     }
     mp_printf(&_socket_print,
@@ -920,7 +924,8 @@ static void _reply_with_diskinfo_json(socketpool_socket_obj_t *socket, _request
         size_t total_size = fatfs->n_fatent - 2;
 
         const char *writable = "false";
-        if (filesystem_is_writable_by_python(fs)) {
+        if (filesystem_lock(fs)) {
+            filesystem_unlock(fs);
             writable = "true";
         }
         mp_printf(&_socket_print,