Esempio n. 1
0
void
sscapeintr(int irq)
{
    u_char   bits, tmp;

    DEB(printf("sscapeintr(0x%02x)\n", (bits = sscape_read(devc, GA_INTSTAT_REG))));
    if ((sscape_sleep_flag.mode & WK_SLEEP)) {
	sscape_sleep_flag.mode = WK_WAKEUP;
	wakeup(sscape_sleeper);
    }
    if (bits & 0x02) {	/* Host interface interrupt */
	printf("SSCAPE: Host interrupt, data=%02x\n", host_read(devc));
    }
#if (defined(CONFIG_MPU401) || defined(CONFIG_MPU_EMU)) && defined(CONFIG_MIDI)
    if (bits & 0x01) {
	static int debug = 0;

	mpuintr(irq);
	if (debug++ > 10) {	/* Temporary debugging hack */
	    sscape_write(devc, GA_INTENA_REG, 0x00); /* Disable all interr. */
	}
    }
#endif

    /*
     * Acknowledge interrupts (toggle the interrupt bits)
     */

    tmp = sscape_read(devc, GA_INTENA_REG);
    sscape_write(devc, GA_INTENA_REG, (~bits & 0x0e) | (tmp & 0xf1));
}
Esempio n. 2
0
int hostif_getch()
{
 	unsigned char ch = 0;
	if(host_read(STDIN_FILENO, &ch, 1) != 1) {
		return EOF;
	}
	return (int)ch;
 
}
Esempio n. 3
0
static void set_control(struct sscape_info *devc, int ctrl, int value)
{
	host_open(devc);
	host_command3(devc, CMD_SET_CONTROL, ctrl, value);
	if (host_read(devc) != CMD_ACK)
	{
		/* printk( "SNDSCAPE: Setting control (%d) failed\n",  ctrl); */
	}
	host_close(devc);
}
Esempio n. 4
0
static void set_mt32(struct sscape_info *devc, int value)
{
	host_open(devc);
	host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
	if (host_read(devc) != CMD_ACK)
	{
		/* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
	}
	host_close(devc);
}
Esempio n. 5
0
static int
hostcons_getchar()
{
	uint8_t ch;
	int rv;

	rv = host_read(0, &ch, 1);
	if (rv == 1)
		return (ch);
	return (-1);
}
Esempio n. 6
0
//Copy file operation
int copy_file() {
    int in_fd;
    FILE* out_fd;
    int fsize = 0;
    char file_name[MAX_BUFFER_SIZE];

    /* Get the file name to copy to 
     * This will activate our hook on the invalid opcode in the python script.
     */

    host_get_file_name(agent_buffer, sizeof(agent_buffer));
    strncpy(file_name,agent_buffer,sizeof(file_name));

    /* Open file on the host. */

    if ((in_fd = host_open(file_name)) == -1){
        fprintf(stderr, "Error opening file on host\n");
        return 2;
    }

    /* Read file from the host and output it on stdout. */
    if ((out_fd = fopen(file_name, "wb")) == NULL){
        fprintf(stderr, "Error opening file %s on guest for writing\n", file_name);
        return 3;
    }
     
    /* Data read loop */
    while (1) {
        int ret = host_read(in_fd, agent_buffer, sizeof(agent_buffer));
        if (ret == -1) {
            fprintf(stderr, "Error reading from host file\n");
            return 4;
        }
        else if (ret == 0) {
            break;
        }

        if (fwrite(agent_buffer, 1, ret, out_fd) != ret) {
            fprintf(stderr, "Error writing to file on guest\n");
            return 5;
        }

        fsize += ret;
    }

    /* Don't forget to close the file on the host. */
    host_close(in_fd);
    fclose(out_fd);

    fprintf(stderr, "File %s of size %d was successfully transferred\n", file_name, fsize);
    return 0;

}
Esempio n. 7
0
// Fault any disk block that is read or written in to memory by
// loading it from disk.
// Hint: Use ide_read and BLKSECTS.
    static void
bc_pgfault(struct UTrapframe *utf)
{
    void *addr = (void *) utf->utf_fault_va;
    uint64_t blockno = ((uint64_t)addr - DISKMAP) / BLKSIZE;
    int r;

    // Check that the fault was within the block cache region
	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))
		panic("page fault in FS: eip %08x, va %08x, err %04x",
		      utf->utf_rip, addr, utf->utf_err);

    // Sanity check the block number.
    if (super && blockno >= super->s_nblocks)
        panic("reading non-existent block %08x\n", blockno);

    // Allocate a page in the disk map region, read the contents
    // of the block from the disk into that page, and mark the
    // page not-dirty (since reading the data from disk will mark
    // the page dirty).
    //
    // LAB 5: Your code here
	
	
	if((r= sys_page_alloc(0, ROUNDDOWN(addr,PGSIZE), PTE_SYSCALL)) < 0)
	panic("File System page fault handler couldn't alloc new page at addr %d. %e",addr, r);
	
	//if(super)
	//	cprintf("12 %d\n",super->s_nblocks);
