uint32_t loader() {
Elf32_Ehdr *elf;
Elf32_Phdr *ph = NULL;
uint8_t buf[4096];
#ifdef HAS_DEVICE
ide_read(buf, ELF_OFFSET_IN_DISK, 4096);
#else
ramdisk_read(buf, ELF_OFFSET_IN_DISK, 4096);
#endif
elf = (void*)buf;
/* fix the magic number with the correct one */
const uint32_t elf_magic = 0x464c457f;
uint32_t *p_magic = (void *)buf;
nemu_assert(*p_magic == elf_magic);
/* Load each program segment */
int i;
for(i=0;i<elf->e_phnum;i++ ) {
/* Scan the program header table, load each segment into memory */
ph=(void *)(elf->e_phoff + i * elf->e_phentsize + buf);
if(ph->p_type == PT_LOAD) {
//Log("success");
#ifdef IA32_PAGE
/* Record the program break for future use. */
extern uint32_t brk;
uint32_t new_brk = ph->p_vaddr + ph->p_memsz - 1;
if(brk < new_brk) { brk = new_brk; }
uint32_t pa=mm_malloc(ph->p_vaddr,ph->p_memsz);
#endif
#ifndef HAS_DEVICE
ramdisk_read((void*)pa, ELF_OFFSET_IN_DISK + ph->p_offset, ph->p_filesz);
#else
ide_read((void*)pa, ELF_OFFSET_IN_DISK + ph->p_offset, ph->p_filesz);
#endif
memset((void*)(pa + ph->p_filesz), 0, ph->p_memsz - ph->p_filesz);
}
}
volatile uint32_t entry = elf->e_entry;
#ifdef IA32_PAGE
mm_malloc(KOFFSET - STACK_SIZE, STACK_SIZE);
#ifdef HAS_DEVICE
create_video_mapping();
#endif
write_cr3(get_ucr3());
#endif
return entry;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
switch (req)
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
default:
errno = EINVAL;
return -1;
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
break;
}
errno = EINVAL;
return -1;
}
uint32_t loader() {
Elf32_Ehdr *elf;
Elf32_Phdr *ph = NULL;
uint8_t buf[4096];
#ifdef HAS_DEVICE
ide_read(buf, ELF_OFFSET_IN_DISK, 4096);
#else
ramdisk_read(buf, ELF_OFFSET_IN_DISK, 4096);
#endif
elf = (void*)buf;
/* TODO: fix the magic number with the correct one */
const uint32_t elf_magic = 0x7f454c46;
uint32_t *p_magic = (void *)buf;
nemu_assert(*p_magic == elf_magic);
/* Load each program segment */
for(; true; ) {
/* Scan the program header table, load each segment into memory */
if(ph->p_type == PT_LOAD) { //PT_LOAT=1, Loadable program segment
/* TODO: read the content of the segment from the ELF file
* to the memory region [VirtAddr, VirtAddr + FileSiz)
*/
/* TODO: zero the memory region
* [VirtAddr + FileSiz, VirtAddr + MemSiz)
*/
#ifdef IA32_PAGE
/* Record the program break for future use. */
extern uint32_t brk;
uint32_t new_brk = ph->p_vaddr + ph->p_memsz - 1;
if(brk < new_brk) { brk = new_brk; }
#endif
}
}
volatile uint32_t entry = elf->e_entry;
#ifdef IA32_PAGE
mm_malloc(KOFFSET - STACK_SIZE, STACK_SIZE);
#ifdef HAS_DEVICE
create_video_mapping();
#endif
write_cr3(get_ucr3());
#endif
return entry;
}
int32_t fat16_mount(struct superblock_t *superblock) {
int i;
uint32_t offset = 0;
uint32_t boot_offset;
Partition partitionTable[4];
/* Read the partition table */
offset = PARTITION_TABLE_OFFSET;
ramdisk_read(offset, sizeof(Partition)*4, partitionTable);
/* Check for valid FAT16 partition type */
for (int i = 0; i < 4; i++) {
if (partitionTable[i].type == 4 ||
partitionTable[i].type == 6 ||
partitionTable[i].type == 14) {
if (debug) printk("Found FAT16 partition!\n");
break;
}
}
/* Calculate boot sector offset */
if (i == 4) {
if (debug) printk("No FAT16 partition found!\n");
return -1;
} else {
boot_offset = 512 * partitionTable[i].start_sector;
}
/* Read the MBR */
offset = boot_offset;
ramdisk_read(offset, sizeof(FAT16BootSector), &bootSector);
/* Calculate start locations of FAT, root dir, and data */
fat_start = bootSector.reserved_sectors * bootSector.sector_size;
root_start = fat_start + bootSector.sectors_per_FAT * bootSector.num_FATs * bootSector.sector_size;
data_start = root_start + bootSector.num_root_entries * sizeof(DirEntry);
return 0;
}
/* Just use the file entry offset as the inode.
Note: only looking in root directory */
int32_t fat16_get_inode(const char *name) {
int i;
int32_t inode = 0;
uint32_t offset = root_start;
FAT16DirEntry entry;
/* Scan through root dir looking for matching filename */
for (i = 0; i < bootSector.num_root_entries; i++) {
inode = offset;
ramdisk_read(offset, sizeof(FAT16DirEntry), &entry);
if (!strncmp(name, entry.filename, 8)) {
return inode;
}
}
return -1;
}
/* ramdisk_ioctl --
* IOCTL handler for RAM disk device.
*
* PARAMETERS:
* dev - device number (major, minor number)
* req - IOCTL request code
* argp - IOCTL argument
*
* RETURNS:
* IOCTL return value
*/
static int
ramdisk_ioctl(dev_t dev, uint32_t req, void *argp)
{
switch (req)
{
case BLKIO_REQUEST:
{
rtems_device_minor_number minor;
blkdev_request *r = argp;
struct ramdisk *rd;
minor = rtems_filesystem_dev_minor_t(dev);
if ((minor >= nramdisks) || !ramdisk[minor].initialized)
{
errno = ENODEV;
return -1;
}
rd = ramdisk + minor;
switch (r->req)
{
case BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
default:
errno = EBADRQC;
return -1;
}
break;
}
default:
errno = EBADRQC;
return -1;
}
}
uint32_t loader() {
Elf32_Ehdr *elf;
Elf32_Phdr *ph = NULL;
uint8_t buf[4096];
#ifdef HAS_DEVICE
ide_read(buf, ELF_OFFSET_IN_DISK, 4096);
#else
ramdisk_read(buf, ELF_OFFSET_IN_DISK, 4096);
#endif
elf = (void*)buf;
/* DONE: fix the magic number with the correct one */
const uint32_t elf_magic = 0x464c457f;
uint32_t *p_magic = (void *)buf;
nemu_assert(*p_magic == elf_magic);
/* Load each program segment */
//panic("please implement me");
ph = (Elf32_Phdr *)(buf + elf->e_phoff);
uint16_t i = 0;
for(i = 0; i < elf->e_phnum; ++i) {
//if(elf->e_phnum == 3) {HIT_BAD_TRAP;}
/* Scan the program header table, load each segment into memory */
if(ph->p_type == PT_LOAD) {
uint32_t hwaddr = mm_malloc(ph->p_vaddr, ph->p_memsz);
/* DONE: read the content of the segment from the ELF file to the memory region [VirtAddr, VirtAddr + FileSiz) */
ramdisk_read((uint8_t *)hwaddr, ph->p_offset, ph->p_filesz);
/* DONE: zero the memory region [VirtAddr + FileSiz, VirtAddr + MemSiz) */
memset((void *)hwaddr + ph->p_filesz, 0, ph->p_memsz - ph->p_filesz);
#ifdef IA32_PAGE
/* Record the program break for future use. */
extern uint32_t brk;
uint32_t new_brk = ph->p_vaddr + ph->p_memsz - 1;
if(brk < new_brk) { brk = new_brk; }
#endif
}
ph++;
}
volatile uint32_t entry = elf->e_entry;
#ifdef IA32_PAGE
mm_malloc(KOFFSET - STACK_SIZE, STACK_SIZE);
#ifdef HAS_DEVICE
create_video_mapping();
#endif
write_cr3(get_ucr3());
#endif
return entry;
}
uint32_t loader() {
Elf32_Ehdr *elf;
Elf32_Phdr *ph = NULL;
uint8_t buf[HEAD_SIZE];
uint8_t buf_[_SIZE_];
#ifdef HAS_DEVICE
ide_read(buf, ELF_OFFSET_IN_DISK, HEAD_SIZE);
#else
ramdisk_read(buf, ELF_OFFSET_IN_DISK, HEAD_SIZE);
#endif
elf = (void*)buf;
/* TODO: fix the magic number with the correct one */
const uint32_t elf_magic = 0x464c457f;
uint32_t *p_magic = (void *)buf;
nemu_assert(*p_magic == elf_magic);
int cnt;
/* Load each program segment */
for(cnt = 0; cnt < elf->e_phnum; ++ cnt) {
/* Scan the program header table, load each segment into memory */
/*
#ifdef HAS_DEVICE
ide_read(buf_, ELF_OFFSET_IN_DISK + elf->e_ehsize + cnt * elf->e_phentsize, elf->e_phentsize);
#else
ramdisk_read(buf_, ELF_OFFSET_IN_DISK + elf->e_ehsize + cnt * elf->e_phentsize, elf->e_phentsize);
#endif
*/
ph = (void*)(buf + elf->e_ehsize + cnt * elf->e_phentsize);
// ph = (void*)buf_;
if(ph->p_type == PT_LOAD) {
/* TODO: read the content of the segment from the ELF file
* to the memory region [VirtAddr, VirtAddr + FileSiz)
*/
#ifdef HAS_DEVICE
ide_read(buf_, ELF_OFFSET_IN_DISK + ph->p_offset, ph->p_filesz);
#else
ramdisk_read(buf_, ELF_OFFSET_IN_DISK + ph->p_offset, ph->p_filesz);
#endif
uint32_t hwaddr =
mm_malloc(ph->p_vaddr, ph->p_memsz);
memcpy((void *)hwaddr, (void *)(buf_), ph->p_filesz);
/* TODO: zero the memory region
* [VirtAddr + FileSiz, VirtAddr + MemSiz)
*/
// Log("%x %x %x %x", ph->p_vaddr, ph->p_filesz, ph->p_memsz, ph->p_vaddr + ph->p_filesz);
memset((void *)hwaddr + ph->p_filesz, 0, ph->p_memsz - ph->p_filesz);
#ifdef IA32_PAGE
/* Record the program break for future use. */
extern uint32_t brk;
uint32_t new_brk = ph->p_vaddr + ph->p_memsz - 1;
if(brk < new_brk) {
brk = new_brk;
}
#endif
}
}
volatile uint32_t entry = elf->e_entry;
#ifdef IA32_PAGE
mm_malloc(KOFFSET - STACK_SIZE, STACK_SIZE);
#ifdef HAS_DEVICE
create_video_mapping();
#endif
write_cr3(get_ucr3());
#endif
// HIT_GOOD_TRAP;
return entry;
}
uint32_t loader() {
Elf32_Ehdr *elf;
Elf32_Phdr *ph = NULL;
uint8_t buf[4096];
#ifdef HAS_DEVICE
ide_read(buf, ELF_OFFSET_IN_DISK, 4096);
#else
ramdisk_read(buf, ELF_OFFSET_IN_DISK, 4096);
#endif
elf = (void*)buf;
int i;
/* TODO: fix the magic number with the correct one */
const uint32_t elf_magic = 0x464c457f;
uint32_t *p_magic = (void *)buf;
nemu_assert(*p_magic == elf_magic);
/* Load each program segment */
//panic("please implement me");
for(ph=(Elf32_Phdr*)(buf+elf->e_phoff),i=0;i<elf->e_phnum;i++ ) {
/* Scan the program header table, load each segment into memory */
if(ph->p_type == PT_LOAD ) {
/* TODO: read the content of the segment from the ELF file
* to the memory region [VirtAddr, VirtAddr + FileSiz)
*/
uint32_t va=(uint32_t)(ph->p_vaddr);
uint8_t* my_vaddr=(uint8_t*)mm_malloc(va,ph->p_memsz);
ide_read(my_vaddr,ph->p_offset,ph->p_filesz);
//void* rstart=(void*)0;
//memcpy(my_vaddr,rstart+ph->p_offset,ph->p_filesz);
/* TODO: zero the memory region
* [VirtAddr + FileSiz, VirtAddr + MemSiz)
*/
my_vaddr+=ph->p_filesz;
int j;
for(j=0;j<ph->p_memsz-ph->p_filesz;j++)
*(my_vaddr+j)=0;
#ifdef IA32_PAGE
/* Record the program break for future use. */
extern uint32_t brk;
uint32_t new_brk = ph->p_vaddr + ph->p_memsz - 1;
if(brk < new_brk) { brk = new_brk; }
#endif
ph++;
}
}
uint32_t entry = elf->e_entry;
#ifdef IA32_PAGE
mm_malloc(KOFFSET - STACK_SIZE, STACK_SIZE);
#ifdef HAS_DEVICE
create_video_mapping();
#endif
write_cr3(get_ucr3());
#endif
return entry;
}
