Include /var/adm/messages in archived zone logs

System messages on illumos are logged to `/var/adm/messages`. In the
event of a hardware or kernel issue, an archive of these logs can be
for understanding the nature of the failure.

Currently we archive all Oxide service logs from the global zone and any
zones we create, but not `/var/adm/messages`. Update the archiver to
include the latter as well.

Author: wfchandler

sled-agent/config-reconciler/src/dump_setup.rs

@@ -1101,15 +1101,22 @@ impl DumpSetupWorker {
         let oxz_zones = self.zone_invoker.get_zones().await?;
         for zone in oxz_zones {
             let logdir = if zone.global() {
-                PathBuf::from("/var/svc/log")
+                zone.path.join("var/svc/log")
             } else {
                 zone.path().join("root/var/svc/log")
             };
             let zone_name = zone.name();
             self.archive_logs_from_zone_path(
-                debug_dir, logdir, zone_name, false,
+                debug_dir, logdir, "*.log", zone_name, false,
             )
             .await?;
+            if zone.global() {
+                let adm_logdir = zone.path.join("var/adm");
+                self.archive_logs_from_zone_path(
+                    debug_dir, adm_logdir, "messages", zone_name, false,
+                )
+                .await?;
+            }
         }
         Ok(())
     }
@@ -1129,6 +1136,7 @@ impl DumpSetupWorker {
             .archive_logs_from_zone_path(
                 debug_dir,
                 logdir.into(),
+                "*.log",
                 zone_name,
                 true,
             )
@@ -1149,13 +1157,14 @@ impl DumpSetupWorker {
         &self,
         debug_dir: &DebugDataset,
         logdir: PathBuf,
+        log_name_pattern: &str,
         zone_name: &str,
         include_live: bool,
     ) -> Result<(), ArchiveLogsError> {
         let mut rotated_log_files = Vec::new();
         if include_live {
             let pattern = logdir
-                .join("*.log*")
+                .join(format!("{log_name_pattern}*"))
                 .to_str()
                 .ok_or_else(|| ArchiveLogsError::Utf8(zone_name.to_string()))?
                 .to_string();
@@ -1166,7 +1175,7 @@ impl DumpSetupWorker {
             // any
             for n in 1..9 {
                 let pattern = logdir
-                    .join(format!("*.log.{}", "[0-9]".repeat(n)))
+                    .join(format!("{log_name_pattern}.{}", "[0-9]".repeat(n)))
                     .to_str()
                     .ok_or_else(|| {
                         ArchiveLogsError::Utf8(zone_name.to_string())
@@ -1794,8 +1803,13 @@ mod tests {
         let core_dir = tempdir.path().join(CRASH_DATASET);
         let debug_dir = tempdir.path().join(DUMP_DATASET);
         let zone_logs = tempdir.path().join("root/var/svc/log");
+        let adm_logs = tempdir.path().join("var/adm");
 
         let tempdir_path = tempdir.path().as_str().to_string();
+        let global_zone = Zone::from_str(&format!(
+            "0:global:running:{tempdir_path}::ipkg:shared"
+        ))
+        .unwrap();
         let zone = Zone::from_str(&format!(
             "1:myzone:running:{tempdir_path}::ipkg:shared"
         ))
@@ -1831,14 +1845,15 @@ mod tests {
                 .into_iter()
                 .collect(),
             }),
-            Box::new(FakeZone { zones: vec![zone.clone()] }),
+            Box::new(FakeZone { zones: vec![global_zone, zone.clone()] }),
             logctx.log.clone(),
             tokio::sync::mpsc::channel(1).1,
         );
 
         tokio::fs::create_dir_all(&core_dir).await.unwrap();
         tokio::fs::create_dir_all(&debug_dir).await.unwrap();
         tokio::fs::create_dir_all(&zone_logs).await.unwrap();
+        tokio::fs::create_dir_all(&adm_logs).await.unwrap();
         const LOG_NAME: &'static str = "foo.log.0";
         tokio::fs::File::create(zone_logs.join(LOG_NAME))
             .await
@@ -1847,6 +1862,14 @@ mod tests {
             .await
             .expect("writing fake log");
 
+        const ADM_LOG_NAME: &'static str = "messages.0";
+        tokio::fs::File::create(adm_logs.join(ADM_LOG_NAME))
+            .await
+            .expect("creating fake adm log")
+            .write_all(b"admin stuff")
+            .await
+            .expect("writing fake adm log");
+
         const CORE_NAME: &str = "core.myzone.myexe.123.1690540950";
         tokio::fs::File::create(core_dir.join(CORE_NAME))
             .await
@@ -1878,6 +1901,12 @@ mod tests {
             debug_dir.join(zone.name()).join(LOG_NAME.replace(".0", ".*"));
         assert_eq!(glob::glob(log_glob.as_str()).unwrap().count(), 1);
         assert!(!zone_logs.join(LOG_NAME).is_file());
+
+        let adm_glob =
+            debug_dir.join("global").join(ADM_LOG_NAME.replace(".0", ".*"));
+        assert_eq!(glob::glob(adm_glob.as_str()).unwrap().count(), 1);
+        assert!(!adm_logs.join(ADM_LOG_NAME).is_file());
+
         assert!(debug_dir.join(CORE_NAME).is_file());
         assert!(!core_dir.join(CORE_NAME).is_file());
         logctx.cleanup_successful();