use memory-mapped IO instead of file reads

Author: andrurogerz

tools/swift-inspect/Sources/SwiftInspectLinux/ElfFile.swift

@@ -17,53 +17,37 @@ import LinuxSystemHeaders
 // currently private to swift/stdlib/public/Backtrace.
 class ElfFile {
   public enum ELFError: Error {
-    case readFailure(_ filePath: String, offset: UInt64, size: UInt64)
     case notELF64(_ filePath: String, _ description: String = "")
     case malformedFile(_ filePath: String, _ description: String = "")
   }
 
   public typealias SymbolMap = [String: (start: UInt64, end: UInt64)]
 
   let filePath: String
-  let file: FileHandle
+  let fileData: Data
   let ehdr: Elf64_Ehdr
 
   public init(filePath: String) throws {
     self.filePath = filePath
 
-    let file = try FileHandle(forReadingFrom: URL(fileURLWithPath: filePath))
-    self.file = file
+    let fileData = try Data(contentsOf: URL(fileURLWithPath: filePath), options: .alwaysMapped)
+    self.fileData = fileData
 
     let identLen = Int(EI_NIDENT)
-    file.seek(toFileOffset: 0)
-    guard let identData = try file.read(upToCount: identLen), identData.count == identLen else {
-      file.closeFile()
-      throw ELFError.readFailure(filePath, offset: 0, size: UInt64(identLen))
-    }
-
-    let identMagic = String(bytes: identData.prefix(Int(SELFMAG)), encoding: .utf8)
+    let identMagic = String(bytes: fileData[0..<identLen].prefix(Int(SELFMAG)), encoding: .utf8)
     guard identMagic == ELFMAG else {
-      file.closeFile()
       throw ELFError.notELF64(filePath)
     }
 
-    let identClass = identData[Int(EI_CLASS)]
+    let identClass = fileData[Int(EI_CLASS)]
     guard identClass == ELFCLASS64 else {
       throw ELFError.notELF64(filePath, "\(identClass) != ELFCLASS64")
     }
 
     let ehdrSize = MemoryLayout<Elf64_Ehdr>.size
-    file.seek(toFileOffset: 0)
-    guard let ehdrData = try file.read(upToCount: ehdrSize), ehdrData.count == ehdrSize else {
-      file.closeFile()
-      throw ELFError.readFailure(filePath, offset: 0, size: UInt64(ehdrSize))
-    }
-
-    self.ehdr = ehdrData.withUnsafeBytes { $0.load(as: Elf64_Ehdr.self) }
+    self.ehdr = fileData[0..<ehdrSize].withUnsafeBytes { $0.load(as: Elf64_Ehdr.self) }
   }
 
-  deinit { self.file.closeFile() }
-
   // returns a map of symbol names to their offset range in file (+ baseAddress)
   public func loadSymbols(baseAddress: UInt64 = 0) throws -> SymbolMap {
     guard let sectionCount = UInt(exactly: self.ehdr.e_shnum) else {
@@ -73,11 +57,11 @@ class ElfFile {
 
     var symbols: SymbolMap = [:]
     for sectionIndex in 0..<sectionCount {
-      let shdr: Elf64_Shdr = try self.readShdr(index: sectionIndex)
+      let shdr: Elf64_Shdr = try self.loadShdr(index: sectionIndex)
       guard shdr.sh_type == SHT_SYMTAB || shdr.sh_type == SHT_DYNSYM else { continue }
 
-      let sectionData: Data = try self.readSection(shdr)
-      let symTable: [Elf64_Sym] = sectionData.withUnsafeBytes {
+      let symTableData: Data = try self.loadSection(shdr)
+      let symTable: [Elf64_Sym] = symTableData.withUnsafeBytes {
         Array($0.bindMemory(to: Elf64_Sym.self))
       }
 
@@ -91,13 +75,16 @@ class ElfFile {
         throw ELFError.malformedFile(self.filePath, "invalid Elf64_Shdr.sh_link: \(shdr.sh_link)")
       }
 
-      let shdrLink: Elf64_Shdr = try self.readShdr(index: UInt(linkIndex))
+      let shdrLink: Elf64_Shdr = try self.loadShdr(index: UInt(linkIndex))
       guard shdrLink.sh_type == SHT_STRTAB else {
         throw ELFError.malformedFile(self.filePath, "linked section not SHT_STRTAB")
       }
 
       // load the entire contents of the string table into memory
-      let strTable: Data = try self.readSection(shdrLink)
+      let strTableData: Data = try self.loadSection(shdrLink)
+      let strTable: [UInt8] = strTableData.withUnsafeBytes {
+        Array($0.bindMemory(to: UInt8.self))
+      }
 
       let symCount = Int(shdr.sh_size / shdr.sh_entsize)
       for symIndex in 0..<symCount {
@@ -110,7 +97,7 @@ class ElfFile {
         }
 
         guard let strEnd = strTable[strStart...].firstIndex(of: 0),
-          let symName = String(data: strTable[strStart..<strEnd], encoding: .utf8)
+          let symName = String(bytes: strTable[strStart..<strEnd], encoding: .utf8)
         else {
           throw ELFError.malformedFile(self.filePath, "invalid string @ offset \(strStart)")
         }
@@ -124,8 +111,8 @@ class ElfFile {
     return symbols
   }
 
-  // reads and returns the Elf64_Shdr at the specified index
-  internal func readShdr(index: UInt) throws -> Elf64_Shdr {
+  // returns the Elf64_Shdr at the specified index
+  internal func loadShdr(index: UInt) throws -> Elf64_Shdr {
     guard index < self.ehdr.e_shnum else {
       throw ELFError.malformedFile(
         self.filePath, "section index \(index) >= Elf64_Ehdr.e_shnum \(self.ehdr.e_shnum))")
@@ -136,27 +123,22 @@ class ElfFile {
       throw ELFError.malformedFile(self.filePath, "Elf64_Ehdr.e_shentsize != \(shdrSize)")
     }
 
-    let shdrOffset: UInt64 = self.ehdr.e_shoff + UInt64(index) * UInt64(shdrSize)
-    self.file.seek(toFileOffset: shdrOffset)
-    guard let shdrData = try self.file.read(upToCount: shdrSize), shdrData.count == shdrSize else {
-      throw ELFError.readFailure(self.filePath, offset: shdrOffset, size: UInt64(shdrSize))
-    }
-
+    let shdrOffset = Int(self.ehdr.e_shoff) + Int(index) * shdrSize
+    let shdrData = self.fileData[shdrOffset..<(shdrOffset + shdrSize)]
     return shdrData.withUnsafeBytes { $0.load(as: Elf64_Shdr.self) }
   }
 
-  // reads and returns all data in the specified section
-  internal func readSection(_ shdr: Elf64_Shdr) throws -> Data {
+  // returns all data in the specified section
+  internal func loadSection(_ shdr: Elf64_Shdr) throws -> Data {
     guard let sectionSize = Int(exactly: shdr.sh_size) else {
       throw ELFError.malformedFile(self.filePath, "Elf64_Shdr.sh_size too large \(shdr.sh_size)")
     }
 
-    let fileOffset = shdr.sh_offset
-    self.file.seek(toFileOffset: fileOffset)
-    guard let data = try self.file.read(upToCount: sectionSize), data.count == sectionSize else {
-      throw ELFError.readFailure(self.filePath, offset: fileOffset, size: UInt64(sectionSize))
+    guard let fileOffset = Int(exactly: shdr.sh_offset) else {
+      throw ELFError.malformedFile(
+        self.filePath, "Elf64_Shdr.sh_offset too large \(shdr.sh_offset)")
     }
 
-    return data
+    return self.fileData[fileOffset..<(fileOffset + sectionSize)]
   }
 }