Implement std::fs::File::set_times

Ayush1325 · Ayush1325 · commit d610cde3ec8a · 2022-12-01T11:39:10.000+05:30
Signed-off-by: Ayush &lt;ayushsingh1325@gmail.com&gt;
diff --git a/library/std/src/sys/uefi/fs.rs b/library/std/src/sys/uefi/fs.rs
@@ -5,7 +5,7 @@ use crate::fmt;
 use crate::hash::Hash;
 use crate::io::{self, IoSlice, IoSliceMut, ReadBuf, SeekFrom};
 use crate::path::{Path, PathBuf};
-use crate::sys::time::{SystemTime, UNIX_EPOCH};
+use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 use r_efi::protocols::file;
 
@@ -20,7 +20,8 @@ pub struct FileAttr {
     perm: FilePermissions,
     file_type: FileType,
     created_time: SystemTime,
-    file_times: FileTimes,
+    last_accessed_time: SystemTime,
+    modification_time: SystemTime,
 }
 
 pub struct ReadDir {
@@ -55,8 +56,8 @@ pub struct FileType {
 
 #[derive(Copy, Clone, Debug)]
 pub struct FileTimes {
-    last_accessed_time: SystemTime,
-    modification_time: SystemTime,
+    last_accessed_time: Option<SystemTime>,
+    modification_time: Option<SystemTime>,
 }
 
 #[derive(Debug)]
@@ -83,12 +84,12 @@ impl FileAttr {
 
     #[inline]
     pub fn modified(&self) -> io::Result<SystemTime> {
-        Ok(self.file_times.modification_time)
+        Ok(self.modification_time)
     }
 
     #[inline]
     pub fn accessed(&self) -> io::Result<SystemTime> {
-        Ok(self.file_times.last_accessed_time)
+        Ok(self.last_accessed_time)
     }
 
     #[inline]
@@ -103,11 +104,9 @@ impl From<&file::Info> for FileAttr {
             size: info.file_size,
             perm: FilePermissions { attr: info.attribute },
             file_type: FileType { attr: info.attribute },
-            file_times: FileTimes {
-                last_accessed_time: SystemTime::from(info.last_access_time),
-                modification_time: SystemTime::from(info.modification_time),
-            },
             created_time: SystemTime::from(info.create_time),
+            last_accessed_time: SystemTime::from(info.last_access_time),
+            modification_time: SystemTime::from(info.modification_time),
         }
     }
 }
@@ -177,19 +176,19 @@ impl Iterator for ReadDir {
 impl FileTimes {
     #[inline]
     pub fn set_accessed(&mut self, t: SystemTime) {
-        self.last_accessed_time = t;
+        self.last_accessed_time = Some(t);
     }
 
     #[inline]
     pub fn set_modified(&mut self, t: SystemTime) {
-        self.modification_time = t;
+        self.modification_time = Some(t);
     }
 }
 
 impl Default for FileTimes {
     #[inline]
     fn default() -> Self {
-        Self { last_accessed_time: UNIX_EPOCH, modification_time: UNIX_EPOCH }
+        Self { last_accessed_time: None, modification_time: None }
     }
 }
 
@@ -382,8 +381,9 @@ impl File {
         self.ptr.set_file_attr(perm.attr)
     }
 
-    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
-        unsupported()
+    #[inline]
+    pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
+        self.ptr.set_file_times(times)
     }
 }
 
@@ -548,6 +548,7 @@ fn cascade_delete(file: uefi_fs::FileProtocol, path: &Path) -> io::Result<()> {
 }
 
 mod uefi_fs {
+    use super::FileTimes;
     use super::{DirEntry, FileAttr};
     use crate::default::Default;
     use crate::ffi::OsStr;
@@ -891,6 +892,34 @@ mod uefi_fs {
             }
         }
 
