Allow using read_file to consume pipe mode data

Author: art049

src/error.rs

@@ -63,6 +63,12 @@ pub enum Error {
 
     #[error("The specified size in the perf event header was smaller than the header itself")]
     InvalidPerfEventSize,
+
+    #[error("Cannot parse non-streaming perf.data file with parse_pipe. Use parse_file instead.")]
+    FileFormatDetectedInPipeMode,
+
+    #[error("Detected pipe format in file mode")]
+    PipeFormatDetectedInFileMode,
 }
 
 impl From<std::str::Utf8Error> for Error {

src/file_reader.rs

@@ -58,7 +58,15 @@ pub struct PerfFileReader<R: Read> {
 
 impl<C: Read + Seek> PerfFileReader<C> {
     pub fn parse_file(mut cursor: C) -> Result<Self, Error> {
-        let header = PerfHeader::parse(&mut cursor)?;
+        let header = match PerfHeader::parse(&mut cursor) {
+            Ok(header) => header,
+            Err(Error::PipeFormatDetectedInFileMode) => {
+                // Rewind and parse as pipe format instead
+                cursor.seek(SeekFrom::Start(0))?;
+                return Self::parse_pipe(cursor);
+            }
+            Err(e) => return Err(e),
+        };
         match &header.magic {
             b"PERFILE2" => {
                 Self::parse_file_impl::<LittleEndian>(cursor, header, Endianness::LittleEndian)

src/header.rs

@@ -2,6 +2,7 @@ use std::io::Read;
 
 use byteorder::{ByteOrder, ReadBytesExt};
 
+use super::error::Error;
 use super::features::FeatureSet;
 use super::section::PerfFileSection;
 
@@ -28,7 +29,7 @@ pub struct PerfHeader {
 }
 
 impl PerfHeader {
-    pub fn parse<R: Read>(mut reader: R) -> Result<Self, std::io::Error> {
+    pub fn parse<R: Read>(mut reader: R) -> Result<Self, Error> {
         let mut magic = [0; 8];
         reader.read_exact(&mut magic)?;
 
@@ -39,11 +40,14 @@ impl PerfHeader {
         }
     }
 
-    fn parse_impl<R: Read, T: ByteOrder>(
-        mut reader: R,
-        magic: [u8; 8],
-    ) -> Result<Self, std::io::Error> {
+    fn parse_impl<R: Read, T: ByteOrder>(mut reader: R, magic: [u8; 8]) -> Result<Self, Error> {
         let header_size = reader.read_u64::<T>()?;
+
+        // Detect if this is actually a pipe format instead of file format.
+        if header_size == std::mem::size_of::<PerfPipeHeader>() as u64 {
+            return Err(Error::PipeFormatDetectedInFileMode);
+        }
+
         let attr_size = reader.read_u64::<T>()?;
         let attr_section = PerfFileSection::parse::<_, T>(&mut reader)?;
         let data_section = PerfFileSection::parse::<_, T>(&mut reader)?;
@@ -81,7 +85,7 @@ pub struct PerfPipeHeader {
 }
 
 impl PerfPipeHeader {
-    pub fn parse<R: Read>(mut reader: R) -> Result<Self, std::io::Error> {
+    pub fn parse<R: Read>(mut reader: R) -> Result<Self, Error> {
         let mut magic = [0; 8];
         reader.read_exact(&mut magic)?;
 
@@ -90,6 +94,14 @@ impl PerfPipeHeader {
         } else {
             reader.read_u64::<byteorder::BigEndian>()?
         };
+
+        // Detect if this is actually a file format instead of pipe format.
+        if size > std::mem::size_of::<Self>() as u64
+            && size == std::mem::size_of::<PerfHeader>() as u64
+        {
+            return Err(Error::FileFormatDetectedInPipeMode);
+        }
+
         Ok(Self { magic, size })
     }
 }