예제 #1
0
static int esp8266_Read(sqlite3_file *id, void *buffer, int amount, sqlite3_int64 offset)
{
	size_t nRead;
	sint32_t ofst, iofst;
	esp8266_file *file = (esp8266_file*) id;

	iofst = (sint32_t)(offset & 0x7FFFFFFF);

	dbg_printf("esp8266_Read: 1r %s %d %d %lld[%ld] \n", file->name, file->fd, amount, offset, iofst);
	ofst = vfs_lseek(file->fd, iofst, VFS_SEEK_SET);
	if (ofst != iofst) {
	        dbg_printf("esp8266_Read: 2r %ld != %ld FAIL\n", ofst, iofst);
		return SQLITE_IOERR_SHORT_READ /* SQLITE_IOERR_SEEK */;
	}

	nRead = vfs_read(file->fd, buffer, amount);
	if ( nRead == amount ) {
	        dbg_printf("esp8266_Read: 3r %s %u %d OK\n", file->name, nRead, amount);
		return SQLITE_OK;
	} else if ( nRead >= 0 ) {
	        dbg_printf("esp8266_Read: 3r %s %u %d FAIL\n", file->name, nRead, amount);
		return SQLITE_IOERR_SHORT_READ;
	}

	dbg_printf("esp8266_Read: 4r %s FAIL\n", file->name);
	return SQLITE_IOERR_READ;
}
예제 #2
0
파일: fuse.c 프로젝트: syuu1228/fat32fs
static int fuse_read(const char *path, char *buf, size_t size, off_t offset,
                    struct fuse_file_info *fi)
{
    int res;
    if((res = vfs_lseek(fi->fh, offset, 0)) < 0)
    	return res;
    if((res = vfs_read(fi->fh, buf, size)) < 0)
        return res;

