int sys_remove(const char *filename, int *ret){
int err;
char *filename_cp;
/* Error check inputs */
if((filename == NULL) || (ret == NULL)){
*ret = -1;
return EINVAL;
}
filename_cp = kmalloc(strlen(filename) + 1);
if(filename_cp == NULL){
*ret = -1;
return ENOMEM;
}
strcpy(filename_cp, filename);
err = vfs_remove(filename_cp);
kfree(filename_cp);
if(err){
*ret = -1;
return err;
}
*ret = 0;
return 0;
}
static void cmd_dele(const char *arg, struct tcp_pcb *pcb, struct ftpd_msgstate *fsm)
{
vfs_stat_t st;
if (arg == NULL) {
send_msg(pcb, fsm, msg501);
return;
}
if (*arg == '\0') {
send_msg(pcb, fsm, msg501);
return;
}
if (vfs_stat(fsm->vfs, arg, &st) != 0) {
send_msg(pcb, fsm, msg550);
return;
}
if (!VFS_ISREG(st.st_mode)) {
send_msg(pcb, fsm, msg550);
return;
}
if (vfs_remove(fsm->vfs, arg) != 0) {
send_msg(pcb, fsm, msg550);
} else {
send_msg(pcb, fsm, msg250);
}
}
static int esp8266_Delete( sqlite3_vfs * vfs, const char * path, int syncDir )
{
sint32_t rc = vfs_remove( path );
if (rc == VFS_RES_ERR)
return SQLITE_IOERR_DELETE;
dbg_printf("esp8266_Delete: %s OK\n", path);
return SQLITE_OK;
}
int
sys_remove(userptr_t p)
{
char pbuf_store[PATH_MAX];
int err;
err = copyinstr(p, pbuf_store, sizeof(pbuf_store), NULL);
if (!err) {
return vfs_remove(pbuf_store);
}
else {
return err;
}
}
static void single_run(int32_t chunksize, int32_t repetitions)
{
errval_t err;
vfs_handle_t handle;
// create file
err = vfs_create(FILENAME, &handle);
assert(err_is_ok(err));
// create chunk containing arbitraty data
uint8_t *chunk = malloc(chunksize);
assert(chunk != NULL);
// start time
printf("Start run with chunksize: %" PRId32 ", repetitions: %" PRId32
"\n", chunksize, repetitions);
cycles_t start_cycles = bench_tsc();
size_t written = 0;
for (int32_t i = 0; i < repetitions; i++) {
err = vfs_write(handle, chunk, chunksize, &written);
assert(err_is_ok(err));
assert(written == chunksize);
}
err = vfs_close(handle);
assert(err_is_ok(err));
// end time
cycles_t end_cycles = bench_tsc();
// evaluation
cycles_t cycles = end_cycles - start_cycles;
uint64_t ms = bench_tsc_to_ms(cycles);
double sec = (double) ms / 1000.0;
int64_t bytes_written = chunksize * repetitions;
double kibibytes_written = (double) bytes_written / 1024.0;
double mebibytes_written = (double) bytes_written / (1024.0 * 1024.0);
double kibps = kibibytes_written / sec;
printf("%" PRId64 " bytes (%.1f KiB, %.1f MiB) written in %" PRIuCYCLES
" cycles (%" PRIu64 " ms, %.1f s) -> %.1f KiB/s\n", bytes_written,
kibibytes_written, mebibytes_written, cycles, ms, sec, kibps);
// cleanup
free(chunk);
err = vfs_remove(FILENAME);
assert(err_is_ok(err));
}
static
int
fstest_remove(const char *fs, const char *namesuffix)
{
char name[32];
char buf[32];
int err;
MAKENAME();
strcpy(buf, name);
err = vfs_remove(buf);
if (err) {
kprintf("Could not remove %s: %s\n", name, strerror(err));
return -1;
}
return 0;
}
static int rm(int argc, char *argv[])
{
if(argc < 2) {
printf("Usage: %s file...\n", argv[0]);
return 1;
}
int ret = 0;
for (int i = 1; i < argc; i++) {
char *path = vfs_path_mkabsolute(cwd, argv[i]);
errval_t err = vfs_remove(path);
free(path);
if (err_is_fail(err)) {
printf("%s: %s\n", argv[i], err_getstring(err));
ret = 1;
}
}
return ret;
}
int syscall_remove(const char *pathname) {
int result = vfs_remove(pathname);
if (result < 0) {
switch(result) {
case VFS_UNUSABLE:
kprintf("Error removing file. File system unusable.\n");
break;
case VFS_INVALID_PARAMS:
kprintf("Error removing file: Invalid params\n");
break;
case VFS_NO_SUCH_FS:
kprintf("Error removing file: No such filesystem\n");
break;
default:
kprintf("Error writing file: unknown error\n");
break;
}
}
return result;
}
/* Deletes the file with name pathname from the file system, fails if
the file is open. Returns 0 on success, or a negative number on
error. */
int syscall_delete(char *pathname) {
return vfs_remove(pathname);
}
int io_remove(const char* pathname) {
return vfs_remove(pathname);
}
static
int
fstest_write(const char *fs, const char *namesuffix,
int stridesize, int stridepos)
{
struct vnode *vn;
int err;
int i;
size_t shouldbytes=0;
size_t bytes=0;
off_t pos=0;
char name[32];
char buf[32];
struct iovec iov;
struct uio ku;
int flags;
KASSERT(sizeof(buf) > strlen(SLOGAN));
MAKENAME();
flags = O_WRONLY|O_CREAT;
if (stridesize == 1) {
flags |= O_TRUNC;
}
/* vfs_open destroys the string it's passed */
strcpy(buf, name);
err = vfs_open(buf, flags, 0664, &vn);
if (err) {
kprintf("Could not open %s for write: %s\n",
name, strerror(err));
return -1;
}
for (i=0; i<NCHUNKS; i++) {
if (i % stridesize != stridepos) {
pos += strlen(SLOGAN);
continue;
}
strcpy(buf, SLOGAN);
rotate(buf, i);
uio_kinit(&iov, &ku, buf, strlen(SLOGAN), pos, UIO_WRITE);
err = VOP_WRITE(vn, &ku);
if (err) {
kprintf("%s: Write error: %s\n", name, strerror(err));
vfs_close(vn);
vfs_remove(name);
return -1;
}
if (ku.uio_resid > 0) {
kprintf("%s: Short write: %lu bytes left over\n",
name, (unsigned long) ku.uio_resid);
vfs_close(vn);
vfs_remove(name);
return -1;
}
bytes += (ku.uio_offset - pos);
shouldbytes += strlen(SLOGAN);
pos = ku.uio_offset;
}
vfs_close(vn);
if (bytes != shouldbytes) {
kprintf("%s: %lu bytes written, should have been %lu!\n",
name, (unsigned long) bytes,
(unsigned long) (NCHUNKS*strlen(SLOGAN)));
vfs_remove(name);
return -1;
}
kprintf("%s: %lu bytes written\n", name, (unsigned long) bytes);
return 0;
}
