syscall.c

Simple Operating Systems （简称SOS）是一个可以运行在X86平台上（包括QEMU

	if (NULL == of)
	  {
	    retval = -SOS_EBADF;
	    break;
	  }

	/* Do the actual sync */
	retval = sos_fs_fsync(of);
      }
      break;

    case SOS_SYSCALL_ID_FCNTL:
      {
	struct sos_fs_opened_file * of;
	struct sos_process * proc;
	sos_ui32_t cmd, arg;
	int fd;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get3args(user_ctxt,
				      (unsigned int*)& fd,
				      (unsigned int*)& cmd,
				      (unsigned int*)& arg);
	if (SOS_OK != retval)
	  break;

	of = sos_process_get_opened_file(proc, fd);
	if (NULL == of)
	  {
	    retval = -SOS_EBADF;
	    break;
	  }

	/* Do the actual fcntl */
	retval = sos_fs_fcntl(of, cmd, arg);
      }
      break;

    case SOS_SYSCALL_ID_CREAT:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	sos_ui32_t  access_rights;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get3args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len,
				      (unsigned int*)& access_rights);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_creat(proc,
			      path, len,
			      access_rights);
	sos_kfree((sos_vaddr_t)path);
      }
      break;

    case SOS_SYSCALL_ID_LINK:
    case SOS_SYSCALL_ID_RENAME:
      {
	sos_uaddr_t user_oldpath, user_newpath;
	sos_size_t  oldpathlen, newpathlen;
	char * kernel_oldpath, * kernel_newpath;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get4args(user_ctxt,
				      (unsigned int*)& user_oldpath,
				      (unsigned int*)& oldpathlen,
				      (unsigned int*)& user_newpath,
				      (unsigned int*)& newpathlen);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &kernel_oldpath,
				      user_oldpath,
				      oldpathlen, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &kernel_newpath,
				      user_newpath,
				      newpathlen, 0);
	if (SOS_OK != retval)
	  {
	    sos_kfree((sos_vaddr_t) kernel_oldpath);
	    break;
	  }

	if (syscall_id == SOS_SYSCALL_ID_LINK)
	  retval = sos_fs_link(proc,
			       kernel_oldpath, oldpathlen,
			       kernel_newpath, newpathlen);
	else
	  retval = sos_fs_rename(proc,
				 kernel_oldpath, oldpathlen,
				 kernel_newpath, newpathlen);
	sos_kfree((sos_vaddr_t)kernel_oldpath);
	sos_kfree((sos_vaddr_t)kernel_newpath);
      }
      break;

    case SOS_SYSCALL_ID_UNLINK:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get2args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_unlink(proc,
			       path, len);
	sos_kfree((sos_vaddr_t)path);
      }
      break;

    case SOS_SYSCALL_ID_SYMLINK:
      {
	sos_uaddr_t user_path, user_targetpath;
	sos_size_t  pathlen, targetpathlen;
	char * kernel_path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get4args(user_ctxt,
				      (unsigned int*)& user_path,
				      (unsigned int*)& pathlen,
				      (unsigned int*)& user_targetpath,
				      (unsigned int*)& targetpathlen);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &kernel_path,
				      user_path,
				      pathlen, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_symlink(proc,
				kernel_path, pathlen,
				user_targetpath, targetpathlen);
	sos_kfree((sos_vaddr_t)kernel_path);
      }
      break;

    case SOS_SYSCALL_ID_MKDIR:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	sos_ui32_t  access_rights;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get3args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len,
				      (unsigned int*)& access_rights);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_mkdir(proc,
			      path, len, access_rights);
	sos_kfree((sos_vaddr_t)path);
      }
      break;

    case SOS_SYSCALL_ID_RMDIR:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get2args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_rmdir(proc, path, len);
	sos_kfree((sos_vaddr_t)path);
      }
      break;

    case SOS_SYSCALL_ID_CHMOD:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	sos_ui32_t  access_rights;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get3args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len,
				      (unsigned int*)& access_rights);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_chmod(proc, path, len, access_rights);
	sos_kfree((sos_vaddr_t)path);
      }
      break;

    case SOS_SYSCALL_ID_STAT64:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	sos_uaddr_t user_stat_struct;
	struct sos_fs_stat kernel_stat_struct;
	int nofollow;
	char * path;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get4args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len,
				      (unsigned int*)& nofollow,
				      (unsigned int*)& user_stat_struct);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_stat(proc, path, len, nofollow, & kernel_stat_struct);
	sos_kfree((sos_vaddr_t)path);
	if (SOS_OK != retval)
	  break;

	if (sizeof(kernel_stat_struct)
	    != sos_memcpy_to_user(user_stat_struct,
				  (sos_vaddr_t) & kernel_stat_struct,
				  sizeof(kernel_stat_struct)))
	  retval = -SOS_EFAULT;
      }
      break;

    case SOS_SYSCALL_ID_CHROOT:
    case SOS_SYSCALL_ID_CHDIR:
      {
	sos_uaddr_t user_str;
	sos_size_t  len;
	char * path;
	struct sos_fs_opened_file * of, * old_of;
	struct sos_process * proc;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get2args(user_ctxt,
				      (unsigned int*)& user_str,
				      (unsigned int*)& len);
	if (SOS_OK != retval)
	  break;

	retval = sos_memdup_from_user((sos_vaddr_t*) &path, user_str, len, 0);
	if (SOS_OK != retval)
	  break;

	retval = sos_fs_open(proc,
			     path, len,
			     SOS_FS_OPEN_DIRECTORY,
			     SOS_FS_OPEN_READ,
			     & of);
	sos_kfree((sos_vaddr_t)path);
	if (SOS_OK != retval)
	  break;

	if (syscall_id == SOS_SYSCALL_ID_CHROOT)
	  retval = sos_process_chroot(proc, of, & old_of);
	else
	  retval = sos_process_chdir(proc, of, & old_of);

	if (retval < 0)
	  {
	    sos_fs_close(of);
	    break;
	  }

	sos_fs_close(old_of);
      }
      break;      

    case SOS_SYSCALL_ID_FCHDIR:
      {
	struct sos_fs_opened_file * of, * new_of, * old_of;
	struct sos_process * proc;
	int fd;

	proc = sos_thread_get_current()->process;
	retval = sos_syscall_get1arg(user_ctxt,
				     (unsigned int*)& fd);
	if (SOS_OK != retval)
	  break;

	of = sos_process_get_opened_file(proc, fd);
	if (NULL == of)
	  {
	    retval = -SOS_EBADF;
	    break;
	  }

	/* Duplicate this FD */
	retval = sos_fs_duplicate_opened_file(of, proc, & new_of);
	if (SOS_OK != retval)
	  break;

	/* Do the actual chdir */
	retval = sos_process_chdir(proc, new_of, & old_of);
	if (retval < 0)
	  {
	    sos_fs_close(new_of);
	    break;
	  }

	sos_fs_close(old_of);
      }
      break;

    case SOS_SYSCALL_ID_BOCHS_WRITE:
      {
	sos_uaddr_t user_str;
	sos_size_t len;
	char * str;
	retval = sos_syscall_get2args(user_ctxt, & user_str, & len);
	if (SOS_OK != retval)
	  break;

	retval = sos_strndup_from_user(& str, user_str, len + 1, 0);
	if (SOS_OK == retval)
	  {
	    sos_bochs_printf("THR 0x%x: ",
			     (unsigned)sos_thread_get_current());
	    retval = sos_bochs_putstring(str);
	    retval = len;
	    sos_kfree((sos_vaddr_t)str);
	  }
      }
      break;


      /* ***********************************************
       * Debug syscalls (will be removed in the future)
       */


      /**
       * Syscall 4012: hexdump of a user-space memory region
       * args: addr_start size, retval=ignored
       */
    case 4012:
      {
	sos_uaddr_t user_str;
	unsigned int len;
	unsigned char * str;

	retval = sos_syscall_get2args(user_ctxt, & user_str, & len);
	if (SOS_OK != retval)
	  break;

	str = (char*)sos_kmalloc(len, 0);
	if (str)
	  {
	    int i;
	    sos_bochs_printf("Hexdump(0x%x, %d):\n", user_str, len);
	    retval = sos_memcpy_from_user((sos_vaddr_t) str, user_str, len);
	    sos_bochs_printf("  (Successfully copied %d out of %d)\n",
			     retval, len);

	    for (i = 0 ; i < retval ; i++)
	      {
		if ((i % 32) == 0)
		  sos_bochs_printf("%x:", i);
		sos_bochs_printf(" %x", str[i]);
		if (((i+1) % 32) == 0)
		  sos_bochs_printf("\n");
	      }
	    if (i % 32)
	      sos_bochs_printf("\n");

	    sos_kfree((sos_vaddr_t)str);
	  }
	else
	  retval = -SOS_ENOMEM;
      }
      break;

      
      /**
       * Syscall 4004: lists the VR of the current thread's address space
       * args: debug_string, retval=ignored
       */
    case 4004:
      {
	sos_uaddr_t ustr;
	char * kstr;
	struct sos_umem_vmm_as * my_as;

	retval = sos_syscall_get1arg(user_ctxt, & ustr);
	if (SOS_OK != retval)
	  break;

	retval = sos_strndup_from_user(& kstr, ustr, 256, 0);
	if (SOS_OK != retval)
	  break;

	extern void sos_dump_as(const struct sos_umem_vmm_as *, const char *);
	my_as
	  = sos_process_get_address_space(sos_thread_get_current()->process);
	sos_dump_as(my_as, kstr);
	sos_kfree((sos_vaddr_t)kstr);
      }
      break;


      /**
       * Syscall 4008: dump the list of processes in the system
       * args: none, retval=ignored
       */
    case 4008:
      {
	extern void sos_process_dumplist(void);
	sos_process_dumplist();
	retval = SOS_OK;
      }
      break;

    default:
      sos_bochs_printf("Syscall: UNKNOWN[%d]\n", syscall_id);
      retval = -SOS_ENOSUP;
    }
  
  return retval;
}