    return res;
}
예제 #3
0
파일: files.c 프로젝트: fixos/fixos
int sys_lseek(int fd, off_t offset, int whence) {
	struct process *proc;

	proc = process_get_current();
	if(fd>=0 && fd<PROCESS_MAX_FILE && proc->files[fd] != NULL) {
		return vfs_lseek(proc->files[fd], offset, whence);	
	}
	else {
		printk(LOG_DEBUG, "sys_lseek: invalid fd\n");
	}

	return -1;
}
예제 #4
0
파일: elf.c 프로젝트: Masshat/almos
static error_t elf_program_entries_read(struct vfs_file_s *file, Elf32_Ehdr *e_header, Elf32_Phdr **p_entries)
{
	register error_t err;
	register size_t size;
	register ssize_t count;
	uint8_t *buff;
	kmem_req_t req;
  
	size = e_header->e_phoff * e_header->e_phnum;
  
	if(size == 0)
	{
		printk(ERROR, "\nERROR: elf_program_entries_read: no program entries found\n");
		return EINVAL;
	}

	req.type  = KMEM_GENERIC;
	req.size  = size;
	req.flags = AF_USER;

	if((buff = kmem_alloc(&req)) == NULL)
		return ENOMEM;

	if((err=vfs_lseek(file, e_header->e_phoff, VFS_SEEK_SET, NULL)))
	{
		printk(ERROR, "\nERROR: elf_program_entries_read: faild to localise entries\n");
		goto ELF_PROG_ENTRIES_READ_ERR;
	}

	if((count=vfs_read(file, buff, size)) != size)
	{
		printk(ERROR, "\nERROR: elf_program_entries_read: faild to read program entries, got %d bytes, expected %d bytes\n", 
		       count, size);
		err = (error_t) count;
		goto ELF_PROG_ENTRIES_READ_ERR;
	}
  
	*p_entries = (Elf32_Phdr*) buff;
	return 0;

ELF_PROG_ENTRIES_READ_ERR:
	req.ptr = buff;
	kmem_free(&req);
	return err;
}
예제 #5
0
static int esp8266_Write(sqlite3_file *id, const void *buffer, int amount, sqlite3_int64 offset)
{
	size_t nWrite;
	sint32_t ofst, iofst;
	esp8266_file *file = (esp8266_file*) id;

	iofst = (sint32_t)(offset & 0x7FFFFFFF);

	dbg_printf("esp8266_Write: 1w %s %d %d %lld[%ld] \n", file->name, file->fd, amount, offset, iofst);
	ofst = vfs_lseek(file->fd, iofst, VFS_SEEK_SET);
	if (ofst != iofst) {
		return SQLITE_IOERR_SEEK;
	}

	nWrite = vfs_write(file->fd, buffer, amount);
	if ( nWrite != amount ) {
		dbg_printf("esp8266_Write: 2w %s %u %d\n", file->name, nWrite, amount);
		return SQLITE_IOERR_WRITE;
	}

	dbg_printf("esp8266_Write: 3w %s OK\n", file->name);
	return SQLITE_OK;
}
예제 #6
0
파일: sc_vfs.c 프로젝트: ryankurte/RIOT
static int _read_handler(int argc, char **argv)
{
    uint8_t buf[16];
    size_t nbytes = sizeof(buf);
    off_t offset = 0;
    char *path = argv[1];
    if (argc < 2) {
        puts("vfs read: missing file name");
        return 1;
    }
    if (argc > 2) {
        nbytes = atoi(argv[2]);
    }
    if (argc > 3) {
        offset = atoi(argv[3]);
    }

    int res;
    res = vfs_normalize_path(path, path, strlen(path) + 1);
    if (res < 0) {
        _errno_string(res, (char *)buf, sizeof(buf));
        printf("Invalid path \"%s\": %s\n", path, buf);
        return 5;
    }

    int fd = vfs_open(path, O_RDONLY, 0);
    if (fd < 0) {
        _errno_string(fd, (char *)buf, sizeof(buf));
        printf("Error opening file \"%s\": %s\n", path, buf);
        return 3;
    }

    res = vfs_lseek(fd, offset, SEEK_SET);
    if (res < 0) {
        _errno_string(res, (char *)buf, sizeof(buf));
        printf("Seek error: %s\n", buf);
        vfs_close(fd);
        return 4;
    }

    while (nbytes > 0) {
        memset(buf, 0, sizeof(buf));
        size_t line_len = (nbytes < sizeof(buf) ? nbytes : sizeof(buf));
        res = vfs_read(fd, buf, line_len);
        if (res < 0) {
            _errno_string(res, (char *)buf, sizeof(buf));
            printf("Read error: %s\n", buf);
            vfs_close(fd);
            return 5;
        }
        else if ((size_t)res > line_len) {
            printf("BUFFER OVERRUN! %d > %lu\n", res, (unsigned long)line_len);
            vfs_close(fd);
            return 6;
        }
        else if (res == 0) {
            /* EOF */
            printf("-- EOF --\n");
            break;
        }
        printf("%08lx:", (unsigned long)offset);
        for (int k = 0; k < res; ++k) {
            if ((k % 2) == 0) {
                putchar(' ');
            }
            printf("%02x", buf[k]);
        }
        for (unsigned k = res; k < sizeof(buf); ++k) {
            if ((k % 2) == 0) {
                putchar(' ');
            }
            putchar(' ');
            putchar(' ');
        }
        putchar(' ');
        putchar(' ');
        for (int k = 0; k < res; ++k) {
            if (isprint(buf[k])) {
                putchar(buf[k]);
            }
            else {
                putchar('.');
            }
        }
        puts("");
        offset += res;
        nbytes -= res;
    }

    vfs_close(fd);
    return 0;
}
예제 #7
0
int vfs_ungetc( int c, int fd )
{
    return vfs_lseek( fd, -1, VFS_SEEK_CUR );
}
예제 #8
0
static int cmd_vfs_run(struct vmm_chardev *cdev, const char *path)
{
	int fd, rc;
	u32 len;
	size_t buf_rd;
	char buf[VFS_LOAD_BUF_SZ];
	struct stat st;
	u32 tok_len;
	char *token, *save;
	const char *delim = "\n";
	u32 end, cleanup = 0;

	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;
	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;
		}

		end = buf_rd - 1;
		while (buf[end] != '\n') {
			buf[end] = 0;
			end--;
			cleanup++;
		}

		if (cleanup) {
			vfs_lseek(fd, (buf_rd - cleanup), SEEK_SET);
			cleanup = 0;
		}

		for (token = strtok_r(buf, delim, &save); token;
		     token = strtok_r(NULL, delim, &save)) {
			tok_len = strlen(token);
			if (*token != '#' && *token != '\n') {
				vmm_cmdmgr_execute_cmdstr(cdev, token, NULL);
			}

			len -= (tok_len + 1);
		}
	}

	rc = vfs_close(fd);
	if (rc) {
		vmm_cprintf(cdev, "Failed to close %s\n", path);
		return rc;
	}

	return VMM_OK;
}
예제 #9
0
파일: elf.c 프로젝트: Masshat/almos
static error_t elf_segments_load(struct vfs_file_s *file,
				 Elf32_Ehdr *e_header, 
				 Elf32_Phdr *p_entry,
				 struct task_s *task)
				
