1 use std::collections::HashMap;
2 use std::convert::{TryFrom, TryInto};
3 use std::fs::{remove_file, rename, File, OpenOptions};
4 use std::io::{Read, Seek, SeekFrom, Write};
5 use std::path::PathBuf;
6 use std::time::SystemTime;
8 use rustc::ty::layout::{Align, LayoutOf, Size};
10 use crate::stacked_borrows::Tag;
12 use helpers::immty_from_uint_checked;
13 use shims::time::system_time_to_duration;
16 pub struct FileHandle {
21 pub struct FileHandler {
22 handles: HashMap<i32, FileHandle>,
26 impl Default for FileHandler {
27 fn default() -> Self {
29 handles: Default::default(),
30 // 0, 1 and 2 are reserved for stdin, stdout and stderr.
36 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
37 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
40 path_op: OpTy<'tcx, Tag>,
41 flag_op: OpTy<'tcx, Tag>,
42 ) -> InterpResult<'tcx, i32> {
43 let this = self.eval_context_mut();
45 this.check_no_isolation("open")?;
47 let flag = this.read_scalar(flag_op)?.to_i32()?;
49 let mut options = OpenOptions::new();
51 let o_rdonly = this.eval_libc_i32("O_RDONLY")?;
52 let o_wronly = this.eval_libc_i32("O_WRONLY")?;
53 let o_rdwr = this.eval_libc_i32("O_RDWR")?;
54 // The first two bits of the flag correspond to the access mode in linux, macOS and
55 // windows. We need to check that in fact the access mode flags for the current platform
56 // only use these two bits, otherwise we are in an unsupported platform and should error.
57 if (o_rdonly | o_wronly | o_rdwr) & !0b11 != 0 {
58 throw_unsup_format!("Access mode flags on this platform are unsupported");
60 let mut writable = true;
62 // Now we check the access mode
63 let access_mode = flag & 0b11;
65 if access_mode == o_rdonly {
68 } else if access_mode == o_wronly {
70 } else if access_mode == o_rdwr {
71 options.read(true).write(true);
73 throw_unsup_format!("Unsupported access mode {:#x}", access_mode);
75 // We need to check that there aren't unsupported options in `flag`. For this we try to
76 // reproduce the content of `flag` in the `mirror` variable using only the supported
78 let mut mirror = access_mode;
80 let o_append = this.eval_libc_i32("O_APPEND")?;
81 if flag & o_append != 0 {
85 let o_trunc = this.eval_libc_i32("O_TRUNC")?;
86 if flag & o_trunc != 0 {
87 options.truncate(true);
90 let o_creat = this.eval_libc_i32("O_CREAT")?;
91 if flag & o_creat != 0 {
95 let o_cloexec = this.eval_libc_i32("O_CLOEXEC")?;
96 if flag & o_cloexec != 0 {
97 // We do not need to do anything for this flag because `std` already sets it.
98 // (Technically we do not support *not* setting this flag, but we ignore that.)
101 // If `flag` is not equal to `mirror`, there is an unsupported option enabled in `flag`,
102 // then we throw an error.
104 throw_unsup_format!("unsupported flags {:#x}", flag & !mirror);
107 let path = this.read_os_str_from_c_str(this.read_scalar(path_op)?.not_undef()?)?;
109 let fd = options.open(&path).map(|file| {
110 let mut fh = &mut this.machine.file_handler;
112 fh.handles.insert(fh.low, FileHandle { file, writable }).unwrap_none();
116 this.try_unwrap_io_result(fd)
121 fd_op: OpTy<'tcx, Tag>,
122 cmd_op: OpTy<'tcx, Tag>,
123 _arg1_op: Option<OpTy<'tcx, Tag>>,
124 ) -> InterpResult<'tcx, i32> {
125 let this = self.eval_context_mut();
127 this.check_no_isolation("fcntl")?;
129 let fd = this.read_scalar(fd_op)?.to_i32()?;
130 let cmd = this.read_scalar(cmd_op)?.to_i32()?;
131 // We only support getting the flags for a descriptor.
132 if cmd == this.eval_libc_i32("F_GETFD")? {
133 // Currently this is the only flag that `F_GETFD` returns. It is OK to just return the
134 // `FD_CLOEXEC` value without checking if the flag is set for the file because `std`
135 // always sets this flag when opening a file. However we still need to check that the
136 // file itself is open.
137 if this.machine.file_handler.handles.contains_key(&fd) {
138 Ok(this.eval_libc_i32("FD_CLOEXEC")?)
140 this.handle_not_found()
143 throw_unsup_format!("The {:#x} command is not supported for `fcntl`)", cmd);
147 fn close(&mut self, fd_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
148 let this = self.eval_context_mut();
150 this.check_no_isolation("close")?;
152 let fd = this.read_scalar(fd_op)?.to_i32()?;
154 if let Some(handle) = this.machine.file_handler.handles.remove(&fd) {
155 // We sync the file if it was opened in a mode different than read-only.
157 // `File::sync_all` does the checks that are done when closing a file. We do this to
158 // to handle possible errors correctly.
159 let result = this.try_unwrap_io_result(handle.file.sync_all().map(|_| 0i32));
160 // Now we actually close the file.
162 // And return the result.
165 // We drop the file, this closes it but ignores any errors produced when closing
166 // it. This is done because `File::sync_call` cannot be done over files like
167 // `/dev/urandom` which are read-only. Check
168 // https://github.com/rust-lang/miri/issues/999#issuecomment-568920439 for a deeper
174 this.handle_not_found()
180 fd_op: OpTy<'tcx, Tag>,
181 buf_op: OpTy<'tcx, Tag>,
182 count_op: OpTy<'tcx, Tag>,
183 ) -> InterpResult<'tcx, i64> {
184 let this = self.eval_context_mut();
186 this.check_no_isolation("read")?;
188 let fd = this.read_scalar(fd_op)?.to_i32()?;
189 let buf = this.read_scalar(buf_op)?.not_undef()?;
190 let count = this.read_scalar(count_op)?.to_machine_usize(&*this.tcx)?;
192 // Check that the *entire* buffer is actually valid memory.
193 this.memory.check_ptr_access(
195 Size::from_bytes(count),
196 Align::from_bytes(1).unwrap(),
199 // We cap the number of read bytes to the largest value that we are able to fit in both the
200 // host's and target's `isize`. This saves us from having to handle overflows later.
201 let count = count.min(this.isize_max() as u64).min(isize::max_value() as u64);
203 if let Some(handle) = this.machine.file_handler.handles.get_mut(&fd) {
204 // This can never fail because `count` was capped to be smaller than
205 // `isize::max_value()`.
206 let count = isize::try_from(count).unwrap();
207 // We want to read at most `count` bytes. We are sure that `count` is not negative
208 // because it was a target's `usize`. Also we are sure that its smaller than
209 // `usize::max_value()` because it is a host's `isize`.
210 let mut bytes = vec![0; count as usize];
214 // `File::read` never returns a value larger than `count`, so this cannot fail.
215 .map(|c| i64::try_from(c).unwrap());
219 // If reading to `bytes` did not fail, we write those bytes to the buffer.
220 this.memory.write_bytes(buf, bytes)?;
224 this.set_last_error_from_io_error(e)?;
229 this.handle_not_found()
235 fd_op: OpTy<'tcx, Tag>,
236 buf_op: OpTy<'tcx, Tag>,
237 count_op: OpTy<'tcx, Tag>,
238 ) -> InterpResult<'tcx, i64> {
239 let this = self.eval_context_mut();
241 this.check_no_isolation("write")?;
243 let fd = this.read_scalar(fd_op)?.to_i32()?;
244 let buf = this.read_scalar(buf_op)?.not_undef()?;
245 let count = this.read_scalar(count_op)?.to_machine_usize(&*this.tcx)?;
247 // Check that the *entire* buffer is actually valid memory.
248 this.memory.check_ptr_access(
250 Size::from_bytes(count),
251 Align::from_bytes(1).unwrap(),
254 // We cap the number of written bytes to the largest value that we are able to fit in both the
255 // host's and target's `isize`. This saves us from having to handle overflows later.
256 let count = count.min(this.isize_max() as u64).min(isize::max_value() as u64);
258 if let Some(handle) = this.machine.file_handler.handles.get_mut(&fd) {
259 let bytes = this.memory.read_bytes(buf, Size::from_bytes(count))?;
260 let result = handle.file.write(&bytes).map(|c| i64::try_from(c).unwrap());
261 this.try_unwrap_io_result(result)
263 this.handle_not_found()
269 fd_op: OpTy<'tcx, Tag>,
270 offset_op: OpTy<'tcx, Tag>,
271 whence_op: OpTy<'tcx, Tag>,
272 ) -> InterpResult<'tcx, i64> {
273 let this = self.eval_context_mut();
275 this.check_no_isolation("lseek64")?;
277 let fd = this.read_scalar(fd_op)?.to_i32()?;
278 let offset = this.read_scalar(offset_op)?.to_i64()?;
279 let whence = this.read_scalar(whence_op)?.to_i32()?;
281 let seek_from = if whence == this.eval_libc_i32("SEEK_SET")? {
282 SeekFrom::Start(offset as u64)
283 } else if whence == this.eval_libc_i32("SEEK_CUR")? {
284 SeekFrom::Current(offset)
285 } else if whence == this.eval_libc_i32("SEEK_END")? {
286 SeekFrom::End(offset)
288 let einval = this.eval_libc("EINVAL")?;
289 this.set_last_error(einval)?;
293 if let Some(handle) = this.machine.file_handler.handles.get_mut(&fd) {
294 let result = handle.file.seek(seek_from).map(|offset| offset as i64);
295 this.try_unwrap_io_result(result)
297 this.handle_not_found()
301 fn unlink(&mut self, path_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
302 let this = self.eval_context_mut();
304 this.check_no_isolation("unlink")?;
306 let path = this.read_os_str_from_c_str(this.read_scalar(path_op)?.not_undef()?)?;
308 let result = remove_file(path).map(|_| 0);
310 this.try_unwrap_io_result(result)
315 target_op: OpTy<'tcx, Tag>,
316 linkpath_op: OpTy<'tcx, Tag>
317 ) -> InterpResult<'tcx, i32> {
318 #[cfg(target_family = "unix")]
319 fn create_link(src: PathBuf, dst: PathBuf) -> std::io::Result<()> {
320 std::os::unix::fs::symlink(src, dst)
323 #[cfg(target_family = "windows")]
324 fn create_link(src: PathBuf, dst: PathBuf) -> std::io::Result<()> {
325 use std::os::windows::fs;
327 fs::symlink_dir(src, dst)
329 fs::symlink_file(src, dst)
333 let this = self.eval_context_mut();
335 this.check_no_isolation("symlink")?;
337 let target = this.read_os_str_from_c_str(this.read_scalar(target_op)?.not_undef()?)?.into();
338 let linkpath = this.read_os_str_from_c_str(this.read_scalar(linkpath_op)?.not_undef()?)?.into();
340 this.try_unwrap_io_result(create_link(target, linkpath).map(|_| 0))
345 path_op: OpTy<'tcx, Tag>,
346 buf_op: OpTy<'tcx, Tag>,
347 ) -> InterpResult<'tcx, i32> {
348 let this = self.eval_context_mut();
349 this.check_no_isolation("stat")?;
350 this.check_platform("macos", "stat")?;
351 // `stat` always follows symlinks.
352 this.macos_stat_or_lstat(true, path_op, buf_op)
355 // `lstat` is used to get symlink metadata.
358 path_op: OpTy<'tcx, Tag>,
359 buf_op: OpTy<'tcx, Tag>,
360 ) -> InterpResult<'tcx, i32> {
361 let this = self.eval_context_mut();
362 this.check_no_isolation("lstat")?;
363 this.check_platform("macos", "lstat")?;
364 this.macos_stat_or_lstat(false, path_op, buf_op)
369 fd_op: OpTy<'tcx, Tag>,
370 buf_op: OpTy<'tcx, Tag>,
371 ) -> InterpResult<'tcx, i32> {
372 let this = self.eval_context_mut();
374 this.check_no_isolation("fstat")?;
375 this.check_platform("macos", "fstat")?;
377 let fd = this.read_scalar(fd_op)?.to_i32()?;
379 let metadata = match FileMetadata::from_fd(this, fd)? {
380 Some(metadata) => metadata,
381 None => return Ok(-1),
383 macos_stat_write_buf(this, metadata, buf_op)
386 /// Emulate `stat` or `lstat` on the `macos` platform. This function is not intended to be
387 /// called directly from `emulate_foreign_item_by_name`, so it does not check if isolation is
388 /// disabled or if the target platform is the correct one. Please use `macos_stat` or
389 /// `macos_lstat` instead.
390 fn macos_stat_or_lstat(
392 follow_symlink: bool,
393 path_op: OpTy<'tcx, Tag>,
394 buf_op: OpTy<'tcx, Tag>,
395 ) -> InterpResult<'tcx, i32> {
396 let this = self.eval_context_mut();
398 let path_scalar = this.read_scalar(path_op)?.not_undef()?;
399 let path: PathBuf = this.read_os_str_from_c_str(path_scalar)?.into();
401 let metadata = match FileMetadata::from_path(this, path, follow_symlink)? {
402 Some(metadata) => metadata,
403 None => return Ok(-1),
405 macos_stat_write_buf(this, metadata, buf_op)
410 dirfd_op: OpTy<'tcx, Tag>, // Should be an `int`
411 pathname_op: OpTy<'tcx, Tag>, // Should be a `const char *`
412 flags_op: OpTy<'tcx, Tag>, // Should be an `int`
413 _mask_op: OpTy<'tcx, Tag>, // Should be an `unsigned int`
414 statxbuf_op: OpTy<'tcx, Tag>, // Should be a `struct statx *`
415 ) -> InterpResult<'tcx, i32> {
416 let this = self.eval_context_mut();
418 this.check_no_isolation("statx")?;
419 this.check_platform("linux", "statx")?;
421 let statxbuf_scalar = this.read_scalar(statxbuf_op)?.not_undef()?;
422 let pathname_scalar = this.read_scalar(pathname_op)?.not_undef()?;
424 // If the statxbuf or pathname pointers are null, the function fails with `EFAULT`.
425 if this.is_null(statxbuf_scalar)? || this.is_null(pathname_scalar)? {
426 let efault = this.eval_libc("EFAULT")?;
427 this.set_last_error(efault)?;
431 // Under normal circumstances, we would use `deref_operand(statxbuf_op)` to produce a
432 // proper `MemPlace` and then write the results of this function to it. However, the
433 // `syscall` function is untyped. This means that all the `statx` parameters are provided
434 // as `isize`s instead of having the proper types. Thus, we have to recover the layout of
435 // `statxbuf_op` by using the `libc::statx` struct type.
436 let statxbuf_place = {
437 // FIXME: This long path is required because `libc::statx` is an struct and also a
438 // function and `resolve_path` is returning the latter.
440 .resolve_path(&["libc", "unix", "linux_like", "linux", "gnu", "statx"])?
441 .monomorphic_ty(*this.tcx);
442 let statxbuf_ty = this.tcx.mk_mut_ptr(statx_ty);
443 let statxbuf_layout = this.layout_of(statxbuf_ty)?;
444 let statxbuf_imm = ImmTy::from_scalar(statxbuf_scalar, statxbuf_layout);
445 this.ref_to_mplace(statxbuf_imm)?
448 let path: PathBuf = this.read_os_str_from_c_str(pathname_scalar)?.into();
449 // `flags` should be a `c_int` but the `syscall` function provides an `isize`.
451 this.read_scalar(flags_op)?.to_machine_isize(&*this.tcx)?.try_into().map_err(|e| {
452 err_unsup_format!("Failed to convert pointer sized operand to integer: {}", e)
454 let empty_path_flag = flags & this.eval_libc("AT_EMPTY_PATH")?.to_i32()? != 0;
455 // `dirfd` should be a `c_int` but the `syscall` function provides an `isize`.
457 this.read_scalar(dirfd_op)?.to_machine_isize(&*this.tcx)?.try_into().map_err(|e| {
458 err_unsup_format!("Failed to convert pointer sized operand to integer: {}", e)
461 // * interpreting `path` as an absolute directory,
462 // * interpreting `path` as a path relative to `dirfd` when the latter is `AT_FDCWD`, or
463 // * interpreting `dirfd` as any file descriptor when `path` is empty and AT_EMPTY_PATH is
465 // Other behaviors cannot be tested from `libstd` and thus are not implemented. If you
466 // found this error, please open an issue reporting it.
468 path.is_absolute() ||
469 dirfd == this.eval_libc_i32("AT_FDCWD")? ||
470 (path.as_os_str().is_empty() && empty_path_flag)
473 "Using statx is only supported with absolute paths, relative paths with the file \
474 descriptor `AT_FDCWD`, and empty paths with the `AT_EMPTY_PATH` flag set and any \
479 // the `_mask_op` paramter specifies the file information that the caller requested.
480 // However `statx` is allowed to return information that was not requested or to not
481 // return information that was requested. This `mask` represents the information we can
482 // actually provide in any host platform.
484 this.eval_libc("STATX_TYPE")?.to_u32()? | this.eval_libc("STATX_SIZE")?.to_u32()?;
486 // If the `AT_SYMLINK_NOFOLLOW` flag is set, we query the file's metadata without following
488 let follow_symlink = flags & this.eval_libc("AT_SYMLINK_NOFOLLOW")?.to_i32()? == 0;
490 // If the path is empty, and the AT_EMPTY_PATH flag is set, we query the open file
491 // represented by dirfd, whether it's a directory or otherwise.
492 let metadata = if path.as_os_str().is_empty() && empty_path_flag {
493 FileMetadata::from_fd(this, dirfd)?
495 FileMetadata::from_path(this, path, follow_symlink)?
497 let metadata = match metadata {
498 Some(metadata) => metadata,
499 None => return Ok(-1),
502 // The `mode` field specifies the type of the file and the permissions over the file for
503 // the owner, its group and other users. Given that we can only provide the file type
504 // without using platform specific methods, we only set the bits corresponding to the file
505 // type. This should be an `__u16` but `libc` provides its values as `u32`.
506 let mode: u16 = metadata
510 .unwrap_or_else(|_| bug!("libc contains bad value for constant"));
512 // We need to set the corresponding bits of `mask` if the access, creation and modification
513 // times were available. Otherwise we let them be zero.
514 let (access_sec, access_nsec) = metadata.accessed.map(|tup| {
515 mask |= this.eval_libc("STATX_ATIME")?.to_u32()?;
516 InterpResult::Ok(tup)
517 }).unwrap_or(Ok((0, 0)))?;
519 let (created_sec, created_nsec) = metadata.created.map(|tup| {
520 mask |= this.eval_libc("STATX_BTIME")?.to_u32()?;
521 InterpResult::Ok(tup)
522 }).unwrap_or(Ok((0, 0)))?;
524 let (modified_sec, modified_nsec) = metadata.modified.map(|tup| {
525 mask |= this.eval_libc("STATX_MTIME")?.to_u32()?;
526 InterpResult::Ok(tup)
527 }).unwrap_or(Ok((0, 0)))?;
529 let __u32_layout = this.libc_ty_layout("__u32")?;
530 let __u64_layout = this.libc_ty_layout("__u64")?;
531 let __u16_layout = this.libc_ty_layout("__u16")?;
533 // Now we transform all this fields into `ImmTy`s and write them to `statxbuf`. We write a
534 // zero for the unavailable fields.
536 immty_from_uint_checked(mask, __u32_layout)?, // stx_mask
537 immty_from_uint_checked(0u128, __u32_layout)?, // stx_blksize
538 immty_from_uint_checked(0u128, __u64_layout)?, // stx_attributes
539 immty_from_uint_checked(0u128, __u32_layout)?, // stx_nlink
540 immty_from_uint_checked(0u128, __u32_layout)?, // stx_uid
541 immty_from_uint_checked(0u128, __u32_layout)?, // stx_gid
542 immty_from_uint_checked(mode, __u16_layout)?, // stx_mode
543 immty_from_uint_checked(0u128, __u16_layout)?, // statx padding
544 immty_from_uint_checked(0u128, __u64_layout)?, // stx_ino
545 immty_from_uint_checked(metadata.size, __u64_layout)?, // stx_size
546 immty_from_uint_checked(0u128, __u64_layout)?, // stx_blocks
547 immty_from_uint_checked(0u128, __u64_layout)?, // stx_attributes
548 immty_from_uint_checked(access_sec, __u64_layout)?, // stx_atime.tv_sec
549 immty_from_uint_checked(access_nsec, __u32_layout)?, // stx_atime.tv_nsec
550 immty_from_uint_checked(0u128, __u32_layout)?, // statx_timestamp padding
551 immty_from_uint_checked(created_sec, __u64_layout)?, // stx_btime.tv_sec
552 immty_from_uint_checked(created_nsec, __u32_layout)?, // stx_btime.tv_nsec
553 immty_from_uint_checked(0u128, __u32_layout)?, // statx_timestamp padding
554 immty_from_uint_checked(0u128, __u64_layout)?, // stx_ctime.tv_sec
555 immty_from_uint_checked(0u128, __u32_layout)?, // stx_ctime.tv_nsec
556 immty_from_uint_checked(0u128, __u32_layout)?, // statx_timestamp padding
557 immty_from_uint_checked(modified_sec, __u64_layout)?, // stx_mtime.tv_sec
558 immty_from_uint_checked(modified_nsec, __u32_layout)?, // stx_mtime.tv_nsec
559 immty_from_uint_checked(0u128, __u32_layout)?, // statx_timestamp padding
560 immty_from_uint_checked(0u128, __u64_layout)?, // stx_rdev_major
561 immty_from_uint_checked(0u128, __u64_layout)?, // stx_rdev_minor
562 immty_from_uint_checked(0u128, __u64_layout)?, // stx_dev_major
563 immty_from_uint_checked(0u128, __u64_layout)?, // stx_dev_minor
566 this.write_packed_immediates(statxbuf_place, &imms)?;
571 /// Function used when a handle is not found inside `FileHandler`. It returns `Ok(-1)`and sets
572 /// the last OS error to `libc::EBADF` (invalid file descriptor). This function uses
573 /// `T: From<i32>` instead of `i32` directly because some fs functions return different integer
574 /// types (like `read`, that returns an `i64`).
575 fn handle_not_found<T: From<i32>>(&mut self) -> InterpResult<'tcx, T> {
576 let this = self.eval_context_mut();
577 let ebadf = this.eval_libc("EBADF")?;
578 this.set_last_error(ebadf)?;
584 oldpath_op: OpTy<'tcx, Tag>,
585 newpath_op: OpTy<'tcx, Tag>,
586 ) -> InterpResult<'tcx, i32> {
587 let this = self.eval_context_mut();
589 this.check_no_isolation("rename")?;
591 let oldpath_scalar = this.read_scalar(oldpath_op)?.not_undef()?;
592 let newpath_scalar = this.read_scalar(newpath_op)?.not_undef()?;
594 if this.is_null(oldpath_scalar)? || this.is_null(newpath_scalar)? {
595 let efault = this.eval_libc("EFAULT")?;
596 this.set_last_error(efault)?;
600 let oldpath = this.read_os_str_from_c_str(oldpath_scalar)?;
601 let newpath = this.read_os_str_from_c_str(newpath_scalar)?;
603 let result = rename(oldpath, newpath).map(|_| 0);
605 this.try_unwrap_io_result(result)
609 /// Extracts the number of seconds and nanoseconds elapsed between `time` and the unix epoch when
610 /// `time` is Ok. Returns `None` if `time` is an error. Fails if `time` happens before the unix
612 fn extract_sec_and_nsec<'tcx>(
613 time: std::io::Result<SystemTime>
614 ) -> InterpResult<'tcx, Option<(u64, u32)>> {
615 time.ok().map(|time| {
616 let duration = system_time_to_duration(&time)?;
617 Ok((duration.as_secs(), duration.subsec_nanos()))
621 /// Stores a file's metadata in order to avoid code duplication in the different metadata related
623 struct FileMetadata {
626 created: Option<(u64, u32)>,
627 accessed: Option<(u64, u32)>,
628 modified: Option<(u64, u32)>,
632 fn from_path<'tcx, 'mir>(
633 ecx: &mut MiriEvalContext<'mir, 'tcx>,
636 ) -> InterpResult<'tcx, Option<FileMetadata>> {
637 let metadata = if follow_symlink {
638 std::fs::metadata(path)
640 std::fs::symlink_metadata(path)
643 FileMetadata::from_meta(ecx, metadata)
646 fn from_fd<'tcx, 'mir>(
647 ecx: &mut MiriEvalContext<'mir, 'tcx>,
649 ) -> InterpResult<'tcx, Option<FileMetadata>> {
650 let option = ecx.machine.file_handler.handles.get(&fd);
651 let handle = match option {
652 Some(handle) => handle,
653 None => return ecx.handle_not_found().map(|_: i32| None),
655 let metadata = handle.file.metadata();
657 FileMetadata::from_meta(ecx, metadata)
660 fn from_meta<'tcx, 'mir>(
661 ecx: &mut MiriEvalContext<'mir, 'tcx>,
662 metadata: Result<std::fs::Metadata, std::io::Error>,
663 ) -> InterpResult<'tcx, Option<FileMetadata>> {
664 let metadata = match metadata {
665 Ok(metadata) => metadata,
667 ecx.set_last_error_from_io_error(e)?;
672 let file_type = metadata.file_type();
674 let mode_name = if file_type.is_file() {
676 } else if file_type.is_dir() {
682 let mode = ecx.eval_libc(mode_name)?;
684 let size = metadata.len();
686 let created = extract_sec_and_nsec(metadata.created())?;
687 let accessed = extract_sec_and_nsec(metadata.accessed())?;
688 let modified = extract_sec_and_nsec(metadata.modified())?;
690 // FIXME: Provide more fields using platform specific methods.
691 Ok(Some(FileMetadata { mode, size, created, accessed, modified }))
695 fn macos_stat_write_buf<'tcx, 'mir>(
696 ecx: &mut MiriEvalContext<'mir, 'tcx>,
697 metadata: FileMetadata,
698 buf_op: OpTy<'tcx, Tag>,
699 ) -> InterpResult<'tcx, i32> {
700 let mode: u16 = metadata.mode.to_u16()?;
702 let (access_sec, access_nsec) = metadata.accessed.unwrap_or((0, 0));
703 let (created_sec, created_nsec) = metadata.created.unwrap_or((0, 0));
704 let (modified_sec, modified_nsec) = metadata.modified.unwrap_or((0, 0));
706 let dev_t_layout = ecx.libc_ty_layout("dev_t")?;
707 let mode_t_layout = ecx.libc_ty_layout("mode_t")?;
708 let nlink_t_layout = ecx.libc_ty_layout("nlink_t")?;
709 let ino_t_layout = ecx.libc_ty_layout("ino_t")?;
710 let uid_t_layout = ecx.libc_ty_layout("uid_t")?;
711 let gid_t_layout = ecx.libc_ty_layout("gid_t")?;
712 let time_t_layout = ecx.libc_ty_layout("time_t")?;
713 let long_layout = ecx.libc_ty_layout("c_long")?;
714 let off_t_layout = ecx.libc_ty_layout("off_t")?;
715 let blkcnt_t_layout = ecx.libc_ty_layout("blkcnt_t")?;
716 let blksize_t_layout = ecx.libc_ty_layout("blksize_t")?;
717 let uint32_t_layout = ecx.libc_ty_layout("uint32_t")?;
719 // We need to add 32 bits of padding after `st_rdev` if we are on a 64-bit platform.
720 let pad_layout = if ecx.tcx.sess.target.ptr_width == 64 {
723 ecx.layout_of(ecx.tcx.mk_unit())?
727 immty_from_uint_checked(0u128, dev_t_layout)?, // st_dev
728 immty_from_uint_checked(mode, mode_t_layout)?, // st_mode
729 immty_from_uint_checked(0u128, nlink_t_layout)?, // st_nlink
730 immty_from_uint_checked(0u128, ino_t_layout)?, // st_ino
731 immty_from_uint_checked(0u128, uid_t_layout)?, // st_uid
732 immty_from_uint_checked(0u128, gid_t_layout)?, // st_gid
733 immty_from_uint_checked(0u128, dev_t_layout)?, // st_rdev
734 immty_from_uint_checked(0u128, pad_layout)?, // padding for 64-bit targets
735 immty_from_uint_checked(access_sec, time_t_layout)?, // st_atime
736 immty_from_uint_checked(access_nsec, long_layout)?, // st_atime_nsec
737 immty_from_uint_checked(modified_sec, time_t_layout)?, // st_mtime
738 immty_from_uint_checked(modified_nsec, long_layout)?, // st_mtime_nsec
739 immty_from_uint_checked(0u128, time_t_layout)?, // st_ctime
740 immty_from_uint_checked(0u128, long_layout)?, // st_ctime_nsec
741 immty_from_uint_checked(created_sec, time_t_layout)?, // st_birthtime
742 immty_from_uint_checked(created_nsec, long_layout)?, // st_birthtime_nsec
743 immty_from_uint_checked(metadata.size, off_t_layout)?, // st_size
744 immty_from_uint_checked(0u128, blkcnt_t_layout)?, // st_blocks
745 immty_from_uint_checked(0u128, blksize_t_layout)?, // st_blksize
746 immty_from_uint_checked(0u128, uint32_t_layout)?, // st_flags
747 immty_from_uint_checked(0u128, uint32_t_layout)?, // st_gen
750 let buf = ecx.deref_operand(buf_op)?;
751 ecx.write_packed_immediates(buf, &imms)?;