dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #98246 - joshtriplett:times, r=m-ou-se 

Support setting file accessed/modified timestamps

Add `struct FileTimes` to contain the relevant file timestamps, since
most platforms require setting all of them at once. (This also allows
for future platform-specific extensions such as setting creation time.)

Add `File::set_file_time` to set the timestamps for a `File`.

Implement the `sys` backends for UNIX, macOS (which needs to fall back
to `futimes` before macOS 10.13 because it lacks `futimens`), Windows,
and WASI.
This commit is contained in:
bors 2022-08-01 06:44:43 +00:00
parent 25bb1c13bd f8061ddb03
commit 1f5d8d49eb
9 changed files with 262 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
library/std/src/fs.rs
View File

@ -184,6 +184,11 @@ pub struct DirEntry(fs_imp::DirEntry);
#[stable(feature = "rust1", since = "1.0.0")]
pub struct OpenOptions(fs_imp::OpenOptions);
/// Representation of the various timestamps on a file.
#[derive(Copy, Clone, Debug, Default)]
#[unstable(feature = "file_set_times", issue = "98245")]
pub struct FileTimes(fs_imp::FileTimes);
/// Representation of the various permissions on a file.
///
/// This module only currently provides one bit of information,
@ -596,6 +601,58 @@ impl File {
pub fn set_permissions(&self, perm: Permissions) -> io::Result<()> {
self.inner.set_permissions(perm.0)
}
/// Changes the timestamps of the underlying file.
///
/// # Platform-specific behavior
///
/// This function currently corresponds to the `futimens` function on Unix (falling back to
/// `futimes` on macOS before 10.13) and the `SetFileTime` function on Windows. Note that this
/// [may change in the future][changes].
///
/// [changes]: io#platform-specific-behavior
///
/// # Errors
///
/// This function will return an error if the user lacks permission to change timestamps on the
/// underlying file. It may also return an error in other os-specific unspecified cases.
///
/// This function may return an error if the operating system lacks support to change one or
/// more of the timestamps set in the `FileTimes` structure.
///
/// # Examples
///
/// ```no_run
/// #![feature(file_set_times)]
///
/// fn main() -> std::io::Result<()> {
/// use std::fs::{self, File, FileTimes};
///
/// let src = fs::metadata("src")?;
/// let dest = File::options().write(true).open("dest")?;
/// let times = FileTimes::new()
/// .set_accessed(src.accessed()?)
/// .set_modified(src.modified()?);
/// dest.set_times(times)?;
/// Ok(())
/// }
/// ```
#[unstable(feature = "file_set_times", issue = "98245")]
#[doc(alias = "futimens")]
#[doc(alias = "futimes")]
#[doc(alias = "SetFileTime")]
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
self.inner.set_times(times.0)
}
/// Changes the modification time of the underlying file.
///
/// This is an alias for `set_times(FileTimes::new().set_modified(time))`.
#[unstable(feature = "file_set_times", issue = "98245")]
#[inline]
pub fn set_modified(&self, time: SystemTime) -> io::Result<()> {
self.set_times(FileTimes::new().set_modified(time))
}
}
// In addition to the `impl`s here, `File` also has `impl`s for
@ -1252,6 +1309,30 @@ impl FromInner<fs_imp::FileAttr> for Metadata {
}
}
impl FileTimes {
/// Create a new `FileTimes` with no times set.
///
/// Using the resulting `FileTimes` in [`File::set_times`] will not modify any timestamps.
#[unstable(feature = "file_set_times", issue = "98245")]
pub fn new() -> Self {
Self::default()
}
/// Set the last access time of a file.
#[unstable(feature = "file_set_times", issue = "98245")]
pub fn set_accessed(mut self, t: SystemTime) -> Self {
self.0.set_accessed(t.into_inner());
self
}
/// Set the last modified time of a file.
#[unstable(feature = "file_set_times", issue = "98245")]
pub fn set_modified(mut self, t: SystemTime) -> Self {
self.0.set_modified(t.into_inner());
self
}
}
impl Permissions {
/// Returns `true` if these permissions describe a readonly (unwritable) file.
///

89
library/std/src/sys/unix/fs.rs
View File

@ -20,7 +20,7 @@ use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
target_os = "watchos",
))]
use crate::sys::weak::syscall;
#[cfg(target_os = "macos")]
#[cfg(any(target_os = "android", target_os = "macos"))]
use crate::sys::weak::weak;
use libc::{c_int, mode_t};
@ -313,6 +313,9 @@ pub struct FilePermissions {
mode: mode_t,
}
#[derive(Copy, Clone)]
pub struct FileTimes([libc::timespec; 2]);
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub struct FileType {
mode: mode_t,
@ -507,6 +510,48 @@ impl FilePermissions {
}
}
impl FileTimes {
pub fn set_accessed(&mut self, t: SystemTime) {
self.0[0] = t.t.to_timespec().expect("Invalid system time");
}
pub fn set_modified(&mut self, t: SystemTime) {
self.0[1] = t.t.to_timespec().expect("Invalid system time");
}
}
struct TimespecDebugAdapter<'a>(&'a libc::timespec);
impl fmt::Debug for TimespecDebugAdapter<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("timespec")
.field("tv_sec", &self.0.tv_sec)
.field("tv_nsec", &self.0.tv_nsec)
.finish()
}
}
impl fmt::Debug for FileTimes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("FileTimes")
.field("accessed", &TimespecDebugAdapter(&self.0[0]))
.field("modified", &TimespecDebugAdapter(&self.0[1]))
.finish()
}
}
impl Default for FileTimes {
fn default() -> Self {
// Redox doesn't appear to support `UTIME_OMIT`, so we stub it out here, and always return
// an error in `set_times`.
#[cfg(target_os = "redox")]
let omit = libc::timespec { tv_sec: 0, tv_nsec: 0 };
#[cfg(not(target_os = "redox"))]
let omit = libc::timespec { tv_sec: 0, tv_nsec: libc::UTIME_OMIT as _ };
Self([omit; 2])
}
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.is(libc::S_IFDIR)
@ -1029,6 +1074,48 @@ impl File {
cvt_r(|| unsafe { libc::fchmod(self.as_raw_fd(), perm.mode) })?;
Ok(())
}
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
cfg_if::cfg_if! {
if #[cfg(target_os = "redox")] {
// Redox doesn't appear to support `UTIME_OMIT`.
drop(times);
Err(io::const_io_error!(
io::ErrorKind::Unsupported,
"setting file times not supported",
))
} else if #[cfg(any(target_os = "android", target_os = "macos"))] {
// futimens requires macOS 10.13, and Android API level 19
cvt(unsafe {
weak!(fn futimens(c_int, *const libc::timespec) -> c_int);
match futimens.get() {
Some(futimens) => futimens(self.as_raw_fd(), times.0.as_ptr()),
#[cfg(target_os = "macos")]
None => {
fn ts_to_tv(ts: &libc::timespec) -> libc::timeval {
libc::timeval {
tv_sec: ts.tv_sec,
tv_usec: (ts.tv_nsec / 1000) as _
}
}
let timevals = [ts_to_tv(&times.0[0]), ts_to_tv(&times.0[1])];
libc::futimes(self.as_raw_fd(), timevals.as_ptr())
}
// futimes requires even newer Android.
#[cfg(target_os = "android")]
None => return Err(io::const_io_error!(
io::ErrorKind::Unsupported,
"setting file times requires Android API level >= 19",
)),
}
})?;
Ok(())
} else {
cvt(unsafe { libc::futimens(self.as_raw_fd(), times.0.as_ptr()) })?;
Ok(())
}
}
}
}
impl DirBuilder {

12
library/std/src/sys/unsupported/fs.rs
View File

@ -17,6 +17,9 @@ pub struct DirEntry(!);
#[derive(Clone, Debug)]
pub struct OpenOptions {}
#[derive(Copy, Clone, Debug, Default)]
pub struct FileTimes {}
pub struct FilePermissions(!);
pub struct FileType(!);
@ -86,6 +89,11 @@ impl fmt::Debug for FilePermissions {
}
}
impl FileTimes {
pub fn set_accessed(&mut self, _t: SystemTime) {}
pub fn set_modified(&mut self, _t: SystemTime) {}
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.0
@ -237,6 +245,10 @@ impl File {
pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
self.0
}
pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
self.0
}
}
impl DirBuilder {

25
library/std/src/sys/wasi/fs.rs
View File

@ -63,6 +63,12 @@ pub struct FilePermissions {
readonly: bool,
}
#[derive(Copy, Clone, Debug, Default)]
pub struct FileTimes {
accessed: Option<wasi::Timestamp>,
modified: Option<wasi::Timestamp>,
}
#[derive(PartialEq, Eq, Hash, Debug, Copy, Clone)]
pub struct FileType {
bits: wasi::Filetype,
@ -112,6 +118,16 @@ impl FilePermissions {
}
}
impl FileTimes {
pub fn set_accessed(&mut self, t: SystemTime) {
self.accessed = Some(t.to_wasi_timestamp_or_panic());
}
pub fn set_modified(&mut self, t: SystemTime) {
self.modified = Some(t.to_wasi_timestamp_or_panic());
}
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.bits == wasi::FILETYPE_DIRECTORY
@ -459,6 +475,15 @@ impl File {
unsupported()
}
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
self.fd.filestat_set_times(
times.accessed.unwrap_or(0),
times.modified.unwrap_or(0),
times.accessed.map_or(0, |_| wasi::FSTFLAGS_ATIM)
| times.modified.map_or(0, |_| wasi::FSTFLAGS_MTIM),
)
}
pub fn read_link(&self, file: &Path) -> io::Result<PathBuf> {
read_link(&self.fd, file)
}

4
library/std/src/sys/wasi/time.rs
View File

@ -47,6 +47,10 @@ impl SystemTime {
SystemTime(Duration::from_nanos(ts))
}
pub fn to_wasi_timestamp_or_panic(&self) -> wasi::Timestamp {
self.0.as_nanos().try_into().expect("time does not fit in WASI timestamp")
}
pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
}