{
	register error_t err;
	register uint_t index;
	register size_t size;
	register uint_t start;
	register uint_t limit;
	uint_t proto;
	uint_t flags;

	for(index = 0; index < e_header->e_phnum; index++, p_entry++) 
	{   
		if(p_entry->p_type != PT_LOAD)
			continue;
    
#if 1
		if((p_entry->p_vaddr < USR_OFFSET) || (p_entry->p_vaddr >= USR_LIMIT))
		{
			err = EPERM;
			printk(ERROR, "\nERROR: %s: p_vaddr %x, index %d [ EPERM ]\n",
			       __FUNCTION__, 
			       p_entry->p_vaddr, 
			       index);

			return err;
		}
#endif
    
		if((err=vfs_lseek(file, p_entry->p_offset, VFS_SEEK_SET, NULL)))
		{
			printk(ERROR, "\nERROR: %s: faild to localise segment @index %d\n", 
			       __FUNCTION__, 
			       index);

			return err;
		}

		size  = 0;
		start = p_entry->p_vaddr;
		limit = p_entry->p_vaddr + p_entry->p_memsz;
    
		if((start & PMM_PAGE_MASK) || (limit & PMM_PAGE_MASK))
			return EACCES;

		if(task->vmm.text_start == 0)
		{
			proto                = VM_REG_RD | VM_REG_EX;
			flags                = VM_REG_SHARED | VM_REG_FIXED | VM_REG_INST;
			task->vmm.text_start = start;
			task->vmm.text_end   = limit;

			printk(INFO, "INFO: %s: Text <0x%x - 0x%x>\n", 
			       __FUNCTION__, 
			       start, 
			       limit);
		}
		else
		{
			if(task->vmm.data_start != 0)
				continue;
      
			proto                  = VM_REG_RD | VM_REG_WR;
			flags                  = VM_REG_PRIVATE | VM_REG_FIXED;
			task->vmm.data_start   = start;
			task->vmm.data_end     = limit;
			task->vmm.heap_start   = limit;
			task->vmm.heap_current = limit;

			printk(INFO, "INFO: %s: Data <0x%x - 0x%x>\n", 
			       __FUNCTION__, 
			       start, 
			       limit);
		}

		err = (error_t) vmm_mmap(task, 
					 file, 
					 (void*)start, 
					 limit - start, 
					 proto, 
					 flags,
					 p_entry->p_offset);

		if(err == (error_t)VM_FAILED)
		{
			printk(WARNING,"WARNING: %s: Faild to map segment <0x%x - 0x%x>, proto %x, file name %x\n",
			       __FUNCTION__, 
			       start, 
			       limit, 
			       proto, 
			       file->f_node->n_name);

			return current_thread->info.errno;
		}

		atomic_add(&file->f_count, 1);
	}

