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-2018 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 "py/runtime.h"
28 : : #include "py/mperrno.h"
29 : : #include "py/mphal.h"
30 : : #include "py/mpthread.h"
31 : : #include "extmod/vfs.h"
32 : : #include "extmod/vfs_posix.h"
33 : :
34 : : #if MICROPY_VFS_POSIX
35 : :
36 : : #if !MICROPY_ENABLE_FINALISER
37 : : #error "MICROPY_VFS_POSIX requires MICROPY_ENABLE_FINALISER"
38 : : #endif
39 : :
40 : : #include <errno.h>
41 : : #include <stdio.h>
42 : : #include <string.h>
43 : : #include <sys/stat.h>
44 : : #include <unistd.h>
45 : : #include <dirent.h>
46 : : #ifdef _MSC_VER
47 : : #include <direct.h> // For mkdir etc.
48 : : #endif
49 : :
50 : : typedef struct _mp_obj_vfs_posix_t {
51 : : mp_obj_base_t base;
52 : : vstr_t root;
53 : : size_t root_len;
54 : : bool readonly;
55 : : } mp_obj_vfs_posix_t;
56 : :
57 : 230 : STATIC const char *vfs_posix_get_path_str(mp_obj_vfs_posix_t *self, mp_obj_t path) {
58 [ + + ]: 230 : if (self->root_len == 0) {
59 : 82 : return mp_obj_str_get_str(path);
60 : : } else {
61 : 148 : self->root.len = self->root_len;
62 : 148 : vstr_add_str(&self->root, mp_obj_str_get_str(path));
63 : 148 : return vstr_null_terminated_str(&self->root);
64 : : }
65 : : }
66 : :
67 : 3576 : STATIC mp_obj_t vfs_posix_get_path_obj(mp_obj_vfs_posix_t *self, mp_obj_t path) {
68 [ + + ]: 3576 : if (self->root_len == 0) {
69 : : return path;
70 : : } else {
71 : 20 : self->root.len = self->root_len;
72 : 20 : vstr_add_str(&self->root, mp_obj_str_get_str(path));
73 : 20 : return mp_obj_new_str(self->root.buf, self->root.len);
74 : : }
75 : : }
76 : :
77 : 92 : STATIC mp_obj_t vfs_posix_fun1_helper(mp_obj_t self_in, mp_obj_t path_in, int (*f)(const char *)) {
78 : 92 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
79 : 92 : int ret = f(vfs_posix_get_path_str(self, path_in));
80 [ + + ]: 92 : if (ret != 0) {
81 : 8 : mp_raise_OSError(errno);
82 : : }
83 : 84 : return mp_const_none;
84 : : }
85 : :
86 : 9453 : STATIC mp_import_stat_t mp_vfs_posix_import_stat(void *self_in, const char *path) {
87 : 9453 : mp_obj_vfs_posix_t *self = self_in;
88 [ - + ]: 9453 : if (self->root_len != 0) {
89 : 0 : self->root.len = self->root_len;
90 : 0 : vstr_add_str(&self->root, path);
91 : 0 : path = vstr_null_terminated_str(&self->root);
92 : : }
93 : 9453 : struct stat st;
94 [ + + ]: 9453 : if (stat(path, &st) == 0) {
95 [ + + ]: 1618 : if (S_ISDIR(st.st_mode)) {
96 : : return MP_IMPORT_STAT_DIR;
97 [ + - ]: 1532 : } else if (S_ISREG(st.st_mode)) {
98 : 1532 : return MP_IMPORT_STAT_FILE;
99 : : }
100 : : }
101 : : return MP_IMPORT_STAT_NO_EXIST;
102 : : }
103 : :
104 : 3276 : STATIC mp_obj_t vfs_posix_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
105 : 3276 : mp_arg_check_num(n_args, n_kw, 0, 1, false);
106 : :
107 : 3276 : mp_obj_vfs_posix_t *vfs = mp_obj_malloc(mp_obj_vfs_posix_t, type);
108 : 3276 : vstr_init(&vfs->root, 0);
109 [ + + ]: 3276 : if (n_args == 1) {
110 : 6 : vstr_add_str(&vfs->root, mp_obj_str_get_str(args[0]));
111 : 6 : vstr_add_char(&vfs->root, '/');
112 : : }
113 : 3276 : vfs->root_len = vfs->root.len;
114 : 3276 : vfs->readonly = false;
115 : :
116 : 3276 : return MP_OBJ_FROM_PTR(vfs);
117 : : }
118 : :
119 : 3270 : STATIC mp_obj_t vfs_posix_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs) {
120 : 3270 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
121 [ - + ]: 3270 : if (mp_obj_is_true(readonly)) {
122 : 0 : self->readonly = true;
123 : : }
124 [ - + ]: 3270 : if (mp_obj_is_true(mkfs)) {
125 : 0 : mp_raise_OSError(MP_EPERM);
126 : : }
127 : 3270 : return mp_const_none;
128 : : }
129 : : STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_mount_obj, vfs_posix_mount);
130 : :
131 : 8 : STATIC mp_obj_t vfs_posix_umount(mp_obj_t self_in) {
132 : 8 : (void)self_in;
133 : 8 : return mp_const_none;
134 : : }
135 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_umount_obj, vfs_posix_umount);
136 : :
137 : 3576 : STATIC mp_obj_t vfs_posix_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
138 : 3576 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
139 : 3576 : const char *mode = mp_obj_str_get_str(mode_in);
140 [ - + ]: 3576 : if (self->readonly
141 [ # # # # : 0 : && (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL || strchr(mode, '+') != NULL)) {
# # ]
142 : 0 : mp_raise_OSError(MP_EROFS);
143 : : }
144 [ + - ]: 3576 : if (!mp_obj_is_small_int(path_in)) {
145 : 3576 : path_in = vfs_posix_get_path_obj(self, path_in);
146 : : }
147 : 3576 : return mp_vfs_posix_file_open(&mp_type_vfs_posix_textio, path_in, mode_in);
148 : : }
149 : : STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_open_obj, vfs_posix_open);
150 : :
151 : 4 : STATIC mp_obj_t vfs_posix_chdir(mp_obj_t self_in, mp_obj_t path_in) {
152 : 4 : return vfs_posix_fun1_helper(self_in, path_in, chdir);
153 : : }
154 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_chdir_obj, vfs_posix_chdir);
155 : :
156 : 4 : STATIC mp_obj_t vfs_posix_getcwd(mp_obj_t self_in) {
157 : 4 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
158 : 4 : char buf[MICROPY_ALLOC_PATH_MAX + 1];
159 : 4 : const char *ret = getcwd(buf, sizeof(buf));
160 [ - + ]: 4 : if (ret == NULL) {
161 : 0 : mp_raise_OSError(errno);
162 : : }
163 : 4 : ret += self->root_len;
164 : 4 : return mp_obj_new_str(ret, strlen(ret));
165 : : }
166 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(vfs_posix_getcwd_obj, vfs_posix_getcwd);
167 : :
168 : : typedef struct _vfs_posix_ilistdir_it_t {
169 : : mp_obj_base_t base;
170 : : mp_fun_1_t iternext;
171 : : mp_fun_1_t finaliser;
172 : : bool is_str;
173 : : DIR *dir;
174 : : } vfs_posix_ilistdir_it_t;
175 : :
176 : 810 : STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
177 : 810 : vfs_posix_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
178 : :
179 [ + + ]: 810 : if (self->dir == NULL) {
180 : : return MP_OBJ_STOP_ITERATION;
181 : : }
182 : :
183 : 950 : for (;;) {
184 : 870 : MP_THREAD_GIL_EXIT();
185 : 870 : struct dirent *dirent = readdir(self->dir);
186 [ + + ]: 870 : if (dirent == NULL) {
187 : 40 : closedir(self->dir);
188 : 40 : MP_THREAD_GIL_ENTER();
189 : 40 : self->dir = NULL;
190 : 40 : return MP_OBJ_STOP_ITERATION;
191 : : }
192 : 830 : MP_THREAD_GIL_ENTER();
193 : 830 : const char *fn = dirent->d_name;
194 : :
195 [ + + + + : 830 : if (fn[0] == '.' && (fn[1] == 0 || (fn[1] == '.' && fn[2] == 0))) {
+ + + + ]
196 : : // skip . and ..
197 : 80 : continue;
198 : : }
199 : :
200 : : // make 3-tuple with info about this entry
201 : 750 : mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
202 : :
203 [ + + ]: 750 : if (self->is_str) {
204 : 748 : t->items[0] = mp_obj_new_str(fn, strlen(fn));
205 : : } else {
206 : 2 : t->items[0] = mp_obj_new_bytes((const byte *)fn, strlen(fn));
207 : : }
208 : :
209 : : #ifdef _DIRENT_HAVE_D_TYPE
210 : : #ifdef DTTOIF
211 : 750 : t->items[1] = MP_OBJ_NEW_SMALL_INT(DTTOIF(dirent->d_type));
212 : : #else
213 : : if (dirent->d_type == DT_DIR) {
214 : : t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
215 : : } else if (dirent->d_type == DT_REG) {
216 : : t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
217 : : } else {
218 : : t->items[1] = MP_OBJ_NEW_SMALL_INT(dirent->d_type);
219 : : }
220 : : #endif
221 : : #else
222 : : // DT_UNKNOWN should have 0 value on any reasonable system
223 : : t->items[1] = MP_OBJ_NEW_SMALL_INT(0);
224 : : #endif
225 : :
226 : : #ifdef _DIRENT_HAVE_D_INO
227 : 750 : t->items[2] = MP_OBJ_NEW_SMALL_INT(dirent->d_ino);
228 : : #else
229 : : t->items[2] = MP_OBJ_NEW_SMALL_INT(0);
230 : : #endif
231 : :
232 : 750 : return MP_OBJ_FROM_PTR(t);
233 : : }
234 : : }
235 : :
236 : 80 : STATIC mp_obj_t vfs_posix_ilistdir_it_del(mp_obj_t self_in) {
237 : 80 : vfs_posix_ilistdir_it_t *self = MP_OBJ_TO_PTR(self_in);
238 [ + + ]: 80 : if (self->dir != NULL) {
239 : 40 : MP_THREAD_GIL_EXIT();
240 : 40 : closedir(self->dir);
241 : 80 : MP_THREAD_GIL_ENTER();
242 : : }
243 : 80 : return mp_const_none;
244 : : }
245 : :
246 : 80 : STATIC mp_obj_t vfs_posix_ilistdir(mp_obj_t self_in, mp_obj_t path_in) {
247 : 80 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
248 : 80 : vfs_posix_ilistdir_it_t *iter = m_new_obj_with_finaliser(vfs_posix_ilistdir_it_t);
249 : 80 : iter->base.type = &mp_type_polymorph_iter_with_finaliser;
250 : 80 : iter->iternext = vfs_posix_ilistdir_it_iternext;
251 : 80 : iter->finaliser = vfs_posix_ilistdir_it_del;
252 : 80 : iter->is_str = mp_obj_get_type(path_in) == &mp_type_str;
253 : 80 : const char *path = vfs_posix_get_path_str(self, path_in);
254 [ + + ]: 80 : if (path[0] == '\0') {
255 : 2 : path = ".";
256 : : }
257 : 80 : MP_THREAD_GIL_EXIT();
258 : 80 : iter->dir = opendir(path);
259 : 80 : MP_THREAD_GIL_ENTER();
260 [ - + ]: 80 : if (iter->dir == NULL) {
261 : 0 : mp_raise_OSError(errno);
262 : : }
263 : 80 : return MP_OBJ_FROM_PTR(iter);
264 : : }
265 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_ilistdir_obj, vfs_posix_ilistdir);
266 : :
267 : : typedef struct _mp_obj_listdir_t {
268 : : mp_obj_base_t base;
269 : : mp_fun_1_t iternext;
270 : : DIR *dir;
271 : : } mp_obj_listdir_t;
272 : :
273 : 42 : STATIC mp_obj_t vfs_posix_mkdir(mp_obj_t self_in, mp_obj_t path_in) {
274 : 42 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
275 : 42 : const char *path = vfs_posix_get_path_str(self, path_in);
276 : 42 : MP_THREAD_GIL_EXIT();
277 : : #ifdef _WIN32
278 : : int ret = mkdir(path);
279 : : #else
280 : 42 : int ret = mkdir(path, 0777);
281 : : #endif
282 : 42 : MP_THREAD_GIL_ENTER();
283 [ - + ]: 42 : if (ret != 0) {
284 : 0 : mp_raise_OSError(errno);
285 : : }
286 : 42 : return mp_const_none;
287 : : }
288 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_mkdir_obj, vfs_posix_mkdir);
289 : :
290 : 44 : STATIC mp_obj_t vfs_posix_remove(mp_obj_t self_in, mp_obj_t path_in) {
291 : 44 : return vfs_posix_fun1_helper(self_in, path_in, unlink);
292 : : }
293 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_remove_obj, vfs_posix_remove);
294 : :
295 : 2 : STATIC mp_obj_t vfs_posix_rename(mp_obj_t self_in, mp_obj_t old_path_in, mp_obj_t new_path_in) {
296 : 2 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
297 : 2 : const char *old_path = vfs_posix_get_path_str(self, old_path_in);
298 : 2 : const char *new_path = vfs_posix_get_path_str(self, new_path_in);
299 : 2 : MP_THREAD_GIL_EXIT();
300 : 2 : int ret = rename(old_path, new_path);
301 : 2 : MP_THREAD_GIL_ENTER();
302 [ - + ]: 2 : if (ret != 0) {
303 : 0 : mp_raise_OSError(errno);
304 : : }
305 : 2 : return mp_const_none;
306 : : }
307 : : STATIC MP_DEFINE_CONST_FUN_OBJ_3(vfs_posix_rename_obj, vfs_posix_rename);
308 : :
309 : 44 : STATIC mp_obj_t vfs_posix_rmdir(mp_obj_t self_in, mp_obj_t path_in) {
310 : 44 : return vfs_posix_fun1_helper(self_in, path_in, rmdir);
311 : : }
312 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_rmdir_obj, vfs_posix_rmdir);
313 : :
314 : 10 : STATIC mp_obj_t vfs_posix_stat(mp_obj_t self_in, mp_obj_t path_in) {
315 : 10 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
316 : 10 : struct stat sb;
317 : 10 : const char *path = vfs_posix_get_path_str(self, path_in);
318 : 10 : int ret;
319 [ + + - + ]: 10 : MP_HAL_RETRY_SYSCALL(ret, stat(path, &sb), mp_raise_OSError(err));
320 : 2 : mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
321 : 2 : t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.st_mode);
322 : 2 : t->items[1] = mp_obj_new_int_from_uint(sb.st_ino);
323 : 2 : t->items[2] = mp_obj_new_int_from_uint(sb.st_dev);
324 : 2 : t->items[3] = mp_obj_new_int_from_uint(sb.st_nlink);
325 : 2 : t->items[4] = mp_obj_new_int_from_uint(sb.st_uid);
326 : 2 : t->items[5] = mp_obj_new_int_from_uint(sb.st_gid);
327 : 2 : t->items[6] = mp_obj_new_int_from_uint(sb.st_size);
328 : 2 : t->items[7] = mp_obj_new_int_from_uint(sb.st_atime);
329 : 2 : t->items[8] = mp_obj_new_int_from_uint(sb.st_mtime);
330 : 2 : t->items[9] = mp_obj_new_int_from_uint(sb.st_ctime);
331 : 2 : return MP_OBJ_FROM_PTR(t);
332 : : }
333 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_stat_obj, vfs_posix_stat);
334 : :
335 : : #if MICROPY_PY_OS_STATVFS
336 : :
337 : : #ifdef __ANDROID__
338 : : #define USE_STATFS 1
339 : : #endif
340 : :
341 : : #if USE_STATFS
342 : : #include <sys/vfs.h>
343 : : #define STRUCT_STATVFS struct statfs
344 : : #define STATVFS statfs
345 : : #define F_FAVAIL sb.f_ffree
346 : : #define F_NAMEMAX sb.f_namelen
347 : : #define F_FLAG sb.f_flags
348 : : #else
349 : : #include <sys/statvfs.h>
350 : : #define STRUCT_STATVFS struct statvfs
351 : : #define STATVFS statvfs
352 : : #define F_FAVAIL sb.f_favail
353 : : #define F_NAMEMAX sb.f_namemax
354 : : #define F_FLAG sb.f_flag
355 : : #endif
356 : :
357 : 2 : STATIC mp_obj_t vfs_posix_statvfs(mp_obj_t self_in, mp_obj_t path_in) {
358 : 2 : mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
359 : 2 : STRUCT_STATVFS sb;
360 : 2 : const char *path = vfs_posix_get_path_str(self, path_in);
361 : 2 : int ret;
362 [ - + - - ]: 2 : MP_HAL_RETRY_SYSCALL(ret, STATVFS(path, &sb), mp_raise_OSError(err));
363 : 2 : mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
364 : 2 : t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.f_bsize);
365 : 2 : t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.f_frsize);
366 : 2 : t->items[2] = MP_OBJ_NEW_SMALL_INT(sb.f_blocks);
367 : 2 : t->items[3] = MP_OBJ_NEW_SMALL_INT(sb.f_bfree);
368 : 2 : t->items[4] = MP_OBJ_NEW_SMALL_INT(sb.f_bavail);
369 : 2 : t->items[5] = MP_OBJ_NEW_SMALL_INT(sb.f_files);
370 : 2 : t->items[6] = MP_OBJ_NEW_SMALL_INT(sb.f_ffree);
371 : 2 : t->items[7] = MP_OBJ_NEW_SMALL_INT(F_FAVAIL);
372 : 2 : t->items[8] = MP_OBJ_NEW_SMALL_INT(F_FLAG);
373 : 2 : t->items[9] = MP_OBJ_NEW_SMALL_INT(F_NAMEMAX);
374 : 2 : return MP_OBJ_FROM_PTR(t);
375 : : }
376 : : STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_statvfs_obj, vfs_posix_statvfs);
377 : :
378 : : #endif
379 : :
380 : : STATIC const mp_rom_map_elem_t vfs_posix_locals_dict_table[] = {
381 : : { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&vfs_posix_mount_obj) },
382 : : { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&vfs_posix_umount_obj) },
383 : : { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&vfs_posix_open_obj) },
384 : :
385 : : { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&vfs_posix_chdir_obj) },
386 : : { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&vfs_posix_getcwd_obj) },
387 : : { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&vfs_posix_ilistdir_obj) },
388 : : { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&vfs_posix_mkdir_obj) },
389 : : { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&vfs_posix_remove_obj) },
390 : : { MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&vfs_posix_rename_obj) },
391 : : { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&vfs_posix_rmdir_obj) },
392 : : { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&vfs_posix_stat_obj) },
393 : : #if MICROPY_PY_OS_STATVFS
394 : : { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&vfs_posix_statvfs_obj) },
395 : : #endif
396 : : };
397 : : STATIC MP_DEFINE_CONST_DICT(vfs_posix_locals_dict, vfs_posix_locals_dict_table);
398 : :
399 : : STATIC const mp_vfs_proto_t vfs_posix_proto = {
400 : : .import_stat = mp_vfs_posix_import_stat,
401 : : };
402 : :
403 : : MP_DEFINE_CONST_OBJ_TYPE(
404 : : mp_type_vfs_posix,
405 : : MP_QSTR_VfsPosix,
406 : : MP_TYPE_FLAG_NONE,
407 : : make_new, vfs_posix_make_new,
408 : : protocol, &vfs_posix_proto,
409 : : locals_dict, &vfs_posix_locals_dict
410 : : );
411 : :
412 : : #endif // MICROPY_VFS_POSIX
|
