예제 #1
0
파일: syscall.c 프로젝트: idoitlpg/pintos
/* Execute Process */
tid_t exec (const char *cmd_line)
{
  struct thread *child = NULL;
  tid_t child_pid = 0;

  /* Execute process with cmd_line */
  child_pid = process_execute (cmd_line);
  /* get Process context with pid */
  child = get_child_process (child_pid);
  if (!child)
    return -1;

  /* Wait for loading child process */
  if (child->thread_loaded == NO_LOAD)
  {
    sema_down(&child->sema_load);
  }

  /* Return error for exception */
  if (child->thread_loaded == FAIL_LOAD)
    return -1;

  /* Return pid of child process */
  return child_pid;
}
예제 #2
0
파일: syscall.c 프로젝트: roomylee/PintOS
tid_t 
exec(const char* cmd_line)
{
	tid_t tid;
	struct thread* t;
	tid = process_execute(cmd_line);
	if( tid == TID_ERROR )
		return -1;
	t = get_child_process(tid);
	if( t-> load_success == 0 )
		return (tid_t)-1;
	else
		return tid;
}
예제 #3
0
파일: syscall.c 프로젝트: GunjuKo/Pintos
/* create child process and wait until childprocess is loaded */
tid_t
exec(const char *cmd_name)
{
	struct thread *child_process;
	tid_t pid;
	
	pid = process_execute(cmd_name);
	child_process = get_child_process(pid);
    /* wait child process */	
	sema_down(&(child_process->load_semaphore));      
	if(child_process->load_success==true)
		return pid;
	else
	{
		return -1;
	}
}
예제 #4
0
static void
syscall_handler (struct intr_frame *f)
{
  uint32_t *p = f->esp;
  check_ptr(p);
  switch (*(int *)p)
  {
  /* Halt the operating system.
    IN : void
    OUT: void
  */
  case SYS_HALT:
  {
    shutdown_power_off();
    break;
  }

  /* Terminate this process.
    IN : int status
    OUT: void
  */
  case SYS_EXIT:
  {
    check_ptr(p + 1);
    int status = *(int *)(p + 1);
    exit(status);
    break;
  }


  /* Start another process.
    IN : const char *file
    OUT: pid_t
  */
  case SYS_EXEC:
  {
    check_string(p + 1);
    // f->eax = process_execute(*(char **)(p + 1));
    pid_t pid = process_execute(*(char **)(p + 1));
    struct child_process *cp = get_child_process(pid);
    if(cp->load == LOAD_SUCCESS)
      f->eax = pid;
    else if(cp->load == LOAD_FAIL)
      f->eax = -1;
    break;
  }

  /* Wait for a child process to die.
    IN : pid_t
    OUT: int
  */
  case SYS_WAIT:
  {
    check_ptr(p + 1);
    f->eax = process_wait(*(tid_t *)(p + 1));
    break;
  }

  /* Create a file.
    IN :const char *file, unsigned initial_size
    OUT:bool
  */
  case SYS_CREATE:
  {
    check_string(p + 1);
    check_ptr(p + 2);
    if(*(char**)(p+1)==NULL||*(int *)(p+1)>=PHYS_BASE||
      pagedir_get_page(thread_current()->pagedir, (const void *)*(p+1)) == NULL)
      exit(-1);
    
    f->eax = filesys_create(*(const char **)(p + 1), *(off_t *)(p + 2));
    
    break;
  }

  /* Delete a file.
    IN: const char *file
    OUT: bool
  */
  case SYS_REMOVE:
  {

    check_string(p + 1);
    if(*(char**)(p+1)==NULL||*(int *)(p+1)>=PHYS_BASE||
      pagedir_get_page(thread_current()->pagedir, (const void *)*(p+1)) == NULL)
      exit(-1);
    
    f->eax = filesys_remove(*(char**)(p + 1));
    break;
  }

  /* Open a file.
    IN: const char *file
    OUT: int
  */
  case SYS_OPEN:
  {
    check_string(p + 1);
    
    struct file *file = filesys_open(*(char**)(p + 1));
    if (file == NULL)
    {
      f->eax = -1;
      break;
    }
    struct file_desc *desc = malloc(sizeof(struct file_desc));
    desc->file = file;
    desc->fd = thread_current()->fd;
    thread_current()->fd++;
    list_push_back(&thread_current()->file_list, &desc->elem);
    f->eax = desc->fd;
    break;
  }

  /* Obtain a file's size.
    IN: int fd
    OUT: int
  */
  case SYS_FILESIZE:
  {
    check_ptr(p + 1);
    int fd = *(p + 1);
    
    struct file *file = process_get_file(fd);
    if (file == NULL)
    {
      f->eax = FILE_ERROR;
    }
    else
    {
      f->eax = file_length(file);
    }
    break;
  }

  /* Read from a file.
    IN: int fd, void *buffer, unsigned length
    OUT: int
  */
  case SYS_READ:
  {
    check_ptr(p + 1);
    check_ptr(p + 2);
    check_ptr(p + 3);
    check_buffer(p + 2, *(p + 3));

    int fd = *(int *)(p + 1);
    void *buffer = *(char**)(p + 2);
    unsigned length = *(unsigned *)(p + 3);

    //read from keyboard. Fd 0 reads from keyboard using input_getc(): one each time.
    if (fd == STDIN_FILENO)
    {
      uint8_t *into_buffer = (uint8_t *) buffer;
      unsigned i;
      for (i = 0; i < length; i++)
      {
        into_buffer[i] = input_getc();
      }
      f->eax = length;
    }
    else
    {
      //read from file into buffer
      
      struct file *file = process_get_file(fd);
      //return -1 if file couldn't be read.
      if (file == NULL)
      {
            f->eax = FILE_ERROR;  //-1
      }
      else
      {
        int bytes = file_read(file, buffer, length);
            f->eax = bytes;
      }

    }
    break;
  }

  /* Write to a file.
    IN: int fd, const void *buffer, unsigned length
    OUT: int
  */
  case SYS_WRITE:
  {
    check_ptr(p + 1);
    check_ptr(p + 2);
    check_ptr(p + 3);
    check_buffer(p + 2, *(p + 3));

    int fd = *(int *)(p + 1);
    void *buffer = *(char**)(p + 2);
    unsigned length = *(off_t *)(p + 3);
    if (length <= 0)
    {
      f->eax = 0;
      break;
    }
    //Fd=1(STDOUT_FILENO) writes to the console.
    if (fd == STDOUT_FILENO)
    {
      putbuf(buffer, length);
      f->eax = length;
    }
    else
    {
      // return file by file descriptor.
      struct file *file = process_get_file(fd);
      if (file == NULL)
      {
            f->eax = FILE_ERROR;  //-1
      }
      else
      {
        int bytes = file_write(file, buffer, length);
        f->eax = bytes;
      }
    }
    break;
  }

  /* Change position in a file.
    IN: int fd, unsigned position
    OUT: void
  */
  case SYS_SEEK:
  {
    check_ptr(p + 1);
    check_ptr(p + 2);
    int fd = *(int *)(p+1);
    unsigned position = *(unsigned *)(p+2);
    
    struct file *file = process_get_file(fd);
    if(file != NULL)
    {
      file_seek(file, position);
    }
    break;
  }

  /* Report current position in a file.
    IN: int fd
    OUT: unsigned
  */
  case SYS_TELL:
  {
    check_ptr(p + 1);
    int fd = *(int *)(p+1);

    
    struct file *file = process_get_file(fd);
    if(file != NULL)
    {
      f->eax = file_tell(file);
    }
    else
      f->eax = FILE_ERROR;  //-1
    break;
  }

  /* Close a file.
    IN: int fd
    OUT: void
  */
  case SYS_CLOSE:
  {
    check_ptr(p+1);
    int fd = *(int*)(p+1);
    
    struct thread *t = thread_current();
    struct list_elem *next, *e = list_begin(&t->file_list);
    while (e != list_end (&t->file_list))
    {
      next = list_next(e);
      struct file_desc *fl = list_entry (e, struct file_desc, elem);
      if (fd == fl->fd)
      {
        file_close(fl->file);
        list_remove(&fl->elem);
        free(fl);
        break;
      }
      e = next;
    }
    break;
  }

  default:
    break;
  }

}