	return 0;
}
예제 #10
0
static int load_bin_elf(struct exe_params *params, struct irq_frame *frame)
{
    struct elf_header head;
    struct elf_prog_section sect;
    int ret, i;
    off_t current_off;
    struct address_space *new_addrspc;
    struct task *current;

    ret = vfs_read(params->exe, &head, sizeof(head));
    if (ret != sizeof(head))
        return -ENOEXEC;

    if (head.magic != ELF_MAGIC)
        return -ENOEXEC;

    new_addrspc = kmalloc(sizeof(*new_addrspc), PAL_KERNEL);
    address_space_init(new_addrspc);

    kp(KP_TRACE, "Parsing ELF binary... frame: %p, state: %d\n", frame, cpu_get_local()->current->state);

    /* The idea is that you loop over every header, and if a header's type is
     * 'LOAD' then we make a vm_map for it and load it into memory. */
    for (i = 0, current_off = head.prog_head_pos; i < head.prog_head_count; i++, current_off += sizeof(struct elf_prog_section)) {

        kp(KP_TRACE, "Reading ELF section...\n");
        vfs_lseek(params->exe, current_off, SEEK_SET);
        ret = vfs_read(params->exe, &sect, sizeof(sect));
        kp(KP_TRACE, "Reading ret: %d\n", ret);
        if (ret != sizeof(sect))
            return -ENOEXEC;

        if (sect.type != ELF_PROG_TYPE_LOAD)
            continue;

        kp(KP_TRACE, "Creating new vm_map...\n");
        struct vm_map *new_sect = kmalloc(sizeof(struct vm_map), PAL_KERNEL);
        vm_map_init(new_sect);

        new_sect->addr.start = va_make(sect.vaddr);
        new_sect->addr.end = va_make(sect.vaddr + sect.mem_size);

        if (sect.flags & ELF_PROG_FLAG_EXEC)
            flag_set(&new_sect->flags, VM_MAP_EXE);

        if (sect.flags & ELF_PROG_FLAG_READ)
            flag_set(&new_sect->flags, VM_MAP_READ);

        if (sect.flags & ELF_PROG_FLAG_WRITE)
            flag_set(&new_sect->flags, VM_MAP_WRITE);

        kp(KP_TRACE, "Map from %p to %p\n", new_sect->addr.start, new_sect->addr.end);

        if (!new_addrspc->code)
            new_addrspc->code = new_sect;
        else if (new_addrspc->code->addr.start > new_sect->addr.start)
            new_addrspc->code = new_sect;

        if (!new_addrspc->data)
            new_addrspc->data = new_sect;
        else if (new_addrspc->data->addr.start < new_sect->addr.start)
            new_addrspc->data = new_sect;

        /* f_size is the size in the file, mem_size is the size in memory of
         * our copy.
         *
         * If mem_size > f_size, then the empty space is filled with zeros. */
        int pages = PG_ALIGN(sect.mem_size) / PG_SIZE;
        int k;
        off_t starting_offset = sect.f_off - PG_ALIGN_DOWN(sect.f_off);
        off_t file_size = sect.f_size + starting_offset;
        off_t file_offset = sect.f_off - starting_offset;

        kp(KP_TRACE,"Starting_offset: %ld\n", starting_offset);

        /* This could be cleaned-up. The complexity comes from the fact that
         * sect.f_off doesn't have to be page aligned, even if the section it
         * is in has to be page aligned - This is more then likely due to
         * sections being stripped out, leaving the other sections at odd offsets.
         *
         * Thus, we handle the first page separate from the rest of the pages,
         * and handle it's offset into virtual memory manually. Then, we loop
         * to handle the rest of the pages, using 'file_size' and 'file_offset'
         * which are adjusted values to skip the first part of the file that we
         * already read.
         */

        for (k = 0; k < pages; k++) {
            off_t len;
            struct page *p = palloc(0, PAL_KERNEL);

            if (PG_SIZE * k + PG_SIZE < file_size)
                len = PG_SIZE - starting_offset;
            else if (file_size > PG_SIZE * k)
                len = file_size - starting_offset - PG_SIZE * k;
            else
                len = 0;

            if (len) {
                vfs_lseek(params->exe, file_offset + starting_offset + (k * PG_SIZE), SEEK_SET);
                vfs_read(params->exe, p->virt + starting_offset, len);
            }

            len += starting_offset;
            starting_offset = 0;

            if (len < PG_SIZE)
                memset(p->virt + len, 0, PG_SIZE - len);

            starting_offset = 0;

            list_add_tail(&new_sect->page_list, &p->page_list_node);
        }

        address_space_vm_map_add(new_addrspc, new_sect);
    }

    /* If we detected both the code and data segments to be the same segment,
     * then that means we don't actually have a data segment, so we set it to
     * NULL. This only actually matters for setting the BRK, and we'll just
     * make a new vm_map if the data is NULL in that case. */
    if (new_addrspc->code == new_addrspc->data)
        new_addrspc->data = NULL;

    struct vm_map *stack = kmalloc(sizeof(struct vm_map), PAL_KERNEL);
    vm_map_init(stack);

    stack->addr.end = KMEM_PROG_STACK_END;
    stack->addr.start = KMEM_PROG_STACK_START;

    flag_set(&stack->flags, VM_MAP_READ);
    flag_set(&stack->flags, VM_MAP_WRITE);
    flag_set(&stack->flags, VM_MAP_EXE);

    palloc_unordered(&stack->page_list, KMEM_STACK_LIMIT, PAL_KERNEL);

    address_space_vm_map_add(new_addrspc, stack);

    new_addrspc->stack = stack;

    kp(KP_TRACE, "New code segment: %p-%p\n", new_addrspc->code->addr.start, new_addrspc->code->addr.end);
    if (new_addrspc->data)
        kp(KP_TRACE, "New data segment: %p-%p\n", new_addrspc->data->addr.start, new_addrspc->data->addr.end);
    kp(KP_TRACE, "New stack segment: %p-%p\n", new_addrspc->stack->addr.start, new_addrspc->stack->addr.end);

    current = cpu_get_local()->current;

    arch_task_change_address_space(new_addrspc);

    irq_frame_initalize(current->context.frame);

    irq_frame_set_stack(current->context.frame, new_addrspc->stack->addr.end);
    irq_frame_set_ip(current->context.frame, va_make(head.entry_vaddr));

    return 0;
}
예제 #11
0
파일: psx.c 프로젝트: 9a3eedi/Droidsound
static sint32 EMU_CALL vlseek(void *vfsstate, sint32 emufd, sint32 offset, sint32 whence) {
  if(emufd < 0) return -9;
  if(whence < 0 || whence > 2) return -22;
  if(whence == 0 && offset < 0) return -22;
  return vfs_lseek(vfsstate, emufd, offset, whence);
}
예제 #12
0
파일: libauth.c 프로젝트: 32bitmicro/xvisor
static int get_user_hash(const char *user, u8 *dst_hash, u32 dst_len)
{
	int fd, rc;
	u32 len;
	size_t buf_rd;
	char buf[VFS_LOAD_BUF_SZ];
	struct stat st;
	u32 tok_len;
	char *token, *save;
	const char *delim = "\n";
	u32 end, cleanup = 0;
	const char *path = CONFIG_LIBAUTH_FILE;

	fd = vfs_open(path, O_RDONLY, 0);
	if (fd < 0) {
		return VMM_EFAIL;
	}

	rc = vfs_fstat(fd, &st);
	if (rc) {
		vfs_close(fd);
		return VMM_EFAIL;
	}

	if (!(st.st_mode & S_IFREG)) {
		vfs_close(fd);
		return VMM_EFAIL;
	}

	len = st.st_size;
	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;
		}

		end = buf_rd - 1;
		while (buf[end] != '\n') {
			buf[end] = 0;
			end--;
			cleanup++;
		}

		if (cleanup) {
			vfs_lseek(fd, (buf_rd - cleanup), SEEK_SET);
			cleanup = 0;
		}

		for (token = strtok_r(buf, delim, &save); token;
		     token = strtok_r(NULL, delim, &save)) {
			tok_len = strlen(token);
			if (*token != '#' && *token != '\n') {
				if (process_auth_entry(token, user,
						dst_hash, dst_len) == VMM_OK)
					return VMM_OK;
			}

			len -= (tok_len + 1);
		}
	}

	rc = vfs_close(fd);
	if (rc) {
		return VMM_EFAIL;
	}

	return VMM_EFAIL;
}