LCOV - code coverage report
Current view: top level - extmod - vfs.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 240 256 93.8 %
Date: 2022-12-01 09:37:31 Functions: 19 20 95.0 %
Branches: 114 130 87.7 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * This file is part of the MicroPython project, http://micropython.org/
       3                 :            :  *
       4                 :            :  * The MIT License (MIT)
       5                 :            :  *
       6                 :            :  * Copyright (c) 2017 Damien P. George
       7                 :            :  *
       8                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
       9                 :            :  * of this software and associated documentation files (the "Software"), to deal
      10                 :            :  * in the Software without restriction, including without limitation the rights
      11                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      12                 :            :  * copies of the Software, and to permit persons to whom the Software is
      13                 :            :  * furnished to do so, subject to the following conditions:
      14                 :            :  *
      15                 :            :  * The above copyright notice and this permission notice shall be included in
      16                 :            :  * all copies or substantial portions of the Software.
      17                 :            :  *
      18                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      19                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      20                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      21                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      22                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      23                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      24                 :            :  * THE SOFTWARE.
      25                 :            :  */
      26                 :            : 
      27                 :            : #include <stdint.h>
      28                 :            : #include <string.h>
      29                 :            : 
      30                 :            : #include "py/runtime.h"
      31                 :            : #include "py/objstr.h"
      32                 :            : #include "py/mperrno.h"
      33                 :            : #include "extmod/vfs.h"
      34                 :            : 
      35                 :            : #if MICROPY_VFS
      36                 :            : 
      37                 :            : #if MICROPY_VFS_FAT
      38                 :            : #include "extmod/vfs_fat.h"
      39                 :            : #endif
      40                 :            : 
      41                 :            : #if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
      42                 :            : #include "extmod/vfs_lfs.h"
      43                 :            : #endif
      44                 :            : 
      45                 :            : #if MICROPY_VFS_POSIX
      46                 :            : #include "extmod/vfs_posix.h"
      47                 :            : #endif
      48                 :            : 
      49                 :            : // For mp_vfs_proxy_call, the maximum number of additional args that can be passed.
      50                 :            : // A fixed maximum size is used to avoid the need for a costly variable array.
      51                 :            : #define PROXY_MAX_ARGS (2)
      52                 :            : 
      53                 :            : // path is the path to lookup and *path_out holds the path within the VFS
      54                 :            : // object (starts with / if an absolute path).
      55                 :            : // Returns MP_VFS_ROOT for root dir (and then path_out is undefined) and
      56                 :            : // MP_VFS_NONE for path not found.
      57                 :      20119 : mp_vfs_mount_t *mp_vfs_lookup_path(const char *path, const char **path_out) {
      58   [ +  +  +  + ]:      20119 :     if (*path == '/' || MP_STATE_VM(vfs_cur) == MP_VFS_ROOT) {
      59                 :            :         // an absolute path, or the current volume is root, so search root dir
      60                 :      12083 :         bool is_abs = 0;
      61         [ +  + ]:      12083 :         if (*path == '/') {
      62                 :      11997 :             ++path;
      63                 :      11997 :             is_abs = 1;
      64                 :            :         }
      65         [ +  + ]:      12083 :         if (*path == '\0') {
      66                 :            :             // path is "" or "/" so return virtual root
      67                 :            :             return MP_VFS_ROOT;
      68                 :            :         }
      69         [ +  + ]:       8983 :         for (mp_vfs_mount_t *vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
      70                 :       8935 :             size_t len = vfs->len - 1;
      71         [ +  + ]:       8935 :             if (len == 0) {
      72                 :       8505 :                 *path_out = path - is_abs;
      73                 :       8505 :                 return vfs;
      74                 :            :             }
      75         [ +  + ]:        430 :             if (strncmp(path, vfs->str + 1, len) == 0) {
      76         [ +  + ]:        262 :                 if (path[len] == '/') {
      77                 :        224 :                     *path_out = path + len;
      78                 :        224 :                     return vfs;
      79         [ +  + ]:         38 :                 } else if (path[len] == '\0') {
      80                 :         30 :                     *path_out = "/";
      81                 :         30 :                     return vfs;
      82                 :            :                 }
      83                 :            :             }
      84                 :            :         }
      85                 :            : 
      86                 :            :         // if we get here then there's nothing mounted on /, so the path doesn't exist
      87                 :            :         return MP_VFS_NONE;
      88                 :            :     }
      89                 :            : 
      90                 :            :     // a relative path within a mounted device
      91                 :       8036 :     *path_out = path;
      92                 :       8036 :     return MP_STATE_VM(vfs_cur);
      93                 :            : }
      94                 :            : 
      95                 :            : // Version of mp_vfs_lookup_path that takes and returns uPy string objects.
      96                 :       3836 : STATIC mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
      97                 :       3836 :     const char *path = mp_obj_str_get_str(path_in);
      98                 :       3836 :     const char *p_out;
      99                 :       3836 :     mp_vfs_mount_t *vfs = mp_vfs_lookup_path(path, &p_out);
     100         [ +  + ]:       3836 :     if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT) {
     101                 :       3742 :         *path_out = mp_obj_new_str_of_type(mp_obj_get_type(path_in),
     102                 :            :             (const byte *)p_out, strlen(p_out));
     103                 :            :     } else {
     104                 :         94 :         *path_out = MP_OBJ_NULL;
     105                 :            :     }
     106                 :       3836 :     return vfs;
     107                 :            : }
     108                 :            : 
     109                 :       7198 : STATIC mp_obj_t mp_vfs_proxy_call(mp_vfs_mount_t *vfs, qstr meth_name, size_t n_args, const mp_obj_t *args) {
     110         [ -  + ]:       7198 :     assert(n_args <= PROXY_MAX_ARGS);
     111         [ +  + ]:       7198 :     if (vfs == MP_VFS_NONE) {
     112                 :            :         // mount point not found
     113                 :         26 :         mp_raise_OSError(MP_ENODEV);
     114                 :            :     }
     115         [ -  + ]:       7172 :     if (vfs == MP_VFS_ROOT) {
     116                 :            :         // can't do operation on root dir
     117                 :          0 :         mp_raise_OSError(MP_EPERM);
     118                 :            :     }
     119                 :       7172 :     mp_obj_t meth[2 + PROXY_MAX_ARGS];
     120                 :       7172 :     mp_load_method(vfs->obj, meth_name, meth);
     121         [ +  + ]:       7172 :     if (args != NULL) {
     122                 :       7112 :         memcpy(meth + 2, args, n_args * sizeof(*args));
     123                 :            :     }
     124                 :       7172 :     return mp_call_method_n_kw(n_args, 0, meth);
     125                 :            : }
     126                 :            : 
     127                 :      13021 : mp_import_stat_t mp_vfs_import_stat(const char *path) {
     128                 :      13021 :     const char *path_out;
     129                 :      13021 :     mp_vfs_mount_t *vfs = mp_vfs_lookup_path(path, &path_out);
     130         [ +  + ]:      13021 :     if (vfs == MP_VFS_NONE || vfs == MP_VFS_ROOT) {
     131                 :            :         return MP_IMPORT_STAT_NO_EXIST;
     132                 :            :     }
     133                 :            : 
     134                 :            :     // If the mounted object has the VFS protocol, call its import_stat helper
     135                 :      13009 :     const mp_obj_type_t *type = mp_obj_get_type(vfs->obj);
     136         [ +  + ]:      13009 :     if (MP_OBJ_TYPE_HAS_SLOT(type, protocol)) {
     137                 :      12917 :         const mp_vfs_proto_t *proto = MP_OBJ_TYPE_GET_SLOT(type, protocol);
     138                 :      12917 :         return proto->import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     139                 :            :     }
     140                 :            : 
     141                 :            :     // delegate to vfs.stat() method
     142                 :         92 :     mp_obj_t path_o = mp_obj_new_str(path_out, strlen(path_out));
     143                 :         92 :     mp_obj_t stat;
     144                 :         92 :     nlr_buf_t nlr;
     145         [ +  + ]:         92 :     if (nlr_push(&nlr) == 0) {
     146                 :         92 :         stat = mp_vfs_proxy_call(vfs, MP_QSTR_stat, 1, &path_o);
     147                 :         32 :         nlr_pop();
     148                 :            :     } else {
     149                 :            :         // assume an exception means that the path is not found
     150                 :            :         return MP_IMPORT_STAT_NO_EXIST;
     151                 :            :     }
     152                 :         32 :     mp_obj_t *items;
     153                 :         32 :     mp_obj_get_array_fixed_n(stat, 10, &items);
     154                 :         32 :     mp_int_t st_mode = mp_obj_get_int(items[0]);
     155         [ +  - ]:         32 :     if (st_mode & MP_S_IFDIR) {
     156                 :            :         return MP_IMPORT_STAT_DIR;
     157                 :            :     } else {
     158                 :         32 :         return MP_IMPORT_STAT_FILE;
     159                 :            :     }
     160                 :            : }
     161                 :            : 
     162                 :         14 : STATIC mp_obj_t mp_vfs_autodetect(mp_obj_t bdev_obj) {
     163                 :            :     #if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
     164                 :         14 :     nlr_buf_t nlr;
     165         [ +  + ]:         14 :     if (nlr_push(&nlr) == 0) {
     166                 :            :         // The superblock for littlefs is in both block 0 and 1, but block 0 may be erased
     167                 :            :         // or partially written, so search both blocks 0 and 1 for the littlefs signature.
     168                 :         14 :         mp_vfs_blockdev_t blockdev;
     169                 :         14 :         mp_vfs_blockdev_init(&blockdev, bdev_obj);
     170                 :         14 :         uint8_t buf[44];
     171         [ +  + ]:         24 :         for (size_t block_num = 0; block_num <= 1; ++block_num) {
     172                 :         20 :             mp_vfs_blockdev_read_ext(&blockdev, block_num, 8, sizeof(buf), buf);
     173                 :            :             #if MICROPY_VFS_LFS1
     174         [ +  + ]:         16 :             if (memcmp(&buf[32], "littlefs", 8) == 0) {
     175                 :            :                 // LFS1
     176                 :          2 :                 mp_obj_t vfs = MP_OBJ_TYPE_GET_SLOT(&mp_type_vfs_lfs1, make_new)(&mp_type_vfs_lfs1, 1, 0, &bdev_obj);
     177                 :          2 :                 nlr_pop();
     178                 :          6 :                 return vfs;
     179                 :            :             }
     180                 :            :             #endif
     181                 :            :             #if MICROPY_VFS_LFS2
     182         [ +  + ]:         14 :             if (memcmp(&buf[0], "littlefs", 8) == 0) {
     183                 :            :                 // LFS2
     184                 :          4 :                 mp_obj_t vfs = MP_OBJ_TYPE_GET_SLOT(&mp_type_vfs_lfs2, make_new)(&mp_type_vfs_lfs2, 1, 0, &bdev_obj);
     185                 :          4 :                 nlr_pop();
     186                 :          4 :                 return vfs;
     187                 :            :             }
     188                 :            :             #endif
     189                 :            :         }
     190                 :          4 :         nlr_pop();
     191                 :            :     } else {
     192                 :            :         // Ignore exception (eg block device doesn't support extended readblocks)
     193                 :          8 :     }
     194                 :            :     #endif
     195                 :            : 
     196                 :            :     #if MICROPY_VFS_FAT
     197                 :          8 :     return MP_OBJ_TYPE_GET_SLOT(&mp_fat_vfs_type, make_new)(&mp_fat_vfs_type, 1, 0, &bdev_obj);
     198                 :            :     #endif
     199                 :            : 
     200                 :            :     // no filesystem found
     201                 :            :     mp_raise_OSError(MP_ENODEV);
     202                 :            : }
     203                 :            : 
     204                 :       3266 : mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     205                 :       3266 :     enum { ARG_readonly, ARG_mkfs };
     206                 :       3266 :     static const mp_arg_t allowed_args[] = {
     207                 :            :         { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_FALSE} },
     208                 :            :         { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_FALSE} },
     209                 :            :     };
     210                 :            : 
     211                 :            :     // parse args
     212                 :       3266 :     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     213                 :       3266 :     mp_arg_parse_all(n_args - 2, pos_args + 2, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     214                 :            : 
     215                 :            :     // get the mount point
     216                 :       3266 :     size_t mnt_len;
     217                 :       3266 :     const char *mnt_str = mp_obj_str_get_data(pos_args[1], &mnt_len);
     218                 :            : 
     219                 :            :     // see if we need to auto-detect and create the filesystem
     220                 :       3266 :     mp_obj_t vfs_obj = pos_args[0];
     221                 :       3266 :     mp_obj_t dest[2];
     222                 :       3266 :     mp_load_method_maybe(vfs_obj, MP_QSTR_mount, dest);
     223         [ +  + ]:       3266 :     if (dest[0] == MP_OBJ_NULL) {
     224                 :            :         // Input object has no mount method, assume it's a block device and try to
     225                 :            :         // auto-detect the filesystem and create the corresponding VFS entity.
     226                 :         14 :         vfs_obj = mp_vfs_autodetect(vfs_obj);
     227                 :            :     }
     228                 :            : 
     229                 :            :     // create new object
     230                 :       3266 :     mp_vfs_mount_t *vfs = m_new_obj(mp_vfs_mount_t);
     231                 :       3266 :     vfs->str = mnt_str;
     232                 :       3266 :     vfs->len = mnt_len;
     233                 :       3266 :     vfs->obj = vfs_obj;
     234                 :       3266 :     vfs->next = NULL;
     235                 :            : 
     236                 :            :     // call the underlying object to do any mounting operation
     237                 :       3266 :     mp_vfs_proxy_call(vfs, MP_QSTR_mount, 2, (mp_obj_t *)&args);
     238                 :            : 
     239                 :            :     // check that the destination mount point is unused
     240                 :       3262 :     const char *path_out;
     241                 :       3262 :     mp_vfs_mount_t *existing_mount = mp_vfs_lookup_path(mp_obj_str_get_str(pos_args[1]), &path_out);
     242         [ +  + ]:       3262 :     if (existing_mount != MP_VFS_NONE && existing_mount != MP_VFS_ROOT) {
     243   [ +  -  +  + ]:         44 :         if (vfs->len != 1 && existing_mount->len == 1) {
     244                 :            :             // if root dir is mounted, still allow to mount something within a subdir of root
     245                 :            :         } else {
     246                 :            :             // mount point in use
     247                 :          2 :             mp_raise_OSError(MP_EPERM);
     248                 :            :         }
     249                 :            :     }
     250                 :            : 
     251                 :            :     // insert the vfs into the mount table
     252                 :            :     mp_vfs_mount_t **vfsp = &MP_STATE_VM(vfs_mount_table);
     253         [ +  + ]:       3262 :     while (*vfsp != NULL) {
     254         [ +  + ]:         44 :         if ((*vfsp)->len == 1) {
     255                 :            :             // make sure anything mounted at the root stays at the end of the list
     256                 :         42 :             vfs->next = *vfsp;
     257                 :         42 :             break;
     258                 :            :         }
     259                 :          2 :         vfsp = &(*vfsp)->next;
     260                 :            :     }
     261                 :       3260 :     *vfsp = vfs;
     262                 :            : 
     263                 :       3260 :     return mp_const_none;
     264                 :            : }
     265                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_mount_obj, 2, mp_vfs_mount);
     266                 :            : 
     267                 :         56 : mp_obj_t mp_vfs_umount(mp_obj_t mnt_in) {
     268                 :            :     // remove vfs from the mount table
     269                 :         56 :     mp_vfs_mount_t *vfs = NULL;
     270                 :         56 :     size_t mnt_len;
     271                 :         56 :     const char *mnt_str = NULL;
     272   [ +  +  +  -  :         56 :     if (mp_obj_is_str(mnt_in)) {
                   -  + ]
     273                 :         48 :         mnt_str = mp_obj_str_get_data(mnt_in, &mnt_len);
     274                 :            :     }
     275         [ +  + ]:         60 :     for (mp_vfs_mount_t **vfsp = &MP_STATE_VM(vfs_mount_table); *vfsp != NULL; vfsp = &(*vfsp)->next) {
     276   [ +  +  +  +  :         58 :         if ((mnt_str != NULL && !memcmp(mnt_str, (*vfsp)->str, mnt_len + 1)) || (*vfsp)->obj == mnt_in) {
                   +  + ]
     277                 :         54 :             vfs = *vfsp;
     278                 :         54 :             *vfsp = (*vfsp)->next;
     279                 :         54 :             break;
     280                 :            :         }
     281                 :            :     }
     282                 :            : 
     283         [ +  + ]:         56 :     if (vfs == NULL) {
     284                 :          2 :         mp_raise_OSError(MP_EINVAL);
     285                 :            :     }
     286                 :            : 
     287                 :            :     // if we unmounted the current device then set current to root
     288         [ +  + ]:         54 :     if (MP_STATE_VM(vfs_cur) == vfs) {
     289                 :         14 :         MP_STATE_VM(vfs_cur) = MP_VFS_ROOT;
     290                 :            :     }
     291                 :            : 
     292                 :            :     // call the underlying object to do any unmounting operation
     293                 :         54 :     mp_vfs_proxy_call(vfs, MP_QSTR_umount, 0, NULL);
     294                 :            : 
     295                 :         54 :     return mp_const_none;
     296                 :            : }
     297                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_umount_obj, mp_vfs_umount);
     298                 :            : 
     299                 :            : // Note: buffering and encoding args are currently ignored
     300                 :       3570 : mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     301                 :       3570 :     enum { ARG_file, ARG_mode, ARG_encoding };
     302                 :       3570 :     static const mp_arg_t allowed_args[] = {
     303                 :            :         { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
     304                 :            :         { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
     305                 :            :         { MP_QSTR_buffering, MP_ARG_INT, {.u_int = -1} },
     306                 :            :         { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     307                 :            :     };
     308                 :            : 
     309                 :            :     // parse args
     310                 :       3570 :     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     311                 :       3570 :     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     312                 :            : 
     313                 :            :     #if MICROPY_VFS_POSIX
     314                 :            :     // If the file is an integer then delegate straight to the POSIX handler
     315         [ +  + ]:       3570 :     if (mp_obj_is_small_int(args[ARG_file].u_obj)) {
     316                 :          2 :         return mp_vfs_posix_file_open(&mp_type_vfs_posix_textio, args[ARG_file].u_obj, args[ARG_mode].u_obj);
     317                 :            :     }
     318                 :            :     #endif
     319                 :            : 
     320                 :       3568 :     mp_vfs_mount_t *vfs = lookup_path(args[ARG_file].u_obj, &args[ARG_file].u_obj);
     321                 :       3568 :     return mp_vfs_proxy_call(vfs, MP_QSTR_open, 2, (mp_obj_t *)&args);
     322                 :            : }
     323                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_open_obj, 0, mp_vfs_open);
     324                 :            : 
     325                 :         30 : mp_obj_t mp_vfs_chdir(mp_obj_t path_in) {
     326                 :         30 :     mp_obj_t path_out;
     327                 :         30 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     328         [ +  + ]:         30 :     if (vfs == MP_VFS_ROOT) {
     329                 :            :         // If we change to the root dir and a VFS is mounted at the root then
     330                 :            :         // we must change that VFS's current dir to the root dir so that any
     331                 :            :         // subsequent relative paths begin at the root of that VFS.
     332         [ +  - ]:          8 :         for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
     333         [ +  + ]:          8 :             if (vfs->len == 1) {
     334                 :          6 :                 mp_obj_t root = MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
     335                 :          6 :                 mp_vfs_proxy_call(vfs, MP_QSTR_chdir, 1, &root);
     336                 :          6 :                 break;
     337                 :            :             }
     338                 :            :         }
     339                 :            :         vfs = MP_VFS_ROOT;
     340                 :            :     } else {
     341                 :         24 :         mp_vfs_proxy_call(vfs, MP_QSTR_chdir, 1, &path_out);
     342                 :            :     }
     343                 :         22 :     MP_STATE_VM(vfs_cur) = vfs;
     344                 :         22 :     return mp_const_none;
     345                 :            : }
     346                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_chdir_obj, mp_vfs_chdir);
     347                 :            : 
     348                 :         18 : mp_obj_t mp_vfs_getcwd(void) {
     349         [ +  + ]:         18 :     if (MP_STATE_VM(vfs_cur) == MP_VFS_ROOT) {
     350                 :            :         return MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
     351                 :            :     }
     352                 :          6 :     mp_obj_t cwd_o = mp_vfs_proxy_call(MP_STATE_VM(vfs_cur), MP_QSTR_getcwd, 0, NULL);
     353         [ +  + ]:          6 :     if (MP_STATE_VM(vfs_cur)->len == 1) {
     354                 :            :         // don't prepend "/" for vfs mounted at root
     355                 :            :         return cwd_o;
     356                 :            :     }
     357                 :          2 :     const char *cwd = mp_obj_str_get_str(cwd_o);
     358                 :          2 :     vstr_t vstr;
     359                 :          2 :     vstr_init(&vstr, MP_STATE_VM(vfs_cur)->len + strlen(cwd) + 1);
     360                 :          2 :     vstr_add_strn(&vstr, MP_STATE_VM(vfs_cur)->str, MP_STATE_VM(vfs_cur)->len);
     361   [ -  +  -  - ]:          2 :     if (!(cwd[0] == '/' && cwd[1] == 0)) {
     362                 :          2 :         vstr_add_str(&vstr, cwd);
     363                 :            :     }
     364                 :          2 :     return mp_obj_new_str_from_vstr(&vstr);
     365                 :            : }
     366                 :            : MP_DEFINE_CONST_FUN_OBJ_0(mp_vfs_getcwd_obj, mp_vfs_getcwd);
     367                 :            : 
     368                 :            : typedef struct _mp_vfs_ilistdir_it_t {
     369                 :            :     mp_obj_base_t base;
     370                 :            :     mp_fun_1_t iternext;
     371                 :            :     union {
     372                 :            :         mp_vfs_mount_t *vfs;
     373                 :            :         mp_obj_t iter;
     374                 :            :     } cur;
     375                 :            :     bool is_str;
     376                 :            :     bool is_iter;
     377                 :            : } mp_vfs_ilistdir_it_t;
     378                 :            : 
     379                 :        136 : STATIC mp_obj_t mp_vfs_ilistdir_it_iternext(mp_obj_t self_in) {
     380                 :        136 :     mp_vfs_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
     381         [ +  + ]:        136 :     if (self->is_iter) {
     382                 :            :         // continue delegating to root dir
     383                 :         72 :         return mp_iternext(self->cur.iter);
     384         [ +  + ]:         64 :     } else if (self->cur.vfs == NULL) {
     385                 :            :         // finished iterating mount points and no root dir is mounted
     386                 :            :         return MP_OBJ_STOP_ITERATION;
     387                 :            :     } else {
     388                 :            :         // continue iterating mount points
     389                 :         44 :         mp_vfs_mount_t *vfs = self->cur.vfs;
     390                 :         44 :         self->cur.vfs = vfs->next;
     391         [ +  + ]:         44 :         if (vfs->len == 1) {
     392                 :            :             // vfs is mounted at root dir, delegate to it
     393                 :         26 :             mp_obj_t root = MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
     394                 :         26 :             self->is_iter = true;
     395                 :         26 :             self->cur.iter = mp_vfs_proxy_call(vfs, MP_QSTR_ilistdir, 1, &root);
     396                 :         26 :             return mp_iternext(self->cur.iter);
     397                 :            :         } else {
     398                 :            :             // a mounted directory
     399                 :         18 :             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
     400                 :         18 :             t->items[0] = mp_obj_new_str_of_type(
     401                 :         18 :                 self->is_str ? &mp_type_str : &mp_type_bytes,
     402         [ -  + ]:         18 :                 (const byte *)vfs->str + 1, vfs->len - 1);
     403                 :         18 :             t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
     404                 :         18 :             t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
     405                 :         18 :             return MP_OBJ_FROM_PTR(t);
     406                 :            :         }
     407                 :            :     }
     408                 :            : }
     409                 :            : 
     410                 :         80 : mp_obj_t mp_vfs_ilistdir(size_t n_args, const mp_obj_t *args) {
     411                 :         80 :     mp_obj_t path_in;
     412         [ +  + ]:         80 :     if (n_args == 1) {
     413                 :         42 :         path_in = args[0];
     414                 :            :     } else {
     415                 :            :         path_in = MP_OBJ_NEW_QSTR(MP_QSTR_);
     416                 :            :     }
     417                 :            : 
     418                 :         80 :     mp_obj_t path_out;
     419                 :         80 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     420                 :            : 
     421         [ +  + ]:         80 :     if (vfs == MP_VFS_ROOT) {
     422                 :            :         // list the root directory
     423                 :         44 :         mp_vfs_ilistdir_it_t *iter = mp_obj_malloc(mp_vfs_ilistdir_it_t, &mp_type_polymorph_iter);
     424                 :         44 :         iter->iternext = mp_vfs_ilistdir_it_iternext;
     425                 :         44 :         iter->cur.vfs = MP_STATE_VM(vfs_mount_table);
     426                 :         44 :         iter->is_str = mp_obj_get_type(path_in) == &mp_type_str;
     427                 :         44 :         iter->is_iter = false;
     428                 :         44 :         return MP_OBJ_FROM_PTR(iter);
     429                 :            :     }
     430                 :            : 
     431                 :         36 :     return mp_vfs_proxy_call(vfs, MP_QSTR_ilistdir, 1, &path_out);
     432                 :            : }
     433                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vfs_ilistdir_obj, 0, 1, mp_vfs_ilistdir);
     434                 :            : 
     435                 :         78 : mp_obj_t mp_vfs_listdir(size_t n_args, const mp_obj_t *args) {
     436                 :         78 :     mp_obj_t iter = mp_vfs_ilistdir(n_args, args);
     437                 :         74 :     mp_obj_t dir_list = mp_obj_new_list(0, NULL);
     438                 :         74 :     mp_obj_t next;
     439         [ +  + ]:        260 :     while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
     440                 :        186 :         mp_obj_list_append(dir_list, mp_obj_subscr(next, MP_OBJ_NEW_SMALL_INT(0), MP_OBJ_SENTINEL));
     441                 :            :     }
     442                 :         74 :     return dir_list;
     443                 :            : }
     444                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vfs_listdir_obj, 0, 1, mp_vfs_listdir);
     445                 :            : 
     446                 :         36 : mp_obj_t mp_vfs_mkdir(mp_obj_t path_in) {
     447                 :         36 :     mp_obj_t path_out;
     448                 :         36 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     449   [ +  +  +  +  :         36 :     if (vfs == MP_VFS_ROOT || (vfs != MP_VFS_NONE && !strcmp(mp_obj_str_get_str(path_out), "/"))) {
                   +  + ]
     450                 :          6 :         mp_raise_OSError(MP_EEXIST);
     451                 :            :     }
     452                 :         30 :     return mp_vfs_proxy_call(vfs, MP_QSTR_mkdir, 1, &path_out);
     453                 :            : }
     454                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_mkdir_obj, mp_vfs_mkdir);
     455                 :            : 
     456                 :         32 : mp_obj_t mp_vfs_remove(mp_obj_t path_in) {
     457                 :         32 :     mp_obj_t path_out;
     458                 :         32 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     459                 :         32 :     return mp_vfs_proxy_call(vfs, MP_QSTR_remove, 1, &path_out);
     460                 :            : }
     461                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_remove_obj, mp_vfs_remove);
     462                 :            : 
     463                 :         18 : mp_obj_t mp_vfs_rename(mp_obj_t old_path_in, mp_obj_t new_path_in) {
     464                 :         18 :     mp_obj_t args[2];
     465                 :         18 :     mp_vfs_mount_t *old_vfs = lookup_path(old_path_in, &args[0]);
     466                 :         18 :     mp_vfs_mount_t *new_vfs = lookup_path(new_path_in, &args[1]);
     467         [ +  + ]:         18 :     if (old_vfs != new_vfs) {
     468                 :            :         // can't rename across filesystems
     469                 :          2 :         mp_raise_OSError(MP_EPERM);
     470                 :            :     }
     471                 :         16 :     return mp_vfs_proxy_call(old_vfs, MP_QSTR_rename, 2, args);
     472                 :            : }
     473                 :            : MP_DEFINE_CONST_FUN_OBJ_2(mp_vfs_rename_obj, mp_vfs_rename);
     474                 :            : 
     475                 :         20 : mp_obj_t mp_vfs_rmdir(mp_obj_t path_in) {
     476                 :         20 :     mp_obj_t path_out;
     477                 :         20 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     478                 :         20 :     return mp_vfs_proxy_call(vfs, MP_QSTR_rmdir, 1, &path_out);
     479                 :            : }
     480                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_rmdir_obj, mp_vfs_rmdir);
     481                 :            : 
     482                 :         28 : mp_obj_t mp_vfs_stat(mp_obj_t path_in) {
     483                 :         28 :     mp_obj_t path_out;
     484                 :         28 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     485         [ +  + ]:         28 :     if (vfs == MP_VFS_ROOT) {
     486                 :         10 :         mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     487                 :         10 :         t->items[0] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR); // st_mode
     488         [ +  + ]:        100 :         for (int i = 1; i <= 9; ++i) {
     489                 :         90 :             t->items[i] = MP_OBJ_NEW_SMALL_INT(0); // dev, nlink, uid, gid, size, atime, mtime, ctime
     490                 :            :         }
     491                 :            :         return MP_OBJ_FROM_PTR(t);
     492                 :            :     }
     493                 :         18 :     return mp_vfs_proxy_call(vfs, MP_QSTR_stat, 1, &path_out);
     494                 :            : }
     495                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_stat_obj, mp_vfs_stat);
     496                 :            : 
     497                 :          6 : mp_obj_t mp_vfs_statvfs(mp_obj_t path_in) {
     498                 :          6 :     mp_obj_t path_out;
     499                 :          6 :     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
     500         [ +  + ]:          6 :     if (vfs == MP_VFS_ROOT) {
     501                 :            :         // statvfs called on the root directory, see if there's anything mounted there
     502         [ +  + ]:          4 :         for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
     503         [ -  + ]:          2 :             if (vfs->len == 1) {
     504                 :            :                 break;
     505                 :            :             }
     506                 :            :         }
     507                 :            : 
     508                 :            :         // If there's nothing mounted at root then return a mostly-empty tuple
     509         [ +  + ]:          4 :         if (vfs == NULL) {
     510                 :          2 :             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     511                 :            : 
     512                 :            :             // fill in: bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flags
     513         [ +  + ]:         20 :             for (int i = 0; i <= 8; ++i) {
     514                 :         18 :                 t->items[i] = MP_OBJ_NEW_SMALL_INT(0);
     515                 :            :             }
     516                 :            : 
     517                 :            :             // Put something sensible in f_namemax
     518                 :          2 :             t->items[9] = MP_OBJ_NEW_SMALL_INT(MICROPY_ALLOC_PATH_MAX);
     519                 :            : 
     520                 :          2 :             return MP_OBJ_FROM_PTR(t);
     521                 :            :         }
     522                 :            : 
     523                 :            :         // VFS mounted at root so delegate the call to it
     524                 :          2 :         path_out = MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
     525                 :            :     }
     526                 :          4 :     return mp_vfs_proxy_call(vfs, MP_QSTR_statvfs, 1, &path_out);
     527                 :            : }
     528                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_statvfs_obj, mp_vfs_statvfs);
     529                 :            : 
     530                 :            : // This is a C-level helper function for ports to use if needed.
     531                 :          0 : int mp_vfs_mount_and_chdir_protected(mp_obj_t bdev, mp_obj_t mount_point) {
     532                 :          0 :     nlr_buf_t nlr;
     533                 :          0 :     mp_int_t ret = -MP_EIO;
     534         [ #  # ]:          0 :     if (nlr_push(&nlr) == 0) {
     535                 :          0 :         mp_obj_t args[] = { bdev, mount_point };
     536                 :          0 :         mp_vfs_mount(2, args, (mp_map_t *)&mp_const_empty_map);
     537                 :          0 :         mp_vfs_chdir(mount_point);
     538                 :          0 :         ret = 0; // success
     539                 :          0 :         nlr_pop();
     540                 :            :     } else {
     541                 :          0 :         mp_obj_base_t *exc = nlr.ret_val;
     542         [ #  # ]:          0 :         if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_OSError))) {
     543                 :          0 :             mp_obj_t v = mp_obj_exception_get_value(MP_OBJ_FROM_PTR(exc));
     544                 :          0 :             mp_obj_get_int_maybe(v, &ret); // get errno value
     545                 :          0 :             ret = -ret;
     546                 :            :         }
     547                 :            :     }
     548                 :          0 :     return ret;
     549                 :            : }
     550                 :            : 
     551                 :            : MP_REGISTER_ROOT_POINTER(struct _mp_vfs_mount_t *vfs_cur);
     552                 :            : MP_REGISTER_ROOT_POINTER(struct _mp_vfs_mount_t *vfs_mount_table);
     553                 :            : 
     554                 :            : #endif // MICROPY_VFS

Generated by: LCOV version 1.15-5-g462f71d