Пример #1
0
int file_open(const char *filename)
{
	load_fd=open_io(filename);
	if(load_fd >= 0)
            seek_io(load_fd, 0);
	return load_fd>-1;
}
Пример #2
0
/* Load 32-bit part of kernel */
static int load_linux_kernel(struct linux_header *hdr, uint32_t kern_addr)
{
    uint32_t kern_offset, kern_size;

    if (hdr->setup_sects == 0)
	hdr->setup_sects = 4;
    kern_offset = (hdr->setup_sects + 1) * 512;
    seek_io(fd, kern_offset);
    kern_size = file_size() - kern_offset;
    debug("offset=%#x addr=%#x size=%#x\n", kern_offset, kern_addr, kern_size);

#if 0
    if (using_devsize) {
	printf("Attempt to load up to end of device as kernel; "
		"specify the image size\n");
	return 0;
    }
#endif

    printf("Loading kernel... ");
    if (read_io(fd, phys_to_virt(kern_addr), kern_size) != kern_size) {
	printf("Can't read kernel\n");
	return 0;
    }
    printf("ok\n");

    return kern_size;
}
Пример #3
0
int
devread( unsigned long sector, unsigned long byte_offset,
	 unsigned long byte_len, void *buf )
{
	llong offs = (llong)sector * 512 + byte_offset;

#ifdef CONFIG_DEBUG_FS
	//printk("devread s=%x buf=%x, fd=%x\n",sector, buf, curfs->dev_fd);
#endif

	if( !curfs ) {
#ifdef CONFIG_DEBUG_FS
		printk("devread: fsys == NULL!\n");
#endif
		return -1;
	}

	if( seek_io(curfs->dev_fd, offs) ) {
#ifdef CONFIG_DEBUG_FS
		printk("seek failure\n");
#endif
		return -1;
	}
	return (read_io(curfs->dev_fd, buf, byte_len) == byte_len) ? 1:0;
}
Пример #4
0
Файл: main.c Проект: 3a9LL/panda
static int
load_elf_rom( unsigned long *entry, int fd )
{
	int i, lszz_offs, elf_offs;
	char buf[128], *addr;
	Elf_ehdr ehdr;
	Elf_phdr *phdr;
	size_t s;

	printk("Loading '%s'\n", get_file_path(fd));

	/* the ELF-image (usually) starts at offset 0x4000 */
	if( (elf_offs=find_elf(fd)) < 0 ) {
		printk("----> %s is not an ELF image\n", buf );
		exit(1);
	}
	if( !(phdr=elf_readhdrs(fd, elf_offs, &ehdr)) )
		fatal_error("elf_readhdrs failed\n");

	*entry = ehdr.e_entry;

	/* load segments. Compressed ROM-image assumed to be located immediately
	 * after the last segment */
	lszz_offs = elf_offs;
	for( i=0; i<ehdr.e_phnum; i++ ) {
		/* p_memsz, p_flags */
		s = MIN( phdr[i].p_filesz, phdr[i].p_memsz );
		seek_io( fd, elf_offs + phdr[i].p_offset );

		/* printk("filesz: %08lX memsz: %08lX p_offset: %08lX p_vaddr %08lX\n",
		   phdr[i].p_filesz, phdr[i].p_memsz, phdr[i].p_offset,
		   phdr[i].p_vaddr ); */

		if( phdr[i].p_vaddr != phdr[i].p_paddr )
			printk("WARNING: ELF segment virtual addr != physical addr\n");
		lszz_offs = MAX( lszz_offs, elf_offs + phdr[i].p_offset + phdr[i].p_filesz );
		if( !s )
			continue;
		if( ofmem_claim( phdr[i].p_vaddr, phdr[i].p_memsz, 0 ) == -1 )
			fatal_error("Claim failed!\n");

		addr = (char*)phdr[i].p_vaddr;
		if( read_io(fd, addr, s) != s )
			fatal_error("read failed\n");

#if 0
		/* patch CODE segment */
		if( *entry >= phdr[i].p_vaddr && *entry < phdr[i].p_vaddr + s ) {
			patch_newworld_rom( (char*)phdr[i].p_vaddr, s );
			newworld_timer_hack( (char*)phdr[i].p_vaddr, s );
		}
#endif
		flush_icache_range( addr, addr+s );

		/*printk("ELF ROM-section loaded at %08lX (size %08lX)\n",
		   (unsigned long)phdr[i].p_vaddr, (unsigned long)phdr[i].p_memsz );*/
	}
	free( phdr );
	return lszz_offs;
}
Пример #5
0
int file_seek(unsigned long offset)
{
        if (load_fd >= 0)
            return seek_io(load_fd, offset);
        else
            return -1;
}
Пример #6
0
static unsigned long file_size(void)
{
	long long fpos, fsize;

	/* Save current position */
	fpos = tell(fd);

	/* Go to end of file and get position */
	seek_io(fd, -1);
	fsize = tell(fd);

	/* Go back to old position */
	seek_io(fd, 0);
	seek_io(fd, fpos);

	return fsize;
}
Пример #7
0
unsigned long file_size(void)
{
	llong fpos, fsize;

	/* save current position */
	fpos=tell(load_fd);

	/* go to end of file and get position */
	seek_io(load_fd, -1);
	fsize=tell(load_fd);

	/* go back to old position */
	seek_io(load_fd, 0);
	seek_io(load_fd, fpos);

	return fsize;
}
Пример #8
0
static unsigned long process_image_notes(Elf_phdr *phdr, int phnum,
        unsigned short *sum_ptr,
        unsigned int offset)
{
    int i;
    char *buf = NULL;
    int retval = 0;
    unsigned long addr, end;
    Elf_Nhdr *nhdr;
    const char *name;
    void *desc;

    for (i = 0; i < phnum; i++) {
        if (phdr[i].p_type != PT_NOTE)
            continue;
        buf = malloc(phdr[i].p_filesz);
        seek_io(fd, offset + phdr[i].p_offset);
        if ((size_t)read_io(fd, buf, phdr[i].p_filesz) != phdr[i].p_filesz) {
            printf("Can't read note segment\n");
            goto out;
        }
        addr = (unsigned long) buf;
        end = addr + phdr[i].p_filesz;
        while (addr < end) {
            nhdr = (Elf_Nhdr *) addr;
            addr += sizeof(Elf_Nhdr);
            name = (const char *) addr;
            addr += (nhdr->n_namesz+3) & ~3;
            desc = (void *) addr;
            addr += (nhdr->n_descsz+3) & ~3;

            if (nhdr->n_namesz==sizeof(ELF_NOTE_BOOT)
                    && memcmp(name, ELF_NOTE_BOOT, sizeof(ELF_NOTE_BOOT))==0) {
                if (nhdr->n_type == EIN_PROGRAM_NAME) {
                    image_name = ob_calloc(1, nhdr->n_descsz + 1);
                    memcpy(image_name, desc, nhdr->n_descsz);
                }
                if (nhdr->n_type == EIN_PROGRAM_VERSION) {
                    image_version = ob_calloc(1, nhdr->n_descsz + 1);
                    memcpy(image_version, desc, nhdr->n_descsz);
                }
                if (nhdr->n_type == EIN_PROGRAM_CHECKSUM) {
                    *sum_ptr = *(unsigned short *) desc;
                    debug("Image checksum: %#04x\n", *sum_ptr);
                    /* Where in the file */
                    retval = phdr[i].p_offset
                             + (unsigned long) desc - (unsigned long) buf;
                }
            }
        }
    }
out:
    close_io(fd);
    if (buf)
        free(buf);
    return retval;
}
Пример #9
0
/* Load the first part the file and check if it's Linux */
static uint32_t load_linux_header(struct linux_header *hdr)
{
    int load_high;
    uint32_t kern_addr;

    if (read_io(fd, hdr, sizeof *hdr) != sizeof *hdr) {
	debug("Can't read Linux header\n");
	return 0;
    }
    if (hdr->boot_sector_magic != 0xaa55) {
	debug("Not a Linux kernel image\n");
	return 0;
    }

    /* Linux is found. Print some information */
    if (memcmp(hdr->header_magic, "HdrS", 4) != 0) {
	/* This may be floppy disk image or something.
	 * Perform a simple (incomplete) sanity check. */
	if (hdr->setup_sects >= 16
		|| file_size() - (hdr->setup_sects<<9) >= 512<<10) {
	    debug("This looks like a bootdisk image but not like Linux...\n");
	    return 0;
	}

	printf("Possible very old Linux");
	/* This kernel does not even have a protocol version.
	 * Force the value. */
	hdr->protocol_version = 0; /* pre-2.00 */
    } else
	printf("Found Linux");
    if (hdr->protocol_version >= 0x200 && hdr->kver_addr) {
	char kver[256];
	seek_io(fd, hdr->kver_addr + 0x200);
	if (read_io(fd, kver, sizeof kver) != 0) {
	    kver[255] = 0;
	    printf(" version %s", kver);
	}
    }
    debug(" (protocol %#x)", hdr->protocol_version);
    load_high = 0;
    if (hdr->protocol_version >= 0x200) {
	debug(" (loadflags %#x)", hdr->loadflags);
	load_high = hdr->loadflags & 1;
    }
    if (load_high) {
	printf(" bzImage");
	kern_addr = 0x100000;
    } else {
	printf(" zImage or Image");
	kern_addr = 0x1000;
    }
    printf(".\n");

    return kern_addr;
}
Пример #10
0
int 
bootcode_load(ihandle_t dev)
{
    int retval = -1, count = 0, fd;
    unsigned long bootcode, loadbase, offset;

    /* Mark the saved-program-state as invalid */
    feval("0 state-valid !");

    fd = open_ih(dev);
    if (fd == -1) {
        goto out;
    }

    /* Default to loading at load-base */
    fword("load-base");
    loadbase = POP();
    
#ifdef CONFIG_PPC
    /* However Old World Macs need to load to a different address */
    if (is_oldworld()) {
        loadbase = OLDWORLD_BOOTCODE_BASEADDR;
    }
#endif
    
    bootcode = loadbase;
    offset = 0;
    
    while(1) {
        if (seek_io(fd, offset) == -1)
            break;
        count = read_io(fd, (void *)bootcode, 512);
        offset += count;
        bootcode += count;
    }

    /* If we didn't read anything then exit */
    if (!count) {
        goto out;
    }
    
    /* Initialise saved-program-state */
    PUSH(loadbase);
    feval("saved-program-state >sps.entry !");
    PUSH(offset);
    feval("saved-program-state >sps.file-size !");
    feval("bootcode saved-program-state >sps.file-type !");

    feval("-1 state-valid !");

out:
    close_io(fd);
    return retval;
}
Пример #11
0
void ext2_read_block(ext2_VOLUME* volume, unsigned int fsblock)
{
	long long offset;

	if (fsblock == volume->current)
		return;

	volume->current = fsblock;
	offset = fsblock * EXT2_BLOCK_SIZE(volume->super);

	seek_io(volume->fd, offset);
	read_io(volume->fd, volume->buffer, EXT2_BLOCK_SIZE(volume->super));
}
Пример #12
0
Файл: boot.c Проект: 3a9LL/panda
void
*load_elf(char *spec)
{
#if 0
	int fd;
	void *entry=NULL;
	int i, lszz_offs, elf_offs;
	char buf[128]; // , *addr;
	Elf_ehdr ehdr;
	Elf_phdr *phdr;
	size_t s;

	if( (fd=open_io(spec)) == -1 )
		return NULL;

	if( (elf_offs=find_elf(fd)) < 0 ) {
		printk("----> %s is not an ELF image\n", buf );
		return NULL;
	}

	if( !(phdr=elf_readhdrs(fd, 0, &ehdr)) ) {
		printk("elf32_readhdrs failed\n");
		return NULL;
	}

	(unsigned long long *)entry = ehdr.e_entry;

	lszz_offs = elf_offs;
	for( i=0; i<ehdr.e_phnum; i++ ) {
		s = MIN( phdr[i].p_filesz, phdr[i].p_memsz );
		seek_io( fd, elf_offs + phdr[i].p_offset );
		/* printk("filesz: %08lX memsz: %08lX p_offset: %08lX p_vaddr %08lX\n",
		   phdr[i].p_filesz, phdr[i].p_memsz, phdr[i].p_offset,
		   phdr[i].p_vaddr ); */
		if( phdr[i].p_vaddr != phdr[i].p_paddr )
			printk("WARNING: ELF segment virtual addr != physical addr\n");
		lszz_offs = MAX( lszz_offs, elf_offs + phdr[i].p_offset + phdr[i].p_filesz );
		if( !s )
			continue;

		 printk("ELF ROM-section loaded at %08lX (size %08lX)\n",
				 (unsigned long)phdr[i].p_vaddr, (unsigned long)phdr[i].p_memsz);
	}
	free( phdr );
	return entry;
#else
	return NULL;
#endif
}
Пример #13
0
void ext2_get_super(int fd, struct ext2_super_block *super)
{
	seek_io(fd, 2 * 512);
	read_io(fd, super, sizeof (*super));

	super->s_inodes_count = __le32_to_cpu(super->s_inodes_count);
	super->s_blocks_count = __le32_to_cpu(super->s_blocks_count);
	super->s_r_blocks_count = __le32_to_cpu(super->s_r_blocks_count);
	super->s_free_blocks_count = __le32_to_cpu(super->s_free_blocks_count);
	super->s_free_inodes_count = __le32_to_cpu(super->s_free_inodes_count);
	super->s_first_data_block = __le32_to_cpu(super->s_first_data_block);
	super->s_log_block_size = __le32_to_cpu(super->s_log_block_size);
	super->s_log_frag_size = __le32_to_cpu(super->s_log_frag_size);
	super->s_blocks_per_group = __le32_to_cpu(super->s_blocks_per_group);
	super->s_frags_per_group = __le32_to_cpu(super->s_frags_per_group);
	super->s_inodes_per_group = __le32_to_cpu(super->s_inodes_per_group);
	super->s_mtime = __le32_to_cpu(super->s_mtime);
	super->s_wtime = __le32_to_cpu(super->s_wtime);
	super->s_mnt_count = __le16_to_cpu(super->s_mnt_count);
	super->s_max_mnt_count = __le16_to_cpu(super->s_max_mnt_count);
	super->s_magic = __le16_to_cpu(super->s_magic);
	super->s_state = __le16_to_cpu(super->s_state);
	super->s_errors = __le16_to_cpu(super->s_errors);
	super->s_minor_rev_level = __le16_to_cpu(super->s_minor_rev_level);
	super->s_lastcheck = __le32_to_cpu(super->s_lastcheck);
	super->s_checkinterval = __le32_to_cpu(super->s_checkinterval);
	super->s_creator_os = __le32_to_cpu(super->s_creator_os);
	super->s_rev_level = __le32_to_cpu(super->s_rev_level);
	super->s_def_resuid = __le16_to_cpu(super->s_def_resuid);
	super->s_def_resgid = __le16_to_cpu(super->s_def_resgid);
	super->s_first_ino = __le32_to_cpu(super->s_first_ino);
	super->s_inode_size = __le16_to_cpu(super->s_inode_size);
	super->s_block_group_nr = __le16_to_cpu(super->s_block_group_nr);
	super->s_feature_compat = __le32_to_cpu(super->s_feature_compat);
	super->s_feature_incompat = __le32_to_cpu(super->s_feature_incompat);
	super->s_feature_ro_compat = __le32_to_cpu(super->s_feature_ro_compat);
	super->s_algorithm_usage_bitmap =
				__le32_to_cpu(super->s_algorithm_usage_bitmap);
	super->s_journal_inum = __le32_to_cpu(super->s_journal_inum);
	super->s_journal_dev = __le32_to_cpu(super->s_journal_dev);
	super->s_last_orphan = __le32_to_cpu(super->s_last_orphan);
	super->s_hash_seed[0] = __le32_to_cpu(super->s_hash_seed[0]);
	super->s_hash_seed[1] = __le32_to_cpu(super->s_hash_seed[1]);
	super->s_hash_seed[2] = __le32_to_cpu(super->s_hash_seed[2]);
	super->s_hash_seed[3] = __le32_to_cpu(super->s_hash_seed[3]);
	super->s_default_mount_opts =
				__le32_to_cpu(super->s_default_mount_opts);
	super->s_first_meta_bg = __le32_to_cpu(super->s_first_meta_bg);
}
Пример #14
0
int ext2_probe(int fd, long long offset)
{
	struct ext2_super_block *super;

	super = (struct ext2_super_block*)malloc(sizeof(struct ext2_super_block));
	seek_io(fd, 2 * 512 + offset);
	read_io(fd, super, sizeof (*super));

	if (__le16_to_cpu(super->s_magic) != EXT2_SUPER_MAGIC) {
		free(super);
		return 0;
	}

	free(super);
	return -1;
}
Пример #15
0
Elf_phdr *
elf_readhdrs(int offset, Elf_ehdr *ehdr)
{
    unsigned long phdr_size;
    Elf_phdr *phdr;

    phdr_size = ehdr->e_phnum * sizeof(Elf_phdr);
    phdr = malloc(phdr_size);
    seek_io(fd, offset + ehdr->e_phoff);
    if ((size_t)read_io(fd, phdr, phdr_size) != phdr_size) {
        printf("Can't read program header\n");
        return NULL;
    }

    return phdr;
}
Пример #16
0
static int load_segments(Elf_phdr *phdr, int phnum,
                         unsigned long checksum_offset,
                         unsigned int offset, unsigned long *bytes)
{
    //unsigned int start_time, time;
    int i;

    *bytes = 0;
    // start_time = currticks();
    for (i = 0; i < phnum; i++) {
        if (phdr[i].p_type != PT_LOAD)
            continue;
        debug("segment %d addr:" FMT_elf " file:" FMT_elf " mem:" FMT_elf " ",
              i, addr_fixup(phdr[i].p_paddr), phdr[i].p_filesz, phdr[i].p_memsz);
        seek_io(fd, offset + phdr[i].p_offset);
        debug("loading... ");
        if ((size_t)read_io(fd, phys_to_virt(addr_fixup(phdr[i].p_paddr)), phdr[i].p_filesz)
                != phdr[i].p_filesz) {
            printf("Can't read program segment %d\n", i);
            return 0;
        }
        bytes += phdr[i].p_filesz;
        debug("clearing... ");
        memset(phys_to_virt(addr_fixup(phdr[i].p_paddr) + phdr[i].p_filesz), 0,
               phdr[i].p_memsz - phdr[i].p_filesz);
        if (phdr[i].p_offset <= checksum_offset
                && phdr[i].p_offset + phdr[i].p_filesz >= checksum_offset+2) {
            debug("clearing checksum... ");
            memset(phys_to_virt(addr_fixup(phdr[i].p_paddr) + checksum_offset
                                - phdr[i].p_offset), 0, 2);
        }
        debug("ok\n");

    }
    // time = currticks() - start_time;
    //debug("Loaded %lu bytes in %ums (%luKB/s)\n", bytes, time,
    //	    time? bytes/time : 0);
    debug("Loaded %lu bytes \n", *bytes);

    return 1;
}
Пример #17
0
char *
get_hfs_vol_name( int fd, char *buf, int size )
{
	char sect[512];
	hfs_mdb_t *mdb = (hfs_mdb_t*)&sect;

	seek_io( fd, 0x400 );
	read_io( fd, sect, sizeof(sect) );
	if( hfs_get_ushort(mdb->drSigWord) == HFS_SIGNATURE ) {
		unsigned int n = mdb->drVN[0];
		if( n >= size )
			n = size - 1;
		memcpy( buf, &mdb->drVN[1], n );
		buf[n] = 0;
	} else if( hfs_get_ushort(mdb->drSigWord) == HFS_PLUS_SIGNATURE ) {
		strncpy( buf, "Unembedded HFS+", size );
	} else {
		strncpy( buf, "Error", size );
	}
	return buf;
}
Пример #18
0
ulong
os_seek( int fd, ulong blknum, int blksize_bits )
{
	/* printk("os_seek %d\n", blknum ); */
	llong offs = (llong)blknum << blksize_bits;

	/* offset == -1 means seek to EOF */
	if( (int)blknum == -1 )
		offs = -1;

	if( seek_io(fd, offs) ) {
		/* printk("os_seek failure\n"); */
		return (ulong)-1;
	}

	if( (int)blknum == -1 ) {
		if( (offs=tell(fd)) < 0 )
			return -1;
		blknum = offs >> blksize_bits;
	}
	return blknum;
}
Пример #19
0
int
find_elf(Elf_ehdr *ehdr)
{
    int offset;

    for (offset = 0; offset < MAX_HEADERS * BS; offset += BS) {
        if ((size_t)read_io(fd, ehdr, sizeof ehdr) != sizeof ehdr) {
            debug("Can't read ELF header\n");
            return 0;
        }

        if (is_elf(ehdr)) {
            debug("Found ELF header at offset %d\n", offset);
            return offset;
        }

        seek_io(fd, offset);
    }

    debug("Not a bootable ELF image\n");
    return 0;
}
Пример #20
0
int 
xcoff_load(ihandle_t dev)
{
	COFF_filehdr_t fhdr;
	COFF_aouthdr_t ahdr;
	COFF_scnhdr_t shdr;
	uint32_t offset;
	size_t total_size = 0;
	int fd, i;
	int retval = -1;
	
	/* Mark the saved-program-state as invalid */
	feval("0 state-valid !");

	fd = open_ih(dev);
	if (fd == -1) {
		retval = LOADER_NOT_SUPPORT;
		goto out;
	}
	
	for (offset = 0; offset < 16 * 512; offset += 512) {
		seek_io(fd, offset);
		if (read_io(fd, &fhdr, sizeof fhdr) != sizeof fhdr) {
			DPRINTF("Can't read XCOFF header\n");
			retval = LOADER_NOT_SUPPORT;
			goto out;
		}
		
		if (is_xcoff(&fhdr))
			break;
	}
	
	/* Is it executable ? */
	if (fhdr.f_magic != 0x01DF &&
	    (fhdr.f_flags & COFF_F_EXEC) == 0) {
		DPRINTF("Not an executable XCOFF file %02x\n", fhdr.f_flags);
		return LOADER_NOT_SUPPORT;
	}

	/* Optional header is a.out ? */
	if (fhdr.f_opthdr != sizeof(COFF_aouthdr_t)) {
		DPRINTF("AOUT optional error size mismatch in XCOFF file\n");
		return LOADER_NOT_SUPPORT;
	}
	
	seek_io(fd, sizeof(COFF_filehdr_t));
	read_io(fd, &ahdr, sizeof(COFF_aouthdr_t));
	
	/* check a.out magic number */
	if (ahdr.magic != AOUT_MAGIC) {
		DPRINTF("Invalid AOUT optional header\n");
		return LOADER_NOT_SUPPORT;
	}

	offset = sizeof(COFF_filehdr_t) + sizeof(COFF_aouthdr_t);

	DPRINTF("XCOFF file with %d sections\n", fhdr.f_nscns);

	for (i = 0; i < fhdr.f_nscns; i++) {
		DPRINTF("Read header at offset %0x\n", offset);
		seek_io(fd, offset);
		read_io(fd, &shdr, sizeof(COFF_scnhdr_t));

		DPRINTF("Initializing '%s' section from %0x %0x to %0x (%0x)\n",
			shdr.s_name, offset, shdr.s_scnptr,
			shdr.s_vaddr, shdr.s_size);

		if (strcmp(shdr.s_name, ".text") == 0) {
			read_io(fd, (void *)shdr.s_vaddr, shdr.s_size);
			total_size += shdr.s_size;
#ifdef CONFIG_PPC
			flush_icache_range((char*)(uintptr_t)shdr.s_vaddr,
					 (char*)(uintptr_t)(shdr.s_vaddr + shdr.s_size));
#endif
		} else if (strcmp(shdr.s_name, ".data") == 0) {
			read_io(fd, (void *)shdr.s_vaddr, shdr.s_size);
			total_size += shdr.s_size;

		} else if (strcmp(shdr.s_name, ".bss") == 0) {
			memset((void *)(uintptr_t)shdr.s_vaddr, 0, shdr.s_size);
			total_size += shdr.s_size;
		} else {
			DPRINTF("    Skip '%s' section\n", shdr.s_name);
		}
		offset += sizeof(COFF_scnhdr_t);
	}

	DPRINTF("XCOFF entry point: %x\n", *(uint32_t*)ahdr.entry);

	// Initialise load-state
	PUSH(total_size);
	feval("load-state >ls.file-size !");
	feval("xcoff load-state >ls.file-type !");

out:
	close_io(fd);
	return retval;
}
Пример #21
0
size_t iso9660_read(iso9660_FILE *_file, char *buf, size_t count)
{
	iso9660_FILE *file = (iso9660_FILE*)_file;
	size_t read = 0;

	if ( count > (file->size  - file->offset) )
		count = file->size  - file->offset;

	while (count > 0)
	{
		size_t part;
		int offset_extent;
		int offset_index;

		offset_extent = file->base +
				    (file->offset / ISOFS_BLOCK_SIZE);
		offset_index = file->offset % ISOFS_BLOCK_SIZE;

		if (file->current != offset_extent)
		{
			if ( (offset_index == 0) &&
			     (count >= ISOFS_BLOCK_SIZE) )
			{
				/* direct i/o */

				int extents_nb;

				extents_nb = count / ISOFS_BLOCK_SIZE;

				part = extents_nb * ISOFS_BLOCK_SIZE;

				seek_io(file->volume->fd,
					offset_extent * ISOFS_BLOCK_SIZE);
				read_io(file->volume->fd, buf + read, part);

				file->offset += part;
				count -= part;
				read += part;

				continue;
			}

			file->current = offset_extent;
			seek_io(file->volume->fd,
				offset_extent * ISOFS_BLOCK_SIZE);
			read_io(file->volume->fd, file->buffer,
				ISOFS_BLOCK_SIZE);
		}

		part = ISOFS_BLOCK_SIZE - offset_index;
		if (count < part)
			part = count;

		memcpy(buf + read, file->buffer + offset_index, part);

		file->offset += part;
		count -= part;
		read += part;
	}

	return read;
}
Пример #22
0
int file_seek(unsigned long offset)
{
	return seek_io(load_fd, offset);
}
Пример #23
0
int file_open(const char *filename)
{
	load_fd=open_io(filename);
	/* if(load_fd!=-1)  */ seek_io(load_fd, 0);
	return load_fd>-1;
}
Пример #24
0
int 
fcode_load(ihandle_t dev)
{
    int retval = -1;
    uint8_t fcode_header[8];
    unsigned long start, size;
    unsigned int offset;

    /* Mark the saved-program-state as invalid */
    feval("0 state-valid !");

    fd = open_ih(dev);
    if (fd == -1) {
        goto out;
    }

    for (offset = 0; offset < 16 * 512; offset += 512) {
        seek_io(fd, offset);
        if (read_io(fd, &fcode_header, sizeof(fcode_header))
            != sizeof(fcode_header)) {
            debug("Can't read FCode header from ihandle " FMT_ucellx "\n", dev);
            retval = LOADER_NOT_SUPPORT;
            goto out;
        }

	if (is_fcode(fcode_header))
            goto found;
    }

    debug("Not a bootable FCode image\n");
    retval = LOADER_NOT_SUPPORT;
    goto out;

 found:
    size = (fcode_header[4] << 24) | (fcode_header[5] << 16) |
        (fcode_header[6] << 8) | fcode_header[7];

    fword("load-base");
    start = POP();

    printf("\nLoading FCode image...\n");

    seek_io(fd, offset);

    if ((size_t)read_io(fd, (void *)start, size) != size) {
        printf("Can't read file (size 0x%lx)\n", size);
        goto out;
    }

    debug("Loaded %lu bytes\n", size);
    debug("entry point is %#lx\n", start);
    
    // Initialise load-state
    PUSH(size);
    feval("load-state >ls.file-size !");
    feval("fcode load-state >ls.file-type !");

out:
    close_io(fd);
    return retval;
}
Пример #25
0
int 
aout_load(struct sys_info *info, ihandle_t dev)
{
    int retval = -1;
    struct exec ehdr;
    unsigned long start, size;
    unsigned int offset;

    image_name = image_version = NULL;

    /* Mark the saved-program-state as invalid */
    feval("0 state-valid !");
    
    fd = open_ih(dev);
    if (fd == -1) {
	goto out;
    }

    for (offset = 0; offset < 16 * 512; offset += 512) {
        seek_io(fd, offset);
        if (read_io(fd, &ehdr, sizeof ehdr) != sizeof ehdr) {
            debug("Can't read a.out header\n");
            retval = LOADER_NOT_SUPPORT;
            goto out;
        }
        if (is_aout(&ehdr))
            break;
    }

    if (!is_aout(&ehdr)) {
	debug("Not a bootable a.out image\n");
	retval = LOADER_NOT_SUPPORT;
	goto out;
    }

    if (ehdr.a_text == 0x30800007)
	ehdr.a_text=64*1024;

    if (N_MAGIC(ehdr) == NMAGIC) {
        size = addr_fixup(N_DATADDR(ehdr)) + addr_fixup(ehdr.a_data);
    } else {
        size = addr_fixup(ehdr.a_text) + addr_fixup(ehdr.a_data);
    }

    if (size < 7680)
        size = 7680;

    fword("load-base");
    start = POP(); // N_TXTADDR(ehdr);

    memcpy((void *)start, &ehdr, sizeof(ehdr));
    
    if (!check_mem_ranges(info, start, size))
	goto out;

    printf("Loading a.out %s...\n", image_name ? image_name : "image");
    seek_io(fd, offset + N_TXTOFF(ehdr));

    if (N_MAGIC(ehdr) == NMAGIC) {
        if ((size_t)read_io(fd, (void *)(start + N_TXTOFF(ehdr)), ehdr.a_text) != ehdr.a_text) {
            printf("Can't read program text segment (size 0x" FMT_aout_ehdr ")\n", ehdr.a_text);
            goto out;
        }
        if ((size_t)read_io(fd, (void *)(start + N_DATADDR(ehdr)), ehdr.a_data) != ehdr.a_data) {
            printf("Can't read program data segment (size 0x" FMT_aout_ehdr ")\n", ehdr.a_data);
            goto out;
        }
    } else {
        if ((size_t)read_io(fd, (void *)(start + N_TXTOFF(ehdr)), size) != size) {
            printf("Can't read program (size 0x" FMT_sizet ")\n", size);
            goto out;
        }
    }

    debug("Loaded %lu bytes\n", size);
    debug("entry point is %#lx\n", start);

    // Initialise saved-program-state
    PUSH(size);
    feval("load-state >ls.file-size !");
    feval("aout load-state >ls.file-type !");

out:
    close_io(fd);
    return retval;
}