8
library/std/src/sys/windows/c.rs
View File

@ -620,7 +620,7 @@ pub struct SOCKADDR {
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Debug, Default)]
pub struct FILETIME {
pub dwLowDateTime: DWORD,
pub dwHighDateTime: DWORD,
@ -888,6 +888,12 @@ extern "system" {
pub fn GetSystemDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
pub fn SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: DWORD) -> BOOL;
pub fn SetFileTime(
hFile: BorrowedHandle<'_>,
lpCreationTime: Option<&FILETIME>,
lpLastAccessTime: Option<&FILETIME>,
lpLastWriteTime: Option<&FILETIME>,
) -> BOOL;
pub fn SetLastError(dwErrCode: DWORD);
pub fn GetCommandLineW() -> LPWSTR;
pub fn GetTempPathW(nBufferLength: DWORD, lpBuffer: LPCWSTR) -> DWORD;

31
library/std/src/sys/windows/fs.rs
View File

@ -83,6 +83,12 @@ pub struct FilePermissions {
attrs: c::DWORD,
}
#[derive(Copy, Clone, Debug, Default)]
pub struct FileTimes {
accessed: Option<c::FILETIME>,
modified: Option<c::FILETIME>,
}
#[derive(Debug)]
pub struct DirBuilder;
@ -536,6 +542,21 @@ impl File {
})?;
Ok(())
}
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
let is_zero = |t: c::FILETIME| t.dwLowDateTime == 0 && t.dwHighDateTime == 0;
if times.accessed.map_or(false, is_zero) || times.modified.map_or(false, is_zero) {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"Cannot set file timestamp to 0",
));
}
cvt(unsafe {
c::SetFileTime(self.as_handle(), None, times.accessed.as_ref(), times.modified.as_ref())
})?;
Ok(())
}
/// Get only basic file information such as attributes and file times.
fn basic_info(&self) -> io::Result<c::FILE_BASIC_INFO> {
unsafe {
@ -903,6 +924,16 @@ impl FilePermissions {
}
}
impl FileTimes {
pub fn set_accessed(&mut self, t: SystemTime) {
self.accessed = Some(t.into_inner());
}
pub fn set_modified(&mut self, t: SystemTime) {
self.modified = Some(t.into_inner());
}
}
impl FileType {
fn new(attrs: c::DWORD, reparse_tag: c::DWORD) -> FileType {
FileType { attributes: attrs, reparse_tag }

7
library/std/src/sys/windows/time.rs
View File

@ -2,6 +2,7 @@ use crate::cmp::Ordering;
use crate::fmt;
use crate::mem;
use crate::sys::c;
use crate::sys_common::IntoInner;
use crate::time::Duration;
use core::hash::{Hash, Hasher};
@ -136,6 +137,12 @@ impl From<c::FILETIME> for SystemTime {
}
}
impl IntoInner<c::FILETIME> for SystemTime {
fn into_inner(self) -> c::FILETIME {
self.t
}
}
impl Hash for SystemTime {
fn hash<H: Hasher>(&self, state: &mut H) {
self.intervals().hash(state)

8
library/std/src/time.rs
View File

@ -38,7 +38,7 @@ use crate::error::Error;
use crate::fmt;
use crate::ops::{Add, AddAssign, Sub, SubAssign};
use crate::sys::time;
use crate::sys_common::FromInner;
use crate::sys_common::{FromInner, IntoInner};
#[stable(feature = "time", since = "1.3.0")]
pub use core::time::Duration;
@ -686,3 +686,9 @@ impl FromInner<time::SystemTime> for SystemTime {
SystemTime(time)
}
}
impl IntoInner<time::SystemTime> for SystemTime {
fn into_inner(self) -> time::SystemTime {
self.0
}
}