#ifndef VMM_GUEST
	if((r = ide_read(blockno*BLKSECTS, ROUNDDOWN(addr,BLKSIZE), BLKSECTS)) < 0)
#else
     if((r = host_read(BLKSECTS*blockno, ROUNDDOWN(addr,BLKSIZE), BLKSECTS)) < 0)

#endif	
	panic("File System page fault handler couldn't read in the data from disk. %e", r);
	
	//if(super)
	//	cprintf("13 %d\n",super->s_nblocks);
	if((r = sys_page_map(0, ROUNDDOWN(addr,PGSIZE), 0, ROUNDDOWN(addr,BLKSIZE), PTE_P| PTE_U | PTE_W)) < 0) //PTE_SYSCALL&~PTE_D
			panic("Couldn't map page not dirty bc_pageflt %e",r);
	
	//if(super)
	//	cprintf("14 %d\n",super->s_nblocks);
	//cprintf("Handled the Fault\n");
	//panic("bc_pgfault not implemented");
	// Check that the block we read was allocated. (exercise for
	// the reader: why do we do this *after* reading the block
	// in?)
	if (bitmap && block_is_free(blockno))
		panic("reading free block %08x\n", blockno);
}
Esempio n. 8
0
static int
get_board_type (struct sscape_info *devc)
{
  int             tmp;

  host_open (devc);
  if (!host_command1 (devc, CMD_GET_BOARD_TYPE))
    tmp = -1;
  else
    tmp = host_read (devc);
  host_close (devc);
  return tmp;
}
Esempio n. 9
0
// Fault any disk block that is read in to memory by
// loading it from disk.
// Hint: Use ide_read and BLKSECTS.
static void
bc_pgfault(struct UTrapframe *utf)
{
	void *addr = (void *) utf->utf_fault_va;
	uint64_t blockno = ((uint64_t)addr - DISKMAP) / BLKSIZE;
	int r;

	// Check that the fault was within the block cache region
	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))
		panic("page fault in FS: eip %08x, va %08x, err %04x",
			  utf->utf_rip, addr, utf->utf_err);

	// Sanity check the block number.
	if (super && blockno >= super->s_nblocks)
		panic("reading non-existent block %08x\n", blockno);

	// Allocate a page in the disk map region, read the contents
	// of the block from the disk into that page.
	// Hint: first round addr to page boundary.
	//
	// LAB 5: your code here:
	addr = ROUNDDOWN(addr, PGSIZE);
	if(0 != sys_page_alloc(0, (void*)addr, PTE_SYSCALL)){
		panic("Page Allocation Failed during handling page fault in FS");
	}
#ifdef VMM_GUEST
	if(0 != host_read((uint32_t) (blockno * BLKSECTS), (void*)addr, BLKSECTS))
	{
		panic("ide read failed in Page Fault Handling");		
	}
#else
	if(0 != ide_read((uint32_t) (blockno * BLKSECTS), (void*)addr, BLKSECTS))
	{
		panic("ide read failed in Page Fault Handling");		
	}
