vfs.c 10.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
 * This file is part of the MicroPython project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2017 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <stdint.h>
#include <string.h>

#include "py/runtime.h"
#include "py/objstr.h"
#include "py/mperrno.h"
#include "extmod/vfs.h"
34
#include "extmod/vfs_fat.h"
35
36
37
38

#if MICROPY_VFS

// ROOT is 0 so that the default current directory is the root directory
39
40
#define VFS_NONE ((mp_vfs_mount_t*)1)
#define VFS_ROOT ((mp_vfs_mount_t*)0)
41
42
43
44
45

// path is the path to lookup and *path_out holds the path within the VFS
// object (starts with / if an absolute path).
// Returns VFS_ROOT for root dir (and then path_out is undefined) and VFS_NONE
// for path not found.
46
STATIC mp_vfs_mount_t *lookup_path_raw(const char *path, const char **path_out) {
47
48
49
50
51
52
53
54
55
56
57
58
59
    if (path[0] == '/' && path[1] == 0) {
        return VFS_ROOT;
    } else if (MP_STATE_VM(vfs_cur) == VFS_ROOT) {
        // in root dir
        if (path[0] == 0) {
            return VFS_ROOT;
        }
    } else if (*path != '/') {
        // a relative path within a mounted device
        *path_out = path;
        return MP_STATE_VM(vfs_cur);
    }

60
    for (mp_vfs_mount_t *vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
        if (strncmp(path, vfs->str, vfs->len) == 0) {
            if (path[vfs->len] == '/') {
                *path_out = path + vfs->len;
                return vfs;
            } else if (path[vfs->len] == '\0') {
                *path_out = "/";
                return vfs;
            }
        }
    }

    // mount point not found
    return VFS_NONE;
}

// Version of lookup_path_raw that takes and returns uPy string objects.
77
STATIC mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
78
79
    const char *path = mp_obj_str_get_str(path_in);
    const char *p_out;
80
    mp_vfs_mount_t *vfs = lookup_path_raw(path, &p_out);
81
82
83
84
85
86
87
    if (vfs != VFS_NONE && vfs != VFS_ROOT) {
        *path_out = mp_obj_new_str_of_type(mp_obj_get_type(path_in),
            (const byte*)p_out, strlen(p_out));
    }
    return vfs;
}

88
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) {
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
    if (vfs == VFS_NONE) {
        // mount point not found
        mp_raise_OSError(MP_ENODEV);
    }
    if (vfs == VFS_ROOT) {
        // can't do operation on root dir
        mp_raise_OSError(MP_EPERM);
    }
    mp_obj_t meth[n_args + 2];
    mp_load_method(vfs->obj, meth_name, meth);
    if (args != NULL) {
        memcpy(meth + 2, args, n_args * sizeof(*args));
    }
    return mp_call_method_n_kw(n_args, 0, meth);
}

mp_import_stat_t mp_vfs_import_stat(const char *path) {
    const char *path_out;
107
    mp_vfs_mount_t *vfs = lookup_path_raw(path, &path_out);
108
109
110
    if (vfs == VFS_NONE || vfs == VFS_ROOT) {
        return MP_IMPORT_STAT_NO_EXIST;
    }
111
112
113
114
115
116
    #if MICROPY_VFS_FAT
    // fast paths for known VFS types
    if (mp_obj_get_type(vfs->obj) == &mp_fat_vfs_type) {
        return fat_vfs_import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
    }
    #endif
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
    // TODO delegate to vfs.stat() method
    return MP_IMPORT_STAT_NO_EXIST;
}

mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    enum { ARG_readonly, ARG_mkfs };
    static const mp_arg_t allowed_args[] = {
        { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_false} },
        { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_false} },
    };

    // parse args
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all(n_args - 2, pos_args + 2, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);

    // get the mount point
    mp_uint_t mnt_len;
    const char *mnt_str = mp_obj_str_get_data(pos_args[1], &mnt_len);

    // create new object
137
    mp_vfs_mount_t *vfs = m_new_obj(mp_vfs_mount_t);
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
    vfs->str = mnt_str;
    vfs->len = mnt_len;
    vfs->obj = pos_args[0];
    vfs->next = NULL;

    // call the underlying object to do any mounting operation
    mp_vfs_proxy_call(vfs, MP_QSTR_mount, 2, (mp_obj_t*)&args);

    // check that the destination mount point is unused
    const char *path_out;
    if (lookup_path_raw(mp_obj_str_get_str(pos_args[1]), &path_out) != VFS_NONE) {
        mp_raise_OSError(MP_EPERM);
    }

    // insert the vfs into the mount table
153
    mp_vfs_mount_t **vfsp = &MP_STATE_VM(vfs_mount_table);
154
155
156
157
158
159
160
161
162
163
164
    while (*vfsp != NULL) {
        vfsp = &(*vfsp)->next;
    }
    *vfsp = vfs;

    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_mount_obj, 2, mp_vfs_mount);

mp_obj_t mp_vfs_umount(mp_obj_t mnt_in) {
    // remove vfs from the mount table
165
    mp_vfs_mount_t *vfs = NULL;
166
167
168
169
170
    mp_uint_t mnt_len;
    const char *mnt_str = NULL;
    if (MP_OBJ_IS_STR(mnt_in)) {
        mnt_str = mp_obj_str_get_data(mnt_in, &mnt_len);
    }
171
    for (mp_vfs_mount_t **vfsp = &MP_STATE_VM(vfs_mount_table); *vfsp != NULL; vfsp = &(*vfsp)->next) {
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
        if ((mnt_str != NULL && !memcmp(mnt_str, (*vfsp)->str, mnt_len + 1)) || (*vfsp)->obj == mnt_in) {
            vfs = *vfsp;
            *vfsp = (*vfsp)->next;
            break;
        }
    }

    if (vfs == NULL) {
        mp_raise_OSError(MP_EINVAL);
    }

    // if we unmounted the current device then set current to root
    if (MP_STATE_VM(vfs_cur) == vfs) {
        MP_STATE_VM(vfs_cur) = VFS_ROOT;
    }

    // call the underlying object to do any unmounting operation
    mp_vfs_proxy_call(vfs, MP_QSTR_umount, 0, NULL);

    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_umount_obj, mp_vfs_umount);

mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    enum { ARG_file, ARG_mode, ARG_encoding };
    static const mp_arg_t allowed_args[] = {
        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
        { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
    };

    // parse args
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);

206
    mp_vfs_mount_t *vfs = lookup_path((mp_obj_t)args[ARG_file].u_rom_obj, &args[ARG_file].u_obj);
207
208
209
210
211
212
    return mp_vfs_proxy_call(vfs, MP_QSTR_open, 2, (mp_obj_t*)&args);
}
MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_open_obj, 0, mp_vfs_open);

mp_obj_t mp_vfs_chdir(mp_obj_t path_in) {
    mp_obj_t path_out;
213
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
    if (vfs != VFS_ROOT) {
        mp_vfs_proxy_call(vfs, MP_QSTR_chdir, 1, &path_out);
    }
    MP_STATE_VM(vfs_cur) = vfs;
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_chdir_obj, mp_vfs_chdir);

mp_obj_t mp_vfs_getcwd(void) {
    if (MP_STATE_VM(vfs_cur) == VFS_ROOT) {
        return MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
    }
    mp_obj_t cwd_o = mp_vfs_proxy_call(MP_STATE_VM(vfs_cur), MP_QSTR_getcwd, 0, NULL);
    const char *cwd = mp_obj_str_get_str(cwd_o);
    vstr_t vstr;
    vstr_init(&vstr, MP_STATE_VM(vfs_cur)->len + strlen(cwd) + 1);
    vstr_add_strn(&vstr, MP_STATE_VM(vfs_cur)->str, MP_STATE_VM(vfs_cur)->len);
    if (!(cwd[0] == '/' && cwd[1] == 0)) {
        vstr_add_str(&vstr, cwd);
    }
    return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
}
MP_DEFINE_CONST_FUN_OBJ_0(mp_vfs_getcwd_obj, mp_vfs_getcwd);

mp_obj_t mp_vfs_listdir(size_t n_args, const mp_obj_t *args) {
    mp_obj_t path_in;
    if (n_args == 1) {
        path_in = args[0];
    } else {
        path_in = MP_OBJ_NEW_QSTR(MP_QSTR_);
    }

    mp_obj_t path_out;
247
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

    if (vfs == VFS_ROOT) {
        // list the root directory
        mp_obj_t dir_list = mp_obj_new_list(0, NULL);
        for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
            mp_obj_list_append(dir_list, mp_obj_new_str_of_type(mp_obj_get_type(path_in),
                (const byte*)vfs->str + 1, vfs->len - 1));
        }
        return dir_list;
    }

    return mp_vfs_proxy_call(vfs, MP_QSTR_listdir, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vfs_listdir_obj, 0, 1, mp_vfs_listdir);

mp_obj_t mp_vfs_mkdir(mp_obj_t path_in) {
    mp_obj_t path_out;
265
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
266
267
268
269
270
271
    return mp_vfs_proxy_call(vfs, MP_QSTR_mkdir, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_mkdir_obj, mp_vfs_mkdir);

mp_obj_t mp_vfs_remove(mp_obj_t path_in) {
    mp_obj_t path_out;
272
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
273
274
275
276
277
278
    return mp_vfs_proxy_call(vfs, MP_QSTR_remove, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_remove_obj, mp_vfs_remove);

mp_obj_t mp_vfs_rename(mp_obj_t old_path_in, mp_obj_t new_path_in) {
    mp_obj_t args[2];
279
280
    mp_vfs_mount_t *old_vfs = lookup_path(old_path_in, &args[0]);
    mp_vfs_mount_t *new_vfs = lookup_path(new_path_in, &args[1]);
281
282
283
284
285
286
287
288
289
290
    if (old_vfs != new_vfs) {
        // can't rename across filesystems
        mp_raise_OSError(MP_EPERM);
    }
    return mp_vfs_proxy_call(old_vfs, MP_QSTR_rename, 2, args);
}
MP_DEFINE_CONST_FUN_OBJ_2(mp_vfs_rename_obj, mp_vfs_rename);

mp_obj_t mp_vfs_rmdir(mp_obj_t path_in) {
    mp_obj_t path_out;
291
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
292
293
294
295
296
297
    return mp_vfs_proxy_call(vfs, MP_QSTR_rmdir, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_rmdir_obj, mp_vfs_rmdir);

mp_obj_t mp_vfs_stat(mp_obj_t path_in) {
    mp_obj_t path_out;
298
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
299
300
301
302
303
304
    return mp_vfs_proxy_call(vfs, MP_QSTR_stat, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_stat_obj, mp_vfs_stat);

mp_obj_t mp_vfs_statvfs(mp_obj_t path_in) {
    mp_obj_t path_out;
305
    mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
306
307
308
309
310
    return mp_vfs_proxy_call(vfs, MP_QSTR_statvfs, 1, &path_out);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_statvfs_obj, mp_vfs_statvfs);

#endif // MICROPY_VFS