int fs_spiffs_unlink(const char *filename) { struct mount_info *m = &s_fsm; if (!m->valid) return set_errno(EBADF); int res = SPIFFS_remove(&m->fs, (char *) filename); if (res == SPIFFS_OK) fs_close_container(m); return set_spiffs_errno(m, res); }
int _unlink_r(struct _reent *r, const char *filename) { int res = SPIFFS_remove(&fs, get_fixed_filename(filename)); (void) r; set_errno(res); return res; }
// file.remove(filename) //==================================== static int file_remove( lua_State* L ) { size_t len; const char *fname = luaL_checklstring( L, 1, &len ); if( len > SPIFFS_OBJ_NAME_LEN ) return luaL_error(L, "filename too long"); file_close(L); SPIFFS_remove(&fs, (char *)fname); return 0; }
} TEST_END #if !SPIFFS_READ_ONLY TEST(truncate_48) { fs_reset(); u32_t len = SPIFFS_DATA_PAGE_SIZE(FS)/2; s32_t res = test_create_and_write_file("small", len, len); TEST_CHECK_GE(res, 0); spiffs_file fd = SPIFFS_open(FS, "small", SPIFFS_RDWR, 0); TEST_CHECK_GE(fd, 0); spiffs_fd *desc; #if SPIFFS_FILEHDL_OFFSET res = spiffs_fd_get(FS, fd - TEST_SPIFFS_FILEHDL_OFFSET, &desc); #else res = spiffs_fd_get(FS, fd, &desc); #endif TEST_CHECK_GE(res, 0); TEST_CHECK_EQ(desc->size, len); u32_t new_len = len/2; res = spiffs_object_truncate(desc, new_len, 0); TEST_CHECK_GE(res, 0); TEST_CHECK_EQ(desc->size, new_len); res = SPIFFS_close(FS, fd); TEST_CHECK_GE(res, 0); spiffs_stat s; res = SPIFFS_stat(FS, "small", &s); TEST_CHECK_GE(res, 0); TEST_CHECK_EQ(s.size, new_len); res = SPIFFS_remove(FS, "small"); TEST_CHECK_GE(res, 0); fd = SPIFFS_open(FS, "small", SPIFFS_RDWR, 0); TEST_CHECK_LT(fd, 0); TEST_CHECK_EQ(SPIFFS_errno(FS), SPIFFS_ERR_NOT_FOUND); return TEST_RES_OK; } TEST_END
int _rename_r(struct _reent *r, const char *from, const char *to) { /* * POSIX rename requires that in case "to" exists, it be atomically replaced * with "from". The atomic part we can't do, but at least we can do replace. */ int res; { spiffs_stat ss; res = SPIFFS_stat(&fs, (char *) to, &ss); if (res == 0) { SPIFFS_remove(&fs, (char *) to); } } res = SPIFFS_rename(&fs, get_fixed_filename(from), get_fixed_filename(to)); (void) r; set_errno(res); return res; }
int run_file_config(int cfg_count, tfile_conf* cfgs, int max_runs, int max_concurrent_files, int dbg) { int res; tfile *tfiles = malloc(sizeof(tfile) * max_concurrent_files); memset(tfiles, 0, sizeof(tfile) * max_concurrent_files); int run = 0; int cur_config_ix = 0; char name[32]; while (run < max_runs) { if (dbg) printf(" run %i/%i\n", run, max_runs); int i; for (i = 0; i < max_concurrent_files; i++) { sprintf(name, "file%i_%i", (1+run), i); tfile *tf = &tfiles[i]; if (tf->state == 0 && cur_config_ix < cfg_count) { // create a new file strcpy(tf->name, name); tf->state = 1; tf->cfg = cfgs[cur_config_ix]; int size = tfile_get_size(tf->cfg.tsize); if (dbg) printf(" create new %s with cfg %i/%i, size %i\n", name, (1+cur_config_ix), cfg_count, size); if (tf->cfg.tsize == EMPTY) { res = SPIFFS_creat(FS, name, 0); CHECK_RES(res); int pfd = open(make_test_fname(name), O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); close(pfd); int extra_flags = tf->cfg.ttype == APPENDED ? SPIFFS_APPEND : 0; spiffs_file fd = SPIFFS_open(FS, name, extra_flags | SPIFFS_RDWR, 0); CHECK(fd > 0); tf->fd = fd; } else { int extra_flags = tf->cfg.ttype == APPENDED ? SPIFFS_APPEND : 0; spiffs_file fd = SPIFFS_open(FS, name, extra_flags | SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0); CHECK(fd > 0); extra_flags = tf->cfg.ttype == APPENDED ? O_APPEND : 0; int pfd = open(make_test_fname(name), extra_flags | O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); tf->fd = fd; uint8_t *buf = malloc(size); memrand(buf, size); res = SPIFFS_write(FS, fd, buf, size); CHECK_RES(res); write(pfd, buf, size); close(pfd); free(buf); res = read_and_verify(name); CHECK_RES(res); } cur_config_ix++; } else if (tf->state > 0) { // hande file lifecycle switch (tf->cfg.ttype) { case UNTAMPERED: { break; } case APPENDED: { if (dbg) printf(" appending %s\n", tf->name); int size = SPIFFS_DATA_PAGE_SIZE(FS)*3; uint8_t *buf = malloc(size); memrand(buf, size); res = SPIFFS_write(FS, tf->fd, buf, size); CHECK_RES(res); int pfd = open(make_test_fname(tf->name), O_APPEND | O_RDWR); write(pfd, buf, size); close(pfd); free(buf); res = read_and_verify(tf->name); CHECK_RES(res); break; } case MODIFIED: { if (dbg) printf(" modify %s\n", tf->name); spiffs_stat stat; res = SPIFFS_fstat(FS, tf->fd, &stat); CHECK_RES(res); int size = stat.size / tf->cfg.tlife + SPIFFS_DATA_PAGE_SIZE(FS)/3; int offs = (stat.size / tf->cfg.tlife) * tf->state; res = SPIFFS_lseek(FS, tf->fd, offs, SPIFFS_SEEK_SET); CHECK_RES(res); uint8_t *buf = malloc(size); memrand(buf, size); res = SPIFFS_write(FS, tf->fd, buf, size); CHECK_RES(res); int pfd = open(make_test_fname(tf->name), O_RDWR); lseek(pfd, offs, SEEK_SET); write(pfd, buf, size); close(pfd); free(buf); res = read_and_verify(tf->name); CHECK_RES(res); break; } case REWRITTEN: { if (tf->fd > 0) { SPIFFS_close(FS, tf->fd); } if (dbg) printf(" rewriting %s\n", tf->name); spiffs_file fd = SPIFFS_open(FS, tf->name, SPIFFS_TRUNC | SPIFFS_CREAT | SPIFFS_RDWR, 0); CHECK(fd > 0); int pfd = open(make_test_fname(tf->name), O_TRUNC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); tf->fd = fd; int size = tfile_get_size(tf->cfg.tsize); uint8_t *buf = malloc(size); memrand(buf, size); res = SPIFFS_write(FS, fd, buf, size); CHECK_RES(res); write(pfd, buf, size); close(pfd); free(buf); res = read_and_verify(tf->name); CHECK_RES(res); break; } } tf->state++; if (tf->state > tf->cfg.tlife) { // file outlived its time, kill it if (tf->fd > 0) { SPIFFS_close(FS, tf->fd); } if (dbg) printf(" removing %s\n", tf->name); res = read_and_verify(tf->name); CHECK_RES(res); res = SPIFFS_remove(FS, tf->name); CHECK_RES(res); remove(make_test_fname(tf->name)); memset(tf, 0, sizeof(tf)); } } } run++; } free(tfiles); return 0; }
ICACHE_FLASH_ATTR int spiffs_remove(const char *filename) { int res = SPIFFS_remove(&fs, (char *) filename); set_errno(res); return res; }
void fileDelete(const String name) { SPIFFS_remove(&_filesystemStorageHandle, name.c_str()); }
} TEST_END TEST(nodemcu_full_fs_2) { fs_reset_specific(0, 0, 4096*22, 4096, 4096, 256); int res; spiffs_file fd; printf(" fill up system by writing one byte a lot\n"); fd = SPIFFS_open(FS, "test1.txt", SPIFFS_RDWR | SPIFFS_CREAT | SPIFFS_TRUNC, 0); TEST_CHECK(fd > 0); int i; spiffs_stat s; res = SPIFFS_OK; for (i = 0; i < 100*1000; i++) { u8_t buf = 'x'; res = SPIFFS_write(FS, fd, &buf, 1); } int errno = SPIFFS_errno(FS); int res2 = SPIFFS_fstat(FS, fd, &s); TEST_CHECK(res2 == SPIFFS_OK); printf(" >>> file %s size: %i\n", s.name, s.size); TEST_CHECK(errno == SPIFFS_ERR_FULL); SPIFFS_close(FS, fd); res2 = SPIFFS_stat(FS, "test1.txt", &s); TEST_CHECK(res2 == SPIFFS_OK); SPIFFS_clearerr(FS); printf(" create small file\n"); fd = SPIFFS_open(FS, "test2.txt", SPIFFS_RDWR | SPIFFS_CREAT | SPIFFS_TRUNC, 0); #if 0 // before gc in v3.1 TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_OK); TEST_CHECK(fd > 0); for (i = 0; i < 1000; i++) { u8_t buf = 'x'; res = SPIFFS_write(FS, fd, &buf, 1); } TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FULL); res2 = SPIFFS_fstat(FS, fd, &s); TEST_CHECK(res2 == SPIFFS_OK); printf(" >>> file %s size: %i\n", s.name, s.size); TEST_CHECK(s.size == 0); SPIFFS_clearerr(FS); #else TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_FULL); SPIFFS_clearerr(FS); #endif printf(" remove files\n"); res = SPIFFS_remove(FS, "test1.txt"); TEST_CHECK(res == SPIFFS_OK); #if 0 res = SPIFFS_remove(FS, "test2.txt"); TEST_CHECK(res == SPIFFS_OK); #endif printf(" create medium file\n"); fd = SPIFFS_open(FS, "test3.txt", SPIFFS_RDWR | SPIFFS_CREAT | SPIFFS_TRUNC, 0); TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_OK); TEST_CHECK(fd > 0); for (i = 0; i < 20*1000; i++) { u8_t buf = 'x'; res = SPIFFS_write(FS, fd, &buf, 1); } TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_OK); res2 = SPIFFS_fstat(FS, fd, &s); TEST_CHECK(res2 == SPIFFS_OK); printf(" >>> file %s size: %i\n", s.name, s.size); TEST_CHECK(s.size == 20*1000); return TEST_RES_OK; } TEST_END
int _unlink_r(struct _reent *r, const char *filename) { int res = SPIFFS_remove(&fs, (char *) filename); set_errno(res); return res; }