Fix clippy warnings

safekeeper/src/timeline.rs

@@ -167,7 +167,7 @@ impl<'a> Drop for WriteGuardSharedState<'a> {
 
 pub enum StateSK {
     Loaded(SafeKeeper<control_file::FileStorage, wal_storage::PhysicalStorage>),
-    Offloaded(TimelineState<control_file::FileStorage>),
+    Offloaded(Box<TimelineState<control_file::FileStorage>>),
     Empty,
 }
 
@@ -271,7 +271,7 @@ impl StateSK {
     fn take_state(self) -> TimelineState<control_file::FileStorage> {
         match self {
             StateSK::Loaded(sk) => sk.state,
-            StateSK::Offloaded(state) => state,
+            StateSK::Offloaded(state) => *state,
             StateSK::Empty => unreachable!(),
         }
     }
@@ -345,7 +345,9 @@ impl SharedState {
                     conf.my_id,
                 )?)
             }
-            EvictionState::Offloaded(_) => StateSK::Offloaded(TimelineState::new(control_store)),
+            EvictionState::Offloaded(_) => {
+                StateSK::Offloaded(Box::new(TimelineState::new(control_store)))
+            }
         };
 
         Ok(Self {
@@ -1031,7 +1033,7 @@ impl ManagerTimeline {
         // now we can switch shared.sk to Offloaded, shouldn't fail
         let prev_sk = std::mem::replace(&mut shared.sk, StateSK::Empty);
         let cfile_state = prev_sk.take_state();
-        shared.sk = StateSK::Offloaded(cfile_state);
+        shared.sk = StateSK::Offloaded(Box::new(cfile_state));
 
         Ok(())
     }

safekeeper/src/timeline_manager.rs

@@ -608,6 +608,11 @@ impl AtomicStatus {
     }
 
     pub fn load(&self, order: std::sync::atomic::Ordering) -> Status {
+        // Safety: This line of code uses `std::mem::transmute` to reinterpret the loaded value as `Status`.
+        // It is safe to use `transmute` in this context because `Status` is a repr(usize) enum,
+        // which means it has the same memory layout as usize.
+        // However, it is important to ensure that the loaded value is a valid variant of `Status`,
+        // otherwise, the behavior will be undefined.
         unsafe { std::mem::transmute(self.inner.load(order)) }
     }