-use std::convert::TryFrom;
-use std::io::{self, Read, Write};
-
use log::trace;
use rustc_middle::mir;
let fd = this.read_scalar(fd)?.to_i32()?;
let buf = this.read_scalar(buf)?.check_init()?;
let count = this.read_scalar(count)?.to_machine_usize(this)?;
- let result = if fd == 0 {
-
- this.check_no_isolation("read")?;
-
- // We cap the number of read bytes to the largest
- // value that we are able to fit in both the
- // host's and target's `isize`. This saves us from
- // having to handle overflows later.
- let count = count.min(this.machine_isize_max() as u64).min(isize::MAX as u64);
-
- // We want to read at most `count` bytes. We are
- // sure that `count` is not negative because it
- // was a target's `usize`. Also we are sure that
- // its smaller than `usize::MAX` because it is a
- // host's `isize`.
- let mut buffer = vec![0; count as usize];
- let res = io::stdin()
- .read(&mut buffer)
- // `Stdin::read` never returns a value larger
- // than `count`, so this cannot fail.
- .map(|c| i64::try_from(c).unwrap());
-
- match res {
- Ok(bytes) => {
- this.memory.write_bytes(buf, buffer)?;
- i64::try_from(bytes).unwrap()
- },
- Err(e) => {
- this.set_last_error_from_io_error(e)?;
- -1
- },
- }
- } else if fd == 1 || fd == 2 {
- throw_unsup_format!("cannot read from stdout/stderr")
- } else {
- this.read(fd, buf, count)?
- };
+ let result = this.read(fd, buf, count)?;
this.write_scalar(Scalar::from_machine_isize(result, this), dest)?;
}
"write" => {
let buf = this.read_scalar(buf)?.check_init()?;
let count = this.read_scalar(n)?.to_machine_usize(this)?;
trace!("Called write({:?}, {:?}, {:?})", fd, buf, count);
- let result = if fd == 0 {
- throw_unsup_format!("cannot write to stdin")
- } else if fd == 1 || fd == 2 {
- // stdout/stderr
-
- let buf_cont = this.memory.read_bytes(buf, Size::from_bytes(count))?;
- // We need to flush to make sure this actually appears on the screen
- let res = if fd == 1 {
- // Stdout is buffered, flush to make sure it appears on the screen.
- // This is the write() syscall of the interpreted program, we want it
- // to correspond to a write() syscall on the host -- there is no good
- // in adding extra buffering here.
- let res = io::stdout().write(buf_cont);
- io::stdout().flush().unwrap();
- res
- } else {
- // No need to flush, stderr is not buffered.
- io::stderr().write(buf_cont)
- };
- match res {
- Ok(n) => i64::try_from(n).unwrap(),
- Err(e) => {
- this.set_last_error_from_io_error(e)?;
- -1
- }
- }
- } else {
- this.write(fd, buf, count)?
- };
+ let result = this.write(fd, buf, count)?;
// Now, `result` is the value we return back to the program.
this.write_scalar(Scalar::from_machine_isize(result, this), dest)?;
}
use std::collections::BTreeMap;
use std::convert::{TryFrom, TryInto};
use std::fs::{read_dir, remove_dir, remove_file, rename, DirBuilder, File, FileType, OpenOptions, ReadDir};
-use std::io::{Read, Seek, SeekFrom, Write};
+use std::io::{self, Read, Seek, SeekFrom, Write};
use std::path::Path;
use std::time::SystemTime;
writable: bool,
}
-#[derive(Debug, Default)]
-pub struct FileHandler {
- handles: BTreeMap<i32, FileHandle>,
+trait FileDescriptor<'tcx> : std::fmt::Debug {
+ fn as_file_handle(&self) -> InterpResult<'tcx, &FileHandle>;
+
+ fn read(&mut self, bytes: &mut [u8]) -> InterpResult<'tcx, io::Result<usize>>;
+ fn write(&mut self, bytes: &[u8]) -> InterpResult<'tcx, io::Result<usize>>;
+ fn seek(&mut self, offset: SeekFrom) -> InterpResult<'tcx, io::Result<u64>>;
+}
+
+impl<'tcx> FileDescriptor<'tcx> for FileHandle {
+ fn as_file_handle(&self) -> InterpResult<'tcx, &FileHandle> {
+ Ok(&self)
+ }
+
+ fn read(&mut self, bytes: &mut [u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ Ok(self.file.read(bytes))
+ }
+
+ fn write(&mut self, bytes: &[u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ Ok(self.file.write(bytes))
+ }
+
+ fn seek(&mut self, offset: SeekFrom) -> InterpResult<'tcx, io::Result<u64>> {
+ Ok(self.file.seek(offset))
+ }
+}
+
+impl<'tcx> FileDescriptor<'tcx> for io::Stdin {
+ fn as_file_handle(&self) -> InterpResult<'tcx, &FileHandle> {
+ throw_unsup_format!("stdin cannot be used as FileHandle");
+ }
+
+ fn read(&mut self, bytes: &mut [u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ Ok(Read::read(self, bytes))
+ }
+
+ fn write(&mut self, _bytes: &[u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ throw_unsup_format!("cannot write to stdin");
+ }
+
+ fn seek(&mut self, _offset: SeekFrom) -> InterpResult<'tcx, io::Result<u64>> {
+ throw_unsup_format!("cannot seek on stdin");
+ }
+}
+
+impl<'tcx> FileDescriptor<'tcx> for io::Stdout {
+ fn as_file_handle(&self) -> InterpResult<'tcx, &FileHandle> {
+ throw_unsup_format!("stdout cannot be used as FileHandle");
+ }
+
+ fn read(&mut self, _bytes: &mut [u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ throw_unsup_format!("cannot read from stdout");
+ }
+
+ fn write(&mut self, bytes: &[u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ let result = Write::write(self, bytes);
+ // Stdout is buffered, flush to make sure it appears on the
+ // screen. This is the write() syscall of the interpreted
+ // program, we want it to correspond to a write() syscall on
+ // the host -- there is no good in adding extra buffering
+ // here.
+ io::stdout().flush().unwrap();
+
+ Ok(result)
+ }
+
+ fn seek(&mut self, _offset: SeekFrom) -> InterpResult<'tcx, io::Result<u64>> {
+ throw_unsup_format!("cannot seek on stdout");
+ }
+}
+
+impl<'tcx> FileDescriptor<'tcx> for io::Stderr {
+ fn as_file_handle(&self) -> InterpResult<'tcx, &FileHandle> {
+ throw_unsup_format!("stdout cannot be used as FileHandle");
+ }
+
+ fn read(&mut self, _bytes: &mut [u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ throw_unsup_format!("cannot read from stderr");
+ }
+
+ fn write(&mut self, bytes: &[u8]) -> InterpResult<'tcx, io::Result<usize>> {
+ Ok(Write::write(self, bytes))
+ }
+
+ fn seek(&mut self, _offset: SeekFrom) -> InterpResult<'tcx, io::Result<u64>> {
+ throw_unsup_format!("cannot seek on stderr");
+ }
+}
+
+#[derive(Debug)]
+pub struct FileHandler<'tcx> {
+ handles: BTreeMap<i32, Box<dyn FileDescriptor<'tcx>>>,
+}
+
+impl<'tcx> Default for FileHandler<'tcx> {
+ fn default() -> Self {
+ let mut handles = BTreeMap::new();
+ handles.insert(0i32, Box::new(io::stdin()) as Box<dyn FileDescriptor<'_>>);
+ handles.insert(1i32, Box::new(io::stdout()) as Box<dyn FileDescriptor<'_>>);
+ handles.insert(2i32, Box::new(io::stderr()) as Box<dyn FileDescriptor<'_>>);
+ FileHandler {
+ handles
+ }
+ }
}
+
// fd numbers 0, 1, and 2 are reserved for stdin, stdout, and stderr
const MIN_NORMAL_FILE_FD: i32 = 3;
-impl FileHandler {
+impl<'tcx> FileHandler<'tcx> {
fn insert_fd(&mut self, file_handle: FileHandle) -> i32 {
self.insert_fd_with_min_fd(file_handle, 0)
}
self.handles.last_key_value().map(|(fd, _)| fd.checked_add(1).unwrap()).unwrap_or(min_fd)
});
- self.handles.insert(new_fd, file_handle).unwrap_none();
+ self.handles.insert(new_fd, Box::new(file_handle)).unwrap_none();
new_fd
}
}
}
let fh = &mut this.machine.file_handler;
let (file_result, writable) = match fh.handles.get(&fd) {
- Some(FileHandle { file, writable }) => (file.try_clone(), *writable),
+ Some(file_descriptor) => match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => (file.try_clone(), *writable),
+ Err(_) => return this.handle_not_found(),
+ },
None => return this.handle_not_found(),
};
let fd_result = file_result.map(|duplicated| {
&& cmd == this.eval_libc_i32("F_FULLFSYNC")?
{
let &[_, _] = check_arg_count(args)?;
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
- let io_result = maybe_sync_file(file, *writable, File::sync_all);
- this.try_unwrap_io_result(io_result)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ let io_result = maybe_sync_file(&file, *writable, File::sync_all);
+ this.try_unwrap_io_result(io_result)
+ },
+ Err(_) => this.handle_not_found(),
+ }
} else {
this.handle_not_found()
}
let fd = this.read_scalar(fd_op)?.to_i32()?;
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.remove(&fd) {
- // We sync the file if it was opened in a mode different than read-only.
- if writable {
- // `File::sync_all` does the checks that are done when closing a file. We do this to
- // to handle possible errors correctly.
- let result = this.try_unwrap_io_result(file.sync_all().map(|_| 0i32));
- // Now we actually close the file.
- drop(file);
- // And return the result.
- result
- } else {
- // We drop the file, this closes it but ignores any errors produced when closing
- // it. This is done because `File::sync_all` cannot be done over files like
- // `/dev/urandom` which are read-only. Check
- // https://github.com/rust-lang/miri/issues/999#issuecomment-568920439 for a deeper
- // discussion.
- drop(file);
- Ok(0)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.remove(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ // We sync the file if it was opened in a mode different than read-only.
+ if *writable {
+ // `File::sync_all` does the checks that are done when closing a file. We do this to
+ // to handle possible errors correctly.
+ let result = this.try_unwrap_io_result(file.sync_all().map(|_| 0i32));
+ // Now we actually close the file.
+ drop(file);
+ // And return the result.
+ result
+ } else {
+ // We drop the file, this closes it but ignores any errors produced when closing
+ // it. This is done because `File::sync_all` cannot be done over files like
+ // `/dev/urandom` which are read-only. Check
+ // https://github.com/rust-lang/miri/issues/999#issuecomment-568920439 for a deeper
+ // discussion.
+ drop(file);
+ Ok(0)
+ }
+ },
+ Err(_) => this.handle_not_found()
}
} else {
this.handle_not_found()
let this = self.eval_context_mut();
this.check_no_isolation("read")?;
- assert!(fd >= 3);
trace!("Reading from FD {}, size {}", fd, count);
// host's and target's `isize`. This saves us from having to handle overflows later.
let count = count.min(this.machine_isize_max() as u64).min(isize::MAX as u64);
- if let Some(FileHandle { file, writable: _ }) = this.machine.file_handler.handles.get_mut(&fd) {
- trace!("read: FD mapped to {:?}", file);
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
+ trace!("read: FD mapped to {:?}", file_descriptor);
// We want to read at most `count` bytes. We are sure that `count` is not negative
// because it was a target's `usize`. Also we are sure that its smaller than
// `usize::MAX` because it is a host's `isize`.
let mut bytes = vec![0; count as usize];
- let result = file
- .read(&mut bytes)
- // `File::read` never returns a value larger than `count`, so this cannot fail.
+ // `File::read` never returns a value larger than `count`,
+ // so this cannot fail.
+ let result = file_descriptor
+ .read(&mut bytes)?
.map(|c| i64::try_from(c).unwrap());
match result {
) -> InterpResult<'tcx, i64> {
let this = self.eval_context_mut();
- this.check_no_isolation("write")?;
- assert!(fd >= 3);
+ if fd >= 3 {
+ this.check_no_isolation("write")?;
+ }
// Check that the *entire* buffer is actually valid memory.
this.memory.check_ptr_access(
// host's and target's `isize`. This saves us from having to handle overflows later.
let count = count.min(this.machine_isize_max() as u64).min(isize::MAX as u64);
- if let Some(FileHandle { file, writable: _ }) = this.machine.file_handler.handles.get_mut(&fd) {
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
let bytes = this.memory.read_bytes(buf, Size::from_bytes(count))?;
- let result = file.write(&bytes).map(|c| i64::try_from(c).unwrap());
+ let result = file_descriptor
+ .write(&bytes)?
+ .map(|c| i64::try_from(c).unwrap());
this.try_unwrap_io_result(result)
} else {
this.handle_not_found()
return Ok(-1);
};
- if let Some(FileHandle { file, writable: _ }) = this.machine.file_handler.handles.get_mut(&fd) {
- let result = file.seek(seek_from).map(|offset| i64::try_from(offset).unwrap());
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
+ let result = file_descriptor
+ .seek(seek_from)?
+ .map(|offset| i64::try_from(offset).unwrap());
this.try_unwrap_io_result(result)
} else {
this.handle_not_found()
let fd = this.read_scalar(fd_op)?.to_i32()?;
let length = this.read_scalar(length_op)?.to_i64()?;
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get_mut(&fd) {
- if *writable {
- if let Ok(length) = length.try_into() {
- let result = file.set_len(length);
- this.try_unwrap_io_result(result.map(|_| 0i32))
- } else {
- let einval = this.eval_libc("EINVAL")?;
- this.set_last_error(einval)?;
- Ok(-1)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ if *writable {
+ if let Ok(length) = length.try_into() {
+ let result = file.set_len(length);
+ this.try_unwrap_io_result(result.map(|_| 0i32))
+ } else {
+ let einval = this.eval_libc("EINVAL")?;
+ this.set_last_error(einval)?;
+ Ok(-1)
+ }
+ } else {
+ // The file is not writable
+ let einval = this.eval_libc("EINVAL")?;
+ this.set_last_error(einval)?;
+ Ok(-1)
+ }
}
- } else {
- // The file is not writable
- let einval = this.eval_libc("EINVAL")?;
- this.set_last_error(einval)?;
- Ok(-1)
+ Err(_) => this.handle_not_found()
}
} else {
this.handle_not_found()
this.check_no_isolation("fsync")?;
let fd = this.read_scalar(fd_op)?.to_i32()?;
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
- let io_result = maybe_sync_file(file, *writable, File::sync_all);
- this.try_unwrap_io_result(io_result)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ let io_result = maybe_sync_file(&file, *writable, File::sync_all);
+ this.try_unwrap_io_result(io_result)
+ }
+ Err(_) => this.handle_not_found()
+ }
} else {
this.handle_not_found()
}
this.check_no_isolation("fdatasync")?;
let fd = this.read_scalar(fd_op)?.to_i32()?;
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
- let io_result = maybe_sync_file(file, *writable, File::sync_data);
- this.try_unwrap_io_result(io_result)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ let io_result = maybe_sync_file(&file, *writable, File::sync_data);
+ this.try_unwrap_io_result(io_result)
+ }
+ Err(_) => this.handle_not_found()
+ }
} else {
this.handle_not_found()
}
return Ok(-1);
}
- if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
- let io_result = maybe_sync_file(file, *writable, File::sync_data);
- this.try_unwrap_io_result(io_result)
+ if let Some(file_descriptor) = this.machine.file_handler.handles.get(&fd) {
+ match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable }) => {
+ let io_result = maybe_sync_file(&file, *writable, File::sync_data);
+ this.try_unwrap_io_result(io_result)
+ },
+ Err(_) => this.handle_not_found()
+ }
} else {
this.handle_not_found()
}
) -> InterpResult<'tcx, Option<FileMetadata>> {
let option = ecx.machine.file_handler.handles.get(&fd);
let file = match option {
- Some(FileHandle { file, writable: _ }) => file,
+ Some(file_descriptor) => match file_descriptor.as_file_handle() {
+ Ok(FileHandle { file, writable: _ }) => file,
+ Err(_) => return ecx.handle_not_found().map(|_: i32| None),
+ },
None => return ecx.handle_not_found().map(|_: i32| None),
};
let metadata = file.metadata();
projects / rust.git / commitdiff