LCOV - code coverage report
Current view: top level - extmod - vfs_lfsx_file.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 106 112 94.6 %
Date: 2022-12-01 09:37:31 Functions: 14 14 100.0 %
Branches: 40 46 87.0 %

           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) 2019-2020 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                 :            : // This file should be compiled when included from vfs_lfs.c.
      28                 :            : #if defined(LFS_BUILD_VERSION)
      29                 :            : 
      30                 :            : #include <stdio.h>
      31                 :            : #include <string.h>
      32                 :            : 
      33                 :            : #include "py/runtime.h"
      34                 :            : #include "py/stream.h"
      35                 :            : #include "py/mperrno.h"
      36                 :            : #include "extmod/vfs.h"
      37                 :            : 
      38                 :       2204 : STATIC void MP_VFS_LFSx(check_open)(MP_OBJ_VFS_LFSx_FILE * self) {
      39         [ -  + ]:       2204 :     if (self->vfs == NULL) {
      40                 :          0 :         mp_raise_ValueError(NULL);
      41                 :            :     }
      42                 :       2204 : }
      43                 :            : 
      44                 :          8 : STATIC void MP_VFS_LFSx(file_print)(const mp_print_t * print, mp_obj_t self_in, mp_print_kind_t kind) {
      45                 :          8 :     (void)self_in;
      46                 :          8 :     (void)kind;
      47                 :          8 :     mp_printf(print, "<io.%s>", mp_obj_get_type_str(self_in));
      48                 :          8 : }
      49                 :            : 
      50                 :        178 : mp_obj_t MP_VFS_LFSx(file_open)(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
      51                 :        178 :     MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
      52                 :            : 
      53                 :        178 :     int flags = 0;
      54                 :        178 :     const mp_obj_type_t *type = &MP_TYPE_VFS_LFSx_(_textio);
      55                 :        178 :     const char *mode_str = mp_obj_str_get_str(mode_in);
      56         [ +  + ]:        584 :     for (; *mode_str; ++mode_str) {
      57                 :        228 :         int new_flags = 0;
      58   [ +  +  +  +  :        228 :         switch (*mode_str) {
             +  +  +  - ]
      59                 :         56 :             case 'r':
      60                 :         56 :                 new_flags = LFSx_MACRO(_O_RDONLY);
      61                 :         56 :                 break;
      62                 :         94 :             case 'w':
      63                 :         94 :                 new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_TRUNC);
      64                 :         94 :                 break;
      65                 :          8 :             case 'x':
      66                 :          8 :                 new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_EXCL);
      67                 :          8 :                 break;
      68                 :          8 :             case 'a':
      69                 :          8 :                 new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_APPEND);
      70                 :          8 :                 break;
      71                 :          4 :             case '+':
      72                 :          4 :                 flags |= LFSx_MACRO(_O_RDWR);
      73                 :          4 :                 break;
      74                 :         40 :             case 'b':
      75                 :         40 :                 type = &MP_TYPE_VFS_LFSx_(_fileio);
      76                 :         40 :                 break;
      77                 :         18 :             case 't':
      78                 :         18 :                 type = &MP_TYPE_VFS_LFSx_(_textio);
      79                 :         18 :                 break;
      80                 :            :         }
      81         [ +  + ]:        228 :         if (new_flags) {
      82         [ -  + ]:        166 :             if (flags) {
      83                 :          0 :                 mp_raise_ValueError(NULL);
      84                 :            :             }
      85                 :            :             flags = new_flags;
      86                 :            :         }
      87                 :            :     }
      88         [ +  + ]:        178 :     if (flags == 0) {
      89                 :         12 :         flags = LFSx_MACRO(_O_RDONLY);
      90                 :            :     }
      91                 :            : 
      92                 :            :     #if LFS_BUILD_VERSION == 1
      93                 :         72 :     MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->prog_size);
      94                 :            :     #else
      95                 :        106 :     MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->cache_size);
      96                 :            :     #endif
      97                 :        178 :     o->base.type = type;
      98                 :        178 :     o->vfs = self;
      99                 :            :     #if !MICROPY_GC_CONSERVATIVE_CLEAR
     100                 :            :     memset(&o->file, 0, sizeof(o->file));
     101                 :            :     memset(&o->cfg, 0, sizeof(o->cfg));
     102                 :            :     #endif
     103                 :        178 :     o->cfg.buffer = &o->file_buffer[0];
     104                 :            : 
     105                 :            :     #if LFS_BUILD_VERSION == 2
     106         [ +  + ]:        106 :     if (self->enable_mtime) {
     107                 :        104 :         lfs_get_mtime(&o->mtime[0]);
     108                 :        104 :         o->attrs[0].type = LFS_ATTR_MTIME;
     109                 :        104 :         o->attrs[0].buffer = &o->mtime[0];
     110                 :        104 :         o->attrs[0].size = sizeof(o->mtime);
     111                 :        104 :         o->cfg.attrs = &o->attrs[0];
     112                 :        104 :         o->cfg.attr_count = MP_ARRAY_SIZE(o->attrs);
     113                 :            :     }
     114                 :            :     #endif
     115                 :            : 
     116                 :        178 :     const char *path = MP_VFS_LFSx(make_path)(self, path_in);
     117                 :        178 :     int ret = LFSx_API(file_opencfg)(&self->lfs, &o->file, path, flags, &o->cfg);
     118         [ +  + ]:        178 :     if (ret < 0) {
     119                 :         12 :         o->vfs = NULL;
     120                 :         12 :         mp_raise_OSError(-ret);
     121                 :            :     }
     122                 :            : 
     123                 :        166 :     return MP_OBJ_FROM_PTR(o);
     124                 :            : }
     125                 :            : 
     126                 :         70 : STATIC mp_obj_t MP_VFS_LFSx(file___exit__)(size_t n_args, const mp_obj_t *args) {
     127                 :         70 :     (void)n_args;
     128                 :         70 :     return mp_stream_close(args[0]);
     129                 :            : }
     130                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(MP_VFS_LFSx(file___exit___obj), 4, 4, MP_VFS_LFSx(file___exit__));
     131                 :            : 
     132                 :         96 : STATIC mp_uint_t MP_VFS_LFSx(file_read)(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
     133                 :         96 :     MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
     134                 :         96 :     MP_VFS_LFSx(check_open)(self);
     135                 :         96 :     LFSx_API(ssize_t) sz = LFSx_API(file_read)(&self->vfs->lfs, &self->file, buf, size);
     136         [ +  + ]:         96 :     if (sz < 0) {
     137                 :          4 :         *errcode = -sz;
     138                 :          4 :         return MP_STREAM_ERROR;
     139                 :            :     }
     140                 :         92 :     return sz;
     141                 :            : }
     142                 :            : 
     143                 :       2080 : STATIC mp_uint_t MP_VFS_LFSx(file_write)(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
     144                 :       2080 :     MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
     145                 :       2080 :     MP_VFS_LFSx(check_open)(self);
     146                 :            :     #if LFS_BUILD_VERSION == 2
     147         [ +  - ]:       1050 :     if (self->vfs->enable_mtime) {
     148                 :       1050 :         lfs_get_mtime(&self->mtime[0]);
     149                 :            :     }
     150                 :            :     #endif
     151                 :       2080 :     LFSx_API(ssize_t) sz = LFSx_API(file_write)(&self->vfs->lfs, &self->file, buf, size);
     152         [ +  + ]:       2080 :     if (sz < 0) {
     153                 :          4 :         *errcode = -sz;
     154                 :          4 :         return MP_STREAM_ERROR;
     155                 :            :     }
     156                 :       2076 :     return sz;
     157                 :            : }
     158                 :            : 
     159                 :        368 : STATIC mp_uint_t MP_VFS_LFSx(file_ioctl)(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     160                 :        368 :     MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
     161                 :            : 
     162         [ +  + ]:        368 :     if (request != MP_STREAM_CLOSE) {
     163                 :         28 :         MP_VFS_LFSx(check_open)(self);
     164                 :            :     }
     165                 :            : 
     166         [ +  + ]:         28 :     if (request == MP_STREAM_SEEK) {
     167                 :         20 :         struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)(uintptr_t)arg;
     168                 :         20 :         int res = LFSx_API(file_seek)(&self->vfs->lfs, &self->file, s->offset, s->whence);
     169         [ +  + ]:         20 :         if (res < 0) {
     170                 :          4 :             *errcode = -res;
     171                 :          4 :             return MP_STREAM_ERROR;
     172                 :            :         }
     173                 :         16 :         res = LFSx_API(file_tell)(&self->vfs->lfs, &self->file);
     174         [ -  + ]:         16 :         if (res < 0) {
     175                 :          0 :             *errcode = -res;
     176                 :          0 :             return MP_STREAM_ERROR;
     177                 :            :         }
     178                 :         16 :         s->offset = res;
     179                 :         16 :         return 0;
     180         [ +  + ]:        348 :     } else if (request == MP_STREAM_FLUSH) {
     181                 :          8 :         int res = LFSx_API(file_sync)(&self->vfs->lfs, &self->file);
     182         [ +  + ]:          8 :         if (res < 0) {
     183                 :          4 :             *errcode = -res;
     184                 :          4 :             return MP_STREAM_ERROR;
     185                 :            :         }
     186                 :            :         return 0;
     187         [ +  - ]:        340 :     } else if (request == MP_STREAM_CLOSE) {
     188         [ +  + ]:        340 :         if (self->vfs == NULL) {
     189                 :            :             return 0;
     190                 :            :         }
     191                 :        166 :         int res = LFSx_API(file_close)(&self->vfs->lfs, &self->file);
     192                 :        166 :         self->vfs = NULL; // indicate a closed file
     193         [ +  + ]:        166 :         if (res < 0) {
     194                 :          4 :             *errcode = -res;
     195                 :          4 :             return MP_STREAM_ERROR;
     196                 :            :         }
     197                 :            :         return 0;
     198                 :            :     } else {
     199                 :          0 :         *errcode = MP_EINVAL;
     200                 :          0 :         return MP_STREAM_ERROR;
     201                 :            :     }
     202                 :            : }
     203                 :            : 
     204                 :            : STATIC const mp_rom_map_elem_t MP_VFS_LFSx(file_locals_dict_table)[] = {
     205                 :            :     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     206                 :            :     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     207                 :            :     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     208                 :            :     { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
     209                 :            :     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     210                 :            :     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
     211                 :            :     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     212                 :            :     { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
     213                 :            :     { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
     214                 :            :     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
     215                 :            :     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
     216                 :            :     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&MP_VFS_LFSx(file___exit___obj)) },
     217                 :            : };
     218                 :            : STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(file_locals_dict), MP_VFS_LFSx(file_locals_dict_table));
     219                 :            : 
     220                 :            : STATIC const mp_stream_p_t MP_VFS_LFSx(fileio_stream_p) = {
     221                 :            :     .read = MP_VFS_LFSx(file_read),
     222                 :            :     .write = MP_VFS_LFSx(file_write),
     223                 :            :     .ioctl = MP_VFS_LFSx(file_ioctl),
     224                 :            : };
     225                 :            : 
     226                 :            : MP_DEFINE_CONST_OBJ_TYPE(
     227                 :            :     MP_TYPE_VFS_LFSx_(_fileio),
     228                 :            :     MP_QSTR_FileIO,
     229                 :            :     MP_TYPE_FLAG_ITER_IS_STREAM,
     230                 :            :     print, MP_VFS_LFSx(file_print),
     231                 :            :     protocol, &MP_VFS_LFSx(fileio_stream_p),
     232                 :            :     locals_dict, &MP_VFS_LFSx(file_locals_dict)
     233                 :            :     );
     234                 :            : 
     235                 :            : STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
     236                 :            :     .read = MP_VFS_LFSx(file_read),
     237                 :            :     .write = MP_VFS_LFSx(file_write),
     238                 :            :     .ioctl = MP_VFS_LFSx(file_ioctl),
     239                 :            :     .is_text = true,
     240                 :            : };
     241                 :            : 
     242                 :            : MP_DEFINE_CONST_OBJ_TYPE(
     243                 :            :     MP_TYPE_VFS_LFSx_(_textio),
     244                 :            :     MP_QSTR_TextIOWrapper,
     245                 :            :     MP_TYPE_FLAG_ITER_IS_STREAM,
     246                 :            :     print, MP_VFS_LFSx(file_print),
     247                 :            :     protocol, &MP_VFS_LFSx(textio_stream_p),
     248                 :            :     locals_dict, &MP_VFS_LFSx(file_locals_dict)
     249                 :            :     );
     250                 :            : 
     251                 :            : #endif // defined(LFS_BUILD_VERSION)

Generated by: LCOV version 1.15-5-g462f71d