#endif	
	if ((r = sys_page_map(0, addr, 0, addr, uvpt[PGNUM(addr)] & PTE_SYSCALL)) < 0)
		panic("in bc_pgfault, sys_page_map: %e", r);

	// Check that the block we read was allocated. (exercise for
	// the reader: why do we do this *after* reading the block
	// in?)
	if (bitmap && block_is_free(blockno))
		panic("reading free block %08x\n", blockno);
}
Esempio n. 10
0
File: bc.c Progetto: xiangho/Cse506
// Fault any disk block that is read in to memory by
// loading it from disk.
static void
bc_pgfault(struct UTrapframe *utf)
{
	void *addr = (void *) utf->utf_fault_va;
	uint64_t blockno = ((uint64_t)addr - DISKMAP) / BLKSIZE;
	int r;

	// Check that the fault was within the block cache region
	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))
		panic("page fault in FS: eip %08x, va %08x, err %04x",
		      utf->utf_rip, addr, utf->utf_err);

	// Sanity check the block number.
	if (super && blockno >= super->s_nblocks)
		panic("reading non-existent block %08x\n", blockno);

	// Allocate a page in the disk map region, read the contents
	// of the block from the disk into that page.
	// Hint: first round addr to page boundary.
	//
	// LAB 5: your code here:

	// Check that the block we read was allocated. (exercise for
	// the reader: why do we do this *after* reading the block
	// in?)
	if (bitmap && block_is_free(blockno))    //doubtful
		panic("reading free block %08x\n", blockno);

	void *new_addr = ROUNDDOWN(addr, PGSIZE);
	r = sys_page_alloc(0, new_addr, PTE_P|PTE_W|PTE_U);
	if(r<0)
		panic("Something wrong with allocation %e",r);
	uint64_t sec_no = BLKSECTS * blockno;
	size_t nsecs = BLKSECTS;
#ifdef VMM_GUEST
		r = host_read(sec_no, new_addr, nsecs);
#else
	r = ide_read(sec_no, new_addr, nsecs);
#endif
	if(r<0)
		panic("Something wrong with reading from the disk %e",r);
}
void
nuse_vif_pipe_read(struct nuse_vif *vif, struct SimDevice *dev)
{
	int sock = vif->sock;
	char buf[8192];
	ssize_t size;

	while (1) {
		size = host_read(sock, buf, sizeof(buf));
		if (size < 0) {
			perror("read");
			host_close(sock);
			return;
		} else if (size == 0) {
			host_close(sock);
			return;
		}

		nuse_dev_rx(dev, buf, size);
	}
}
Esempio n. 12
0
void
sscapeintr (int irq, void *dev_id, struct pt_regs *dummy)
{
  unsigned char   bits, tmp;
  static int      debug = 0;

  bits = sscape_read (devc, GA_INTSTAT_REG);
  if ((sscape_sleep_flag.flags & WK_SLEEP))
    {
      {
	sscape_sleep_flag.flags = WK_WAKEUP;
	module_wake_up (&sscape_sleeper);
      };
    }

  if (bits & 0x02)		/* Host interface interrupt */
    {
      printk ("SSCAPE: Host interrupt, data=%02x\n", host_read (devc));
    }

#if defined(CONFIG_MPU_EMU) && defined(CONFIG_MIDI)
  if (bits & 0x01)
    {
      mpuintr (irq, NULL, NULL);
      if (debug++ > 10)		/* Temporary debugging hack */
	{
	  sscape_write (devc, GA_INTENA_REG, 0x00);	/* Disable all interrupts */
	}
    }
#endif

  /*
     * Acknowledge interrupts (toggle the interrupt bits)
   */

  tmp = sscape_read (devc, GA_INTENA_REG);
  sscape_write (devc, GA_INTENA_REG, (~bits & 0x0e) | (tmp & 0xf1));

}
Esempio n. 13
0
static	int sscape_read_host_ctrl(sscape_info* devc)
{
	return host_read(devc);
}