+        pub fn set_file_times(&self, file_times: FileTimes) -> io::Result<()> {
+            let mut old_info = self.get_file_info()?;
+
+            if let Some(t) = file_times.last_accessed_time {
+                old_info.last_access_time = super::super::time::uefi_time_from_duration(
+                    t.get_duration(),
+                    old_info.last_access_time.daylight,
+                    old_info.last_access_time.timezone,
+                );
+            }
+            if let Some(t) = file_times.modification_time {
+                old_info.modification_time = super::super::time::uefi_time_from_duration(
+                    t.get_duration(),
+                    old_info.modification_time.daylight,
+                    old_info.modification_time.timezone,
+                );
+            }
+
+            unsafe {
+                Self::set_info_raw(
+                    self.inner.as_ptr(),
+                    file::INFO_ID,
+                    old_info.layout().size(),
+                    old_info.as_mut() as *mut _ as *mut crate::ffi::c_void,
+                )
+            }
+        }
+
         // Delete a file.
         pub fn delete(self) -> io::Result<()> {
             // Deleting the file makes the pointer invalid. Thus calling drop on it later will
@@ -899,6 +928,7 @@ mod uefi_fs {
             unsafe { Self::delete_raw(file.inner.as_ptr()) }
         }
 
+        #[inline]
         unsafe fn open_raw(
             rootfs: *mut file::Protocol,
             file_opened: *mut *mut file::Protocol,
@@ -910,21 +940,25 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn set_position_raw(protocol: *mut file::Protocol, pos: u64) -> io::Result<()> {
             let r = unsafe { ((*protocol).set_position)(protocol, pos) };
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn get_position_raw(protocol: *mut file::Protocol, pos: *mut u64) -> io::Result<()> {
             let r = unsafe { ((*protocol).get_position)(protocol, pos) };
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn flush_raw(protocol: *mut file::Protocol) -> io::Result<()> {
             let r = unsafe { ((*protocol).flush)(protocol) };
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn write_raw(
             protocol: *mut file::Protocol,
             buf_size: *mut usize,
@@ -939,6 +973,7 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn read_raw(
             protocol: *mut file::Protocol,
             buf_size: *mut usize,
@@ -948,6 +983,7 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn get_info_raw(
             protocol: *mut file::Protocol,
             mut info_guid: r_efi::efi::Guid,
@@ -958,6 +994,7 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn set_info_raw(
             protocol: *mut file::Protocol,
             mut info_guid: r_efi::efi::Guid,
@@ -968,13 +1005,15 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        #[inline]
         unsafe fn delete_raw(protocol: *mut file::Protocol) -> io::Result<()> {
             let r = unsafe { ((*protocol).delete)(protocol) };
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
     }
 
     impl Drop for FileProtocol {
+        #[inline]
         fn drop(&mut self) {
             let protocol = self.inner.as_ptr();
             // Always returns EFI_SUCCESS
diff --git a/library/std/src/sys/uefi/time.rs b/library/std/src/sys/uefi/time.rs
@@ -14,7 +14,12 @@ pub struct Instant(Duration);
 pub struct SystemTime(Duration);
 
 pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::ZERO);
+
 const NS_PER_SEC: u64 = 1_000_000_000;
+const SEC_IN_MIN: u64 = 60;
+const SEC_IN_HOUR: u64 = SEC_IN_MIN * 60;
+const SEC_IN_DAY: u64 = SEC_IN_HOUR * 24;
+const SEC_IN_YEAR: u64 = SEC_IN_DAY * 365;
 
 impl Instant {
     pub fn now() -> Instant {
@@ -112,6 +117,10 @@ impl SystemTime {
     pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
+
+    pub(crate) fn get_duration(&self) -> Duration {
+        self.0
+    }
 }
 
 impl From<r_efi::system::Time> for SystemTime {
@@ -123,10 +132,6 @@ impl From<r_efi::system::Time> for SystemTime {
 
 // FIXME: Don't know how to use Daylight Saving thing
 fn uefi_time_to_duration(t: r_efi::system::Time) -> Duration {
-    const SEC_IN_MIN: u64 = 60;
-    const SEC_IN_HOUR: u64 = SEC_IN_MIN * 60;
-    const SEC_IN_DAY: u64 = SEC_IN_HOUR * 24;
-    const SEC_IN_YEAR: u64 = SEC_IN_DAY * 365;
     const MONTH_DAYS: [u64; 12] = [0, 31, 59, 90, 120, 151, 181, 211, 242, 272, 303, 333];
 
     let localtime_epoch: u64 = u64::from(t.year - 1970) * SEC_IN_YEAR
@@ -142,6 +147,42 @@ fn uefi_time_to_duration(t: r_efi::system::Time) -> Duration {
     Duration::new(utc_epoch, t.nanosecond)
 }
 
+// This algorithm is taken from: http://howardhinnant.github.io/date_algorithms.html
+pub fn uefi_time_from_duration(dur: Duration, daylight: u8, timezone: i16) -> r_efi::system::Time {
+    let secs = dur.as_secs();
+
+    let days = secs / SEC_IN_DAY;
+    let remaining_secs = secs % SEC_IN_DAY;
+
+    let z = days + 719468;
+    let era = z / 146097;
+    let doe = z - (era * 146097);
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let mut y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+
+    if m <= 2 {
+        y += 1;
+    }
+
+    r_efi::system::Time {
+        year: y as u16,
+        month: m as u8,
+        day: d as u8,
+        hour: (remaining_secs / SEC_IN_HOUR) as u8,
+        minute: ((remaining_secs % SEC_IN_HOUR) / SEC_IN_MIN) as u8,
+        second: ((remaining_secs % SEC_IN_HOUR) % SEC_IN_MIN) as u8,
+        pad1: 0,
+        nanosecond: dur.subsec_nanos(),
+        timezone,
+        daylight,
+        pad2: 0,
+    }
+}
+
 // Returns the Frequency in Mhz
 // Mostly based on [`edk2/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c`](https://github.com/tianocore/edk2/blob/master/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c)
 // Currently implemented only for x86_64 but can be extended for other arch if they ever support
