int binfmt_load(struct proc *proc, const char *path, struct proc **ref) { struct vnode vnode; struct inode *inode = NULL; int err = 0; struct uio uio; memset(&uio, 0, sizeof(struct uio)); if (proc) { uio = PROC_UIO(proc); } if ((err = vfs_lookup(path, &uio, &vnode, NULL))) return err; if ((err = vfs_vget(&vnode, &inode))) return err; for (size_t i = 0; i < NR_BINFMT; ++i) { if (!binfmt_list[i].check(inode)) { binfmt_fmt_load(proc, path, inode, &binfmt_list[i], ref); vfs_close(inode); return 0; } } vfs_close(inode); return -ENOEXEC; }
///////////////////////////////////////////////////////////////////// // Mapper 20 bool NES_mapper20::initialize (NES *parent, NES_PPU *ppu) { hfile_t fp = NULL; uint8 header[16]; if (!(NES_mapper::initialize (parent, ppu))) goto error; fp = vfs_open (parent->disksys_rom_filename, VFS_READ); if (!fp) { ERROR("no disksys.rom"); ERROR(parent->disksys_rom_filename); goto error; } if (vfs_read(header, sizeof(header), 1, fp) != sizeof(header)) goto error; if (!NES_MEMCMP (header, "NES", 3)) vfs_seek(fp, 0x6010, VFS_SEEK_SET); else vfs_seek(fp, 0, VFS_SEEK_SET); if (vfs_read(bios, 0x2000, 1, fp) != 0x2000) goto error; vfs_close(fp); return true; error: if (fp) vfs_close(fp); return false; }
void op_write(const char **params, int nparams) { assert(nparams > 1); inode_t *ino = vfs_open(params[0], &dummy_access); if (!ino) { /* Find parent. */ char *str = NULL; int i; for (i = strlen(params[0]); i >= 0; --i) { if (params[0][i] == '/') { str = kmalloc(i+1); strncpy(str, params[0], i); str[i] = '\0'; break; } } assert(str && "Parent directory not found!"); ino = vfs_open(str, &dummy_access); assert(ino && "Parent directory not found!"); vfs_mknod(ino, ¶ms[0][i+1], it_file, 0755, 0, 0); vfs_close(ino); ino = vfs_open(params[0], &dummy_access); assert(ino && "File not found after having created it!"); } assert(ino && "File not found!"); assert(ino->type == it_file && "File is not a regular file!"); vfs_write(ino, 0, (void*)params[1], strlen(params[1])); vfs_close(ino); }
int runprogram(char *progname) { struct addrspace *as; struct vnode *v; vaddr_t entrypoint, stackptr; int result; /* Open the file. */ result = vfs_open(progname, O_RDONLY, 0, &v); if (result) { return result; } /* We should be a new process. */ KASSERT(curproc_getas() == NULL); /* Create a new address space. */ #if OPT_A3 as = as_create(progname); #else as = as_create(); #endif if (as ==NULL) { vfs_close(v); return ENOMEM; } /* Switch to it and activate it. */ curproc_setas(as); as_activate(); /* Load the executable. */ result = load_elf(v, &entrypoint); if (result) { /* p_addrspace will go away when curproc is destroyed */ vfs_close(v); return result; } /* Done with the file now. */ vfs_close(v); /* Define the user stack in the address space */ result = as_define_stack(as, &stackptr); if (result) { /* p_addrspace will go away when curproc is destroyed */ return result; } /* Warp to user mode. */ enter_new_process(0 /*argc*/, NULL /*userspace addr of argv*/, stackptr, entrypoint); /* enter_new_process does not return. */ panic("enter_new_process returned\n"); return EINVAL; }
BOOL ui_load_onmov_file(void) { partition_t *p_partition = NULL; u32 partition_cnt = 0; u16 file_name[MAX_FILE_PATH] = {0}; hfile_t file = NULL; u8 identify[3] = {0}; u16 *p_line = NULL; partition_cnt = file_list_get_partition(&p_partition); if (partition_cnt > 0) { file_name[0] = p_partition[0].letter[0]; str_asc2uni(":\\onmov.txt", file_name + 1); } #ifdef WIN32 str_asc2uni("C:\\onmov.txt", file_name); #endif file = vfs_open(file_name, VFS_READ); if(file == NULL) { return FALSE; } vfs_read((void *)identify, 1, 2, file); if (strcmp(identify, "\xFF\xFE") && strcmp(identify, "\xFE\xFF")) { vfs_close(file); return FALSE; } p_line = freadline(file); if (p_line != NULL) { mtos_free(p_line); p_line = NULL; } while (TRUE) { p_line = freadline(file); if (p_line == NULL) { break; } parse(p_line); mtos_free(p_line); p_line = NULL; } vfs_close(file); return TRUE; }
static int cmd_vfs_sha256(struct vmm_chardev *cdev, const char *path) { int fd, rc, i; u32 len; size_t buf_rd; u8 buf[VFS_LOAD_BUF_SZ]; struct stat st; struct sha256_context sha256c; sha256_digest_t digest; fd = vfs_open(path, O_RDONLY, 0); if (fd < 0) { vmm_cprintf(cdev, "Failed to open %s\n", path); return fd; } rc = vfs_fstat(fd, &st); if (rc) { vfs_close(fd); vmm_cprintf(cdev, "Failed to stat %s\n", path); return rc; } if (!(st.st_mode & S_IFREG)) { vfs_close(fd); vmm_cprintf(cdev, "Cannot read %s\n", path); return VMM_EINVALID; } len = st.st_size; sha256_init(&sha256c); while (len) { memset(buf, 0, sizeof(buf)); buf_rd = (len < VFS_LOAD_BUF_SZ) ? len : VFS_LOAD_BUF_SZ; buf_rd = vfs_read(fd, buf, buf_rd); if (buf_rd < 1) { break; } sha256_update(&sha256c, buf, buf_rd); } sha256_final(digest, &sha256c); vmm_cprintf(cdev, "SHA-256 Digest: "); for (i = 0; i < SHA256_DIGEST_LEN; i++) vmm_cprintf(cdev, "%x", digest[i]); vmm_cprintf(cdev, "\n"); rc = vfs_close(fd); if (rc) { vmm_cprintf(cdev, "Failed to close %s\n", path); return rc; } return VMM_OK; }
int16_t cron_write_error(struct vfs_file_handle_t * file) { vfs_close(file); /* truncate file */ vfs_close(vfs_open(CRON_FILENAME)); return -1; }
static int cmd_vfs_load(struct vmm_chardev *cdev, physical_addr_t pa, const char *path, u32 off, u32 len) { int fd, rc; size_t buf_rd, rd_count; char buf[VFS_LOAD_BUF_SZ]; struct stat st; fd = vfs_open(path, O_RDONLY, 0); if (fd < 0) { vmm_cprintf(cdev, "Failed to open %s\n", path); return fd; } rc = vfs_fstat(fd, &st); if (rc) { vfs_close(fd); vmm_cprintf(cdev, "Failed to stat %s\n", path); return rc; } if (!(st.st_mode & S_IFREG)) { vfs_close(fd); vmm_cprintf(cdev, "Cannot read %s\n", path); return VMM_EINVALID; } if (off >= st.st_size) { vfs_close(fd); vmm_cprintf(cdev, "Offset greater than file size\n", path); return VMM_EINVALID; } len = ((st.st_size - off) < len) ? (st.st_size - off) : len; rd_count = 0; while (len) { buf_rd = (len < VFS_LOAD_BUF_SZ) ? len : VFS_LOAD_BUF_SZ; buf_rd = vfs_read(fd, buf, buf_rd); if (buf_rd < 1) { break; } vmm_host_memory_write(pa, buf, buf_rd); len -= buf_rd; rd_count += buf_rd; } vmm_cprintf(cdev, "Loaded %d bytes\n", rd_count); rc = vfs_close(fd); if (rc) { vmm_cprintf(cdev, "Failed to close %s\n", path); return rc; } return VMM_OK; }
static void file_open_end(void *token, int err, struct vnode *vn) { dprintf(3, "file_open_end called\n"); assert(token != NULL); cont_file_open_t *cont = (cont_file_open_t*)token; if (err) { cont->callback(cont->token, err, -1); free(cont); return; } // Compare openning permission with file permission int accmode = cont->flags & O_ACCMODE; bool file_readable = vn->sattr.st_mode & S_IRUSR; bool file_writable = vn->sattr.st_mode & S_IWUSR; dprintf(3, "file_readable = %d, file_writable = %d\n", (int)file_readable, (int)file_writable); if ((accmode == O_RDONLY && !file_readable) || (accmode == O_WRONLY && !file_writable) || (accmode == O_RDWR && !(file_readable && file_writable))) { vfs_close(vn, cont->flags); cont->callback(cont->token, EINVAL, -1); free(cont); return; } struct openfile *file; int fd; file = malloc(sizeof(struct openfile)); dprintf(3, "created an openfile at %p\n", file); if (file == NULL) { vfs_close(vn, cont->flags); cont->callback(cont->token, ENOMEM, -1); free(cont); return; } file->of_offset = 0; file->of_accmode = accmode; file->of_refcount = 1; file->of_vnode = vn; /* place the file in the filetable, getting the file descriptor */ err = filetable_placefile(file, &fd); if (err) { free(file); vfs_close(vn, cont->flags); cont->callback(cont->token, err, -1); free(cont); return; } cont->callback(cont->token, 0, fd); free(cont); }
/* * Load program "progname" and start running it in usermode. * Does not return except on error. * * Calls vfs_open on progname and thus may destroy it. */ int runprogram(char *progname) { struct vnode *v; vaddr_t entrypoint, stackptr; int result; /* Open the file. */ result = vfs_open(progname, O_RDONLY, 0, &v); if (result) { return result; } /* We should be a new thread. */ KASSERT(curthread->t_addrspace == NULL); /* Create a new address space. */ curthread->t_addrspace = as_create(); if (curthread->t_addrspace==NULL) { vfs_close(v); return ENOMEM; } curthread->t_filetable = filetable_create(); if(curthread->t_filetable == NULL){ return ENOMEM; } /* Activate it. */ as_activate(curthread->t_addrspace); /* Load the executable. */ result = load_elf(v, &entrypoint); if (result) { /* thread_exit destroys curthread->t_addrspace */ vfs_close(v); return result; } /* Done with the file now. */ vfs_close(v); /* Define the user stack in the address space */ result = as_define_stack(curthread->t_addrspace, &stackptr); if (result) { /* thread_exit destroys curthread->t_addrspace */ return result; } /* Warp to user mode. */ enter_new_process(0 /*argc*/, NULL /*userspace addr of argv*/, stackptr, entrypoint); /* enter_new_process does not return. */ panic("enter_new_process returned\n"); return EINVAL; }
static error_t elf_header_read(char* pathname, struct vfs_file_s **file, Elf32_Ehdr **header) { kmem_req_t req; Elf32_Ehdr *e_header; uint_t refcount; register error_t err; register size_t eh_size; register ssize_t count; if((err = vfs_open(current_task->vfs_cwd, pathname, VFS_O_RDONLY, 0, file))) { printk(ERROR, "\nERROR: elf_header_read: faild to open executable file, error %d\n", err); return err; } eh_size = sizeof(*e_header); req.type = KMEM_GENERIC; req.size = eh_size; req.flags = AF_USER; if((e_header = kmem_alloc(&req)) == NULL) { vfs_close(*file, &refcount); return -ENOMEM; } if((count= vfs_read(*file, (uint8_t*)e_header, eh_size)) != eh_size) { printk(ERROR, "\nERROR: elf_header_read: faild to read ELF header, got %d bytes, expected %d bytes\n", count, eh_size); err = (error_t)count; goto ELF_HEADER_READ_ERR; } if(!(err= elf_isElfHeader(e_header))) { printk(ERROR, "\nERROR: elf_header_read: executable is not in ELF format\n"); goto ELF_HEADER_READ_ERR; } if(!(err= elf_isValidHeader(e_header))) { printk(ERROR, "\nERROR: elf_header_read: not supported Elf\n"); goto ELF_HEADER_READ_ERR; } *header = e_header; return 0; ELF_HEADER_READ_ERR: vfs_close(*file, &refcount); req.ptr = e_header; kmem_free(&req); return -1; }
/* * Load program "progname" and start running it in usermode. * Does not return except on error. * * Calls vfs_open on progname and thus may destroy it. */ int runprogram(char *progname) { struct vnode *v; vaddr_t entrypoint, stackptr; int result; /* Open the file. */ result = vfs_open(progname, O_RDONLY, &v); if (result) { return result; } /* We should be a new thread. */ assert(curthread->t_vmspace == NULL); /* Create a new address space. */ curthread->t_vmspace = as_create(); if (curthread->t_vmspace==NULL) { vfs_close(v); return ENOMEM; } //kprintf("\n in runprogram"); assignPid(); /* Activate it. */ as_activate(curthread->t_vmspace); /* Load the executable. */ result = load_elf(v, &entrypoint); if (result) { /* thread_exit destroys curthread->t_vmspace */ vfs_close(v); return result; } /* Done with the file now. */ vfs_close(v); /* Define the user stack in the address space */ result = as_define_stack(curthread->t_vmspace, &stackptr); if (result) { /* thread_exit destroys curthread->t_vmspace */ return result; } /* Warp to user mode. */ md_usermode(0 /*argc*/, NULL /*userspace addr of argv*/, stackptr, entrypoint); /* md_usermode does not return */ panic("md_usermode returned\n"); return EINVAL; }
/* * Cause the current thread to exit. * * We clean up the parts of the thread structure we don't actually * need to run right away. The rest has to wait until thread_destroy * gets called from exorcise(). */ void thread_exit(void) { if (curthread->t_stack != NULL) { /* * Check the magic number we put on the bottom end of * the stack in thread_fork. If these assertions go * off, it most likely means you overflowed your stack * at some point, which can cause all kinds of * mysterious other things to happen. */ assert(curthread->t_stack[0] == (char)0xae); assert(curthread->t_stack[1] == (char)0x11); assert(curthread->t_stack[2] == (char)0xda); assert(curthread->t_stack[3] == (char)0x33); } #if OPT_A2 vfs_close(curthread->ft[0]->file); vfs_close(curthread->ft[1]->file); vfs_close(curthread->ft[2]->file); #endif splhigh(); if (curthread->t_vmspace) { /* * Do this carefully to avoid race condition with * context switch code. */ struct addrspace *as = curthread->t_vmspace; curthread->t_vmspace = NULL; as_destroy(as); } if (curthread->t_cwd) { VOP_DECREF(curthread->t_cwd); curthread->t_cwd = NULL; } assert(numthreads>0); numthreads--; /* #if OPT_A2 struct process* current = p_table[curthread->pid]; if (current->ppid != -1){ struct process* parent = p_table[current->ppid]; if (parent->waiting) cv_broadcast(parent->exit,parent->exitlock); } #endif */ mi_switch(S_ZOMB); panic("Thread came back from the dead!\n"); }
error_t cp_func(void *param) { char *src_name; char *dest_name; error_t err; uint32_t argc; uint32_t i; ssize_t size; struct vfs_file_s *src_file; struct vfs_file_s *dest_file; ms_args_t *args; uint_t count; /* FIXME to be correctly used */ args = (ms_args_t *) param; argc = args->argc; dest_name = args->argv[argc - 1]; err = 0; if((err=vfs_open(ms_n_cwd,dest_name,VFS_O_WRONLY | VFS_O_CREATE,0,&dest_file))) return err; argc --; for(i=1; i< argc; i++) { src_name = args->argv[i]; if((err=vfs_open(ms_n_cwd,src_name,VFS_O_RDONLY,0,&src_file))){ vfs_close(dest_file, &count); ksh_print("error while opinig %s\n",src_name); return err; } size = 0; while((size = vfs_read(src_file,buffer,BUFFER_SIZE)) > 0) { if((size=vfs_write(dest_file,buffer,size)) < 0) goto CP_FUNC_ERROR; } if(size < 0) goto CP_FUNC_ERROR; vfs_close(src_file, &count); } vfs_close(dest_file,&count); return 0; CP_FUNC_ERROR: vfs_close(src_file,&count); vfs_close(dest_file,&count); return size; }
static void xsync_handle(struct xsync_ctx_t * ctx) { uint8_t buf[PACKET_DATA_MAX]; size_t size; switch(ctx->packet.command) { case XSYNC_COMMAND_ALIVE: size = sprintf((char *)buf, "%s", machine_uniqueid()); xsync_put(XSYNC_COMMAND_ALIVE, buf, size); break; case XSYNC_COMMAND_START: buf[0] = xsync_handle_start(ctx); xsync_put(XSYNC_COMMAND_START, buf, 1); break; case XSYNC_COMMAND_TRANSFER: vfs_write(ctx->fd, (void *)ctx->packet.data, packet_dsize(&ctx->packet)); xsync_put(XSYNC_COMMAND_TRANSFER, 0, 0); break; case XSYNC_COMMAND_STOP: if(ctx->fd > 0) { vfs_close(ctx->fd); ctx->fd = -1; } xsync_put(XSYNC_COMMAND_STOP, 0, 0); break; case XSYNC_COMMAND_SYSTEM: xsync_put(XSYNC_COMMAND_SYSTEM, 0, 0); ctx->quit = 1; if(ctx->fd > 0) { vfs_close(ctx->fd); ctx->fd = -1; } memset(buf, 0, sizeof(buf)); memcpy(buf, &ctx->packet.data[0], packet_dsize(&ctx->packet)); shell_system((const char *)buf); break; default: xsync_put(XSYNC_COMMAND_UNKOWN, 0, 0); break; } }
BOOL ui_find_usb_pgdata_file(void) { hfile_t file = NULL; channel_data_t * p_channel_data = NULL; u32 channel_data_size = 0; u16 filename[MAX_DB_FILE_NAME_LENGTH] = {0}; u32 len = 0; ui_dbase_mk_db_filename(filename, IW_CHANNEL_DATA_FILE_NAME); channel_data_size = sizeof(channel_data_t); p_channel_data = mtos_malloc(channel_data_size); if(NULL == p_channel_data) { OS_PRINTF("@@ %s, p_channel_data malloc failed, size = %d \n", __FUNCTION__, channel_data_size); return FALSE; } memset(p_channel_data, 0, channel_data_size); //open file -- file = vfs_open(filename, VFS_READ); if(file != NULL) { len = vfs_read(p_channel_data, channel_data_size, 1, file); if(len != channel_data_size) { OS_PRINTF("@@ %s :%d \n", __FUNCTION__, __LINE__); vfs_close(file); mtos_free(p_channel_data); return FALSE; } } else { OS_PRINTF("@@ %s :%d \n", __FUNCTION__, __LINE__); vfs_close(file); mtos_free(p_channel_data); return FALSE; } if(p_channel_data->total_pg_num == 0 || p_channel_data->total_tp_num == 0) { mtos_free(p_channel_data); return FALSE; } mtos_free(p_channel_data); return TRUE; }
//-------------------------------------------------------------------------------------------- mad_t * action_check_copy_vfs( mad_t * pmad, const char* loadname ) { /// @details ZZ@> This function copies a model's actions vfs_FILE *fileread; int actiona, actionb; char szOne[16] = EMPTY_CSTR; char szTwo[16] = EMPTY_CSTR; if ( NULL == pmad ) return pmad; fileread = vfs_openRead( loadname ); if ( NULL == fileread ) return pmad; while ( goto_colon( NULL, fileread, btrue ) ) { fget_string( fileread, szOne, SDL_arraysize( szOne ) ); actiona = action_which( szOne[0] ); fget_string( fileread, szTwo, SDL_arraysize( szTwo ) ); actionb = action_which( szTwo[0] ); action_copy_correct( pmad, actiona + 0, actionb + 0 ); action_copy_correct( pmad, actiona + 1, actionb + 1 ); action_copy_correct( pmad, actiona + 2, actionb + 2 ); action_copy_correct( pmad, actiona + 3, actionb + 3 ); } vfs_close( fileread ); return pmad; }
int vfs_dup2(struct thread *t, int oldfd, int newfd) { int ret; struct process *p = get_parent(t); if (!process_fd_exist(p, oldfd)) return -EBADF; if (newfd < 0 || newfd >= PROCESS_MAX_OPEN_FD) return -EBADF; if (p->files[newfd].used) { ret = vfs_close(t, newfd); if (ret < 0) return ret; } spinlock_lock(&p->files_lock); p->files[newfd].used = 1; spinlock_unlock(&p->files_lock); ret = process_dup_file(&p->files[newfd], &p->files[oldfd]); if (ret < 0) { process_free_fd(p, newfd); return ret; } return newfd; }
int sys_close (uint_t fd) { register struct task_s *task; register struct thread_s *this; struct vfs_file_s *file; error_t err; file = NULL; this = current_thread; task = current_task; if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task, fd, &file))) { this->info.errno = EBADFD; return -1; } if((err = vfs_close(file, NULL))) { this->info.errno = err; return -1; } task_fd_put(task, fd); cpu_wbflush(); return 0; }
int sys_close(int fd) { int i; struct file_table *tmp; if (fd < 0 || fd >= MAX_FILE_DESCRIPTOR) return EBADF; if (curthread->fd[fd] == NULL) return EBADF; lock_acquire(curthread->fd[fd]->mutex); curthread->fd[fd]->refcnt--; // Returns void; prints for hard I/O errors so no way to return them if (curthread->fd[fd]->refcnt == 0) vfs_close(curthread->fd[fd]->file); // Free contents of struct (vnode should be freed by vfs_close) if (curthread->fd[fd]->refcnt == 0){ lock_release(curthread->fd[fd]->mutex); lock_destroy(curthread->fd[fd]->mutex); kfree(curthread->fd[fd]); // Clear all references to this table tmp = curthread->fd[fd]; for (i=0; i<MAX_FILE_DESCRIPTOR; i++){ if (curthread->fd[i] == tmp) curthread->fd[fd] = NULL; } } else lock_release(curthread->fd[fd]->mutex); curthread->fd[fd] = NULL; return 0; }
static int touch(int argc, char *argv[]) { if(argc < 2) { printf("Usage: %s [file...]\n", argv[0]); return 1; } vfs_handle_t vh; errval_t err; int ret = 0; for (int i = 1; i < argc; i++) { char *path = vfs_path_mkabsolute(cwd, argv[i]); err = vfs_create(path, &vh); free(path); if (err_is_fail(err)) { printf("%s: %s\n", argv[i], err_getstring(err)); DEBUG_ERR(err, "vfs_create failed"); ret = 1; continue; } err = vfs_close(vh); if (err_is_fail(err)) { DEBUG_ERR(err, "in vfs_close"); } } return ret; }
/* * file_close * Called when a process closes a file descriptor. */ int file_close(int fd) { DEBUG(DB_VFS, "*** Closing fd %d\n", fd); struct filetable *ft = curthread->t_filetable; spinlock_acquire(&ft->ft_spinlock); /* if fd is not a valid file descriptor, return error */ if ((fd < 0) || (fd >= __OPEN_MAX) || (ft->ft_entries[fd] == NULL) || (ft->ft_entries[fd]->ft_vnode == NULL)) { spinlock_release(&ft->ft_spinlock); return EBADF; } /* If there is no other fd pointing to this entry, close the file. */ ft->ft_entries[fd]->ft_count--; if (ft->ft_entries[fd]->ft_count == 0) { vfs_close(ft->ft_entries[fd]->ft_vnode); kfree(ft->ft_entries[fd]); } /*Remove entry from file table. */ ft->ft_entries[fd] = NULL; spinlock_release(&ft->ft_spinlock); return 0; }
int access(const char *pathname, int mode) { vfs_handle_t vh; errval_t err; int ret; char *path = vfs_path_mkabs(pathname); assert(path != NULL); err = vfs_open(path, &vh); if (err_is_fail(err)) { if(err_no(err) == FS_ERR_NOTFILE) { // Is it a directory? err = vfs_opendir(path, &vh); if(err_is_ok(err)) { vfs_closedir(vh); ret = 0; goto out; } } POSIXCOMPAT_DEBUG("access(%s) failed\n", pathname); ret = -1; } else { POSIXCOMPAT_DEBUG("access(%s): OK\n", pathname); vfs_close(vh); ret = 0; } out: free(path); return ret; }
/********************************************************************************************************* ** Function name: vfs_dup2 ** Descriptions: 复制文件描述符到指定的文件描述符 ** input parameters: fd 文件描述符 ** to 指定的文件描述符 ** output parameters: NONE ** Returned value: 0 OR -1 *********************************************************************************************************/ int vfs_dup2(int fd, int to) { int ret; pid_t pid = getpid(); vfs_file_begin(pid); ret = vfs_close(to); if (ret < 0) { vfs_file_end(pid); return ret; } mutex_lock(&info_lock[pid], 0); info->files[to] = file; mutex_unlock(&info_lock[pid]); atomic_inc(&file->ref); atomic_inc(&point->ref); vfs_file_end(pid); seterrno(0); return 0; }
/* * swap_shutdown * * Destroys data structures and closes the swap vnode. */ void swap_shutdown(void) { lock_destroy(swaplock); bitmap_destroy(swapmap); vfs_close(swapstore); }
static void vfs_load_file_to_memory (const char *file, void **data, size_t *size) { assert(data != NULL); assert(size != NULL); errval_t err; vfs_handle_t vh; err = vfs_open(file, &vh); if (err_is_fail(err)) { USER_PANIC_ERR(err, "Error opening %s", file); } struct vfs_fileinfo info; err = vfs_stat(vh, &info); assert_err(err, "vfs_stat"); *data = malloc(info.size); assert(*data != NULL); err = vfs_read(vh, *data, info.size, size); assert_err(err, "vfs_read"); assert(*size == info.size); vfs_close(vh); }
static void filetable_init_end(void *token, int err, struct vnode *vn) { cont_filetable_init_t *cont = (cont_filetable_init_t*)token; struct openfile *file; file = malloc(sizeof(struct openfile)); if (file == NULL) { vfs_close(vn, O_WRONLY); cont->callback(cont->token, ENOMEM); free(cont); return; } file->of_offset = 0; // console doesn't use offset file->of_accmode = O_WRONLY; file->of_refcount = 2; file->of_vnode = vn; cont->filetable->ft_openfiles[STDOUT_FD] = file; cont->filetable->ft_openfiles[STDERR_FD] = file; cont->callback(cont->token, 0); free(cont); }
static void cmd_retr(const char *arg, struct tcp_pcb *pcb, struct ftpd_msgstate *fsm) { vfs_file_t *vfs_file; vfs_stat_t st; vfs_stat(fsm->vfs, arg, &st); if (!VFS_ISREG(st.st_mode)) { send_msg(pcb, fsm, msg550); return; } vfs_file = vfs_open(fsm->vfs, arg, "rb"); if (!vfs_file) { send_msg(pcb, fsm, msg550); return; } send_msg(pcb, fsm, msg150recv, arg, st.st_size); if (open_dataconnection(pcb, fsm) != 0) { vfs_close(vfs_file); return; } fsm->datafs->vfs_file = vfs_file; fsm->state = FTPD_RETR; }
void httpd_cleanup(void) { #ifdef VFS_SUPPORT if (STATE->handler == httpd_handle_vfs && STATE->u.vfs.fd) { printf("httpd: cleaning left-over vfs-handle at %p.\n", STATE->u.vfs.fd); vfs_close(STATE->u.vfs.fd); STATE->u.vfs.fd = NULL; } #endif /* VFS_SUPPORT */ #ifdef HTTP_SD_DIR_SUPPORT if (STATE->handler == httpd_handle_sd_dir && STATE->u.dir.handle) { fat_close_dir(STATE->u.dir.handle); STATE->u.dir.handle = NULL; } #endif /* HTTP_SD_DIR_SUPPORT */ #ifdef HTTPD_SOAP_SUPPORT if (STATE->handler == httpd_handle_soap) soap_deallocate_context(&STATE->u.soap); #endif /* HTTPD_SOAP_SUPPORT */ STATE->handler = NULL; }
void op_mkdir(const char **params, int nparams) { inode_t *ino = vfs_open(params[0], &dummy_access); assert(!ino && "Directory exists!"); /* Find parent. */ char *str = NULL; int i; for (i = strlen(params[0]); i >= 0; --i) { if (params[0][i] == '/') { str = kmalloc(i+1); strncpy(str, params[0], i); str[i] = '\0'; break; } } assert(str && "Parent directory not found!"); ino = vfs_open(str, &dummy_access); assert(ino && "Parent directory not found!"); vfs_mknod(ino, ¶ms[0][i+1], it_dir, 0777, 0, 0); ino = vfs_open(params[0], &dummy_access); assert(ino && "Directory not found after having created it!"); vfs_close(ino); }