manageiq-smartstate 0.1.0

data/lib/fs/iso9660/rock_ridge.rb

@@ -0,0 +1,329 @@
+require 'sys-uname'
+
+require 'binary_struct'
+require 'util/miq-unicode'
+
+module Iso9660
+  # SUSP extensions are present if the first two characters of the SUA of
+  # the first directory entry are "SP". After SUSP is identified, if the
+  # first two characters of any directory entry's SUA are "RR" a Rock Ridge
+  # extension is active for that entry. The particular extension is
+  # identified by the two characters after the next two bytes following "RR".
+
+  # NOTE: This implementation is sufficient for Rock Ridge extensions. It will
+  # not identify or process any other System Use Sharing Protocol extensions.
+  # In particular, SUSP CE (continuation area) records are not processed. This
+  # is where the "RR" extension is defined. This implementation uses the
+  # assumed definition RR_HEADER.
+
+  RR_SIGNATURE = "RR"
+  RR_HEADER = BinaryStruct.new([
+    'a2', 'signature',  # RR if Rock Ridge.
+    'C',  'unused1',    # ? always seems to be 5.
+    'C',  'unused2',    # ? always seems to be 1 (version?).
+    'C',  'unused3'     # ? 0x81
+  ])
+  RR_HEADER_SIZE = 5
+
+  # These types are not used, but we want to know if they pop up.
+  RR_PN_SIGNATURE = "PN"
+  RR_CL_SIGNATURE = "CL"
+  RR_PL_SIGNATURE = "PL"
+  RR_RE_SIGNATURE = "RE"
+  RR_TF_SIGNATURE = "TF"
+
+  # POSIX file attributes. See POSIX 5.6.1.
+  RR_PX_SIGNATURE = "PX"
+  RR_PX = BinaryStruct.new([
+    'L',  'modeLE',   # file mode (used to identify a link).
+    'L',  'modeBE',
+    'L',  'linksLE',  # Num links (st_nlink).
+    'L',  'linksBE',
+    'L',  'userLE',   # User ID.
+    'L',  'userBE',
+    'L',  'groupLE',  # Group ID.
+    'L',  'groupBE'
+    # 'L', 'serialLE', # File serial number.
+    # 'L', 'serialBE'
+  ])
+  # NOTE: IEEE P1282 specifies that file serial number is included, but
+  # real data shows this number is absent. Likewise, the spec says the
+  # struct length is 44 bytes, where real data shows a length of 36 bytes.
+  # It's also worth noting that the real data shows a structure version
+  # of 1, so there is definitely disagreement betweeen theory (IEEE P1282)
+  # and reality (the Open Solaris developer edition distro iso).
+
+  # File mode bits.
+  RR_EXT_SL_FM_SOCK = 0xc000
+  RR_EXT_SL_FM_LINK = 0xa000
+  RR_EXT_SL_FM_FILE = 0x8000
+  RR_EXT_SL_FM_BLOK = 0x6000
+  RR_EXT_SL_FM_CHAR = 0x2000
+  RR_EXT_SL_FM_DIR  = 0x4000
+  RR_EXT_SL_FM_FIFO = 0x1000
+
+  class PosixAttributes
+    attr_reader :flags
+
+    def initialize(data, suff)
+      @flags = 0
+      @suff = suff
+      @px = RR_PX.decode(data)
+    end
+
+    def mode
+      @px["mode#{@suff}"]
+    end
+
+    def nlinks
+      @px["links#{@suff}"]
+    end
+
+    def user
+      @px["user#{@suff}"]
+    end
+
+    def group
+      @px["group#{@suff}"]
+    end
+
+    def isFile?
+      mode & RR_EXT_SL_FM_FILE != 0
+    end
+
+    def isDir?
+      mode & RR_EXT_SL_FM_DIR != 0
+    end
+
+    def isSymLink?
+      mode & RR_EXT_SL_FM_LINK != 0
+    end
+  end # class PosixAttributes
+
+  # Symbolic link.
+  RR_SL_SIGNATURE = "SL"
+  RR_SL = BinaryStruct.new([
+    'C',  'flags',  # See RR_EXT_SLF_ below.
+    'a*', 'components'
+  ])
+
+  # Symbolic link flags.
+  RR_EXT_SLF_CONTINUE = 0x01  # Link continues in the next SL entry.
+
+  # A symbolic link component record.
+  RR_SL_COMPONENT = BinaryStruct.new([
+    'C',  'flags',  # See RR_EXT_SLCOMPF_ below.
+    'C',  'length', # Length of content in bytes.
+    'a*', 'content'
+  ])
+
+  RR_EXT_SLCOMPF_CONTINUE   = 0x01  # Component continues in the next component record.
+  RR_EXT_SLCOMPF_CURRENT    = 0x02  # Component refers to the current directory.
+  RR_EXT_SLCOMPF_PARENT     = 0x04  # Component refers to the parent directory.
+  RR_EXT_SLCOMPF_ROOT       = 0x08  # Component refers to the root directory.
+  RR_EXT_SLCOMPF_RESERVED1  = 0x10  # See below.
+  RR_EXT_CLCOMPF_RESERVED2  = 0x20  # See below.
+  # RESERVED1: Historically, this component has referred to the directory on
+  # which the current CD-ROM is mounted.
+  # Reserved2: Historically, this component has contained the network node
+  # name of the current system as defined in the uname structure of POSIX 4.4.1.2
+
+  class SymbolicLink
+    attr_reader :flags
+    attr_accessor :linkData
+
+    def initialize(data, _suff)
+      sl = RR_SL.decode(data)
+
+      # Reader data.
+      @flags = sl['flags']
+      @linkData = assembleComponents(sl['components'])
+    end
+
+    def assembleComponents(data)
+      out = ""; offset = 0
+      loop do
+        comp = RR_SL_COMPONENT.decode(data[offset..-1])
+
+        # Check for referential flags.
+        out += "./" if comp['flags'] & RR_EXT_SLCOMPF_CURRENT != 0
+        out += "../" if comp['flags'] & RR_EXT_SLCOMPF_PARENT != 0
+        out += "/" if comp['flags'] & RR_EXT_SLCOMPF_ROOT != 0
+
+        # Advance offset, append content (if any) & check for done.
+        # puts "Component content:"
+        # comp['content'][0, comp['length']].hex_dump(:obj => STDOUT, :meth => :puts, :newline => false)
+        # puts "\n\n"
+        offset += comp['length'] + 2 # compensate for first two bytes of component.
+        next if comp['length'] == 0
+        out = File.join(out, comp['content'][0, comp['length']])
+        # break if comp['flags'] & RR_EXT_SLCOMPF_CONTINUE == 0
+        # Analysis of real data shows the condition is offset >= data len.
+        break if offset >= data.length
+      end
+      # puts "Total content:"
+      # out.hex_dump(:obj => STDOUT, :meth => :puts, :newline => false)
+      # puts "\n\n"
+      out
+    end
+  end # class SymbolicLink
+
+  # Alternate name.
+  RR_NM_SIGNATURE = "NM"
+  RR_NM = BinaryStruct.new([
+    'C',  'flags',  # See RR_EXT_NMF_ below.
+    'a*', 'content'
+  ])
+
+  # NOTE: These flag bits are mutually exclusive.
+  RR_EXT_NMF_CONTINUE   = 0x01  # Name continues in the next NM entry.
+  RR_EXT_NMF_CURRENT    = 0x02  # Name refers to the current directory.
+  RR_EXT_NMF_PARENT     = 0x04  # Name refers to the parent directory.
+  RR_EXT_NMF_RESERVED1  = 0x08  # Reserved - 0.
+  RR_EXT_NMF_RESERVED2  = 0x10  # Reserved - 0.
+  RR_EXT_NMF_RESERVED3  = 0x20  # Implementation specific.
+  # NOTE: IEEE-P1282 lists the following note about RESERVED3:
+  # Historically, this component has contained the network node name of
+  # the current system as defined in the uname structure of POSIX 4.4.1.2
+
+  class AlternateName
+    attr_reader :flags
+    attr_accessor :name
+
+    def initialize(data, _suff)
+      an = RR_NM.decode(data)
+
+      # Check for referential flags.
+      @name = ""
+      @name += "./" if an['flags'] & RR_EXT_NMF_CURRENT != 0
+      @name += "../" if an['flags'] & RR_EXT_NMF_PARENT != 0
+      raise "RR extension NM: RESERVED3 flag is set." if an['flags'] & RR_EXT_NMF_RESERVED3 != 0
+
+      # Reader data.
+      @flags = an['flags']
+      @name += an['content']
+    end
+  end # class AlternateName
+
+  # Sparse File.
+  RR_SF_SIGNATURE = "SF"
+  RR_SF = BinaryStruct.new([
+    'L',  'size_hiLE',
+    'L',  'size_hiBE',
+    'L',  'size_loLE',
+    'L',  'size_loBE',
+    'C',  'table_depth',
+  ])
+
+  # Um, sparse file is pretty complicated so I'm just going to get the
+  # first three going and then worry about this.
+
+  class SparseFile
+    attr_reader :length, :fileData, :flags
+
+    def initialize(data, suff)
+      @sf = RR_SF.decode(data)
+      @flags = 0
+      @suff = suff
+      raise "Sparse file."
+    end
+
+    def length
+      (@sf["size_hi#{@suff}"] << 32) + @sf["size_lo#{@suff}"]
+    end
+  end # class SparseFile
+
+  # Common to all RR extensions.
+  RR_EXT_HEADER = BinaryStruct.new([
+    'a2', 'signature',  # Extension type.
+    'C',  'length',     # length in bytes.
+    'C',  'version'     # Entry version, always 1.
+  ])
+  RR_EXT_HEADER_SIZE = 4
+
+  class Extension
+    attr_reader :length, :ext
+
+    def initialize(data, suff)
+      # Get extension header, length & data.
+      @header = RR_EXT_HEADER.decode(data)
+      @length = @header['length']
+      data = data[RR_EXT_HEADER_SIZE, @length - RR_EXT_HEADER_SIZE]
+      # puts "Extension data (from Extension):"
+      # data.hex_dump(:obj => STDOUT, :meth => :puts, :newline => false)
+      # puts "\n\n"
+
+      # Delegate to extension.
+      @ext = case @header['signature']
+             when RR_PX_SIGNATURE then PosixAttributes.new(data, suff)
+             when RR_PN_SIGNATURE then warnAbout(RR_PN_SIGNATURE, data)
+             when RR_SL_SIGNATURE then SymbolicLink.new(data, suff)
+             when RR_NM_SIGNATURE then AlternateName.new(data, suff)
+             when RR_CL_SIGNATURE then warnAbout(RR_CL_SIGNATURE, data)
+             when RR_PL_SIGNATURE then warnAbout(RR_PL_SIGNATURE, data)
+             when RR_RE_SIGNATURE then warnAbout(RR_RE_SIGNATURE, data)
+             when RR_TF_SIGNATURE then warnAbout(RR_TF_SIGNATURE, data)
+             when RR_SF_SIGNATURE then SparseFile.new(data, suff)
+             end
+    end
+
+    def warnAbout(ext, data)
+      if $log
+        $log.debug("RR extension #{ext} found, not processed. Data is:")
+        data.hex_dump(:obj => $log, :meth => :debug, :newline => false)
+      end
+      nil
+    end
+  end # class Extension
+
+  class RockRidge
+    SUSP_SIZE = 7
+    CONTINUE = 1
+
+    attr_reader :extensions
+
+    def initialize(de, suff)
+      raise "No DirectoryEntry specified." if de.nil?
+      raise "The specified DirectoryEntry has no System Use Area." if de.sua.nil?
+
+      # Root directories need to skip SUSP header.
+      offset = de.name == "." ? SUSP_SIZE : 0
+
+      # Get the RR header from the DirectoryEntry & verify.
+      @header = RR_HEADER.decode(de.sua[offset..-1])
+      raise "This is not a Rock Ridge extension record" if @header['signature'] != RR_SIGNATURE
+
+      # Loop through extensions.
+      offset += RR_HEADER_SIZE
+      @extensions = []
+      loop do
+        # puts "Extension data:
+        # de.sua[offset..-1].hex_dump(:obj => STDOUT, :meth => :puts, :newline => false)
+        # puts "\n\n"
+        ext = Extension.new(de.sua[offset..-1], suff)
+        @extensions << ext
+        offset += ext.length
+        break if offset >= de.sua.length
+      end
+
+      # Handle continuations.
+      0.upto(@extensions.size - 1) do |idx|
+        obj = @extensions[idx]
+        next if obj.nil?
+
+        # TODO: Simplify this - the meat of all extensions is .data
+        if obj.flags & CONTINUE
+          if obj.kind_of?(AlternateName)
+            obj.name += @extensions[idx + 1].name
+            @extensions[idx + 1] = nil
+          end
+          if obj.kind_of?(SymbolicLink)
+            obj.linkData += @extensions[idx + 1].linkData
+            @extensions[idx + 1] = nil
+          end
+        end
+      end
+      @extensions.delete(nil)
+    end
+  end # class RockRidge
+end # module

data/lib/fs/iso9660/util.rb

@@ -0,0 +1,57 @@
+# encoding: US-ASCII
+
+require 'ostruct'
+
+require 'binary_struct'
+
+module Iso9660
+  module Util
+    ISO_DATE = BinaryStruct.new([
+      'a4', 'year',   # Absolute year.
+      'a2', 'month',
+      'a2', 'day',
+      'a2', 'hour',
+      'a2', 'min',
+      'a2', 'sec',
+      'a2', 'hun',
+      'c',  'offset'  # 15-min intervals (iow 4 per time zone).
+    ])
+
+    ISO_DATE_SHORT = BinaryStruct.new([
+      'C',  'year',   # Since 1900.
+      'C',  'month',
+      'C',  'day',
+      'C',  'hour',
+      'C',  'min',
+      'C',  'sec',
+      'c',  'offset'  # 15-min intervals.
+    ])
+
+    def self.IsoToRubyDate(isodate)
+      begin
+        tv = OpenStruct.new(ISO_DATE.decode(isodate))
+      rescue
+        return Time.at(0).gmtime
+      end
+      Time.gm(tv.sec, tv.min, tv.hour, tv.day, tv.month, tv.year, nil, nil, nil, tv.offset / 4)
+    end
+
+    def self.GetTimezone(isodate)
+      isodate[16, 1].unpack('c')[0] / 4
+    end
+
+    def self.IsoShortToRubyDate(isoShort)
+      return Time.at(0).gmtime if isoShort == "\0" * 7
+      begin
+        tv = OpenStruct.new(ISO_DATE_SHORT.decode(isoShort))
+      rescue
+        return Time.at(0).gmtime
+      end
+      Time.gm(tv.sec, tv.min, tv.hour, tv.day, tv.month, tv.year + 1900, nil, nil, nil, tv.offset / 4)
+    end
+
+    def self.GetShortTimezone(isoShort)
+      isoShort[7] / 4
+    end
+  end
+end

data/lib/fs/modules/LinuxMount.rb

@@ -0,0 +1,300 @@
+require 'fs/MiqFS/MiqFS'
+
+module LinuxMount
+  FSTAB_FILE_NAME = "/etc/fstab"
+
+  def fs_init
+    @guestOS = "Linux"
+
+    @rootFS = MiqFS.getFS(@rootVolume)
+    raise "LinuxMount: could not mount root volume" unless @rootFS
+
+    #
+    # Assign device letters to all ide and scsi devices,
+    # even if they're not visible volumes. We need to do
+    # this to assign the proper device names to visible
+    # devices.
+    #
+    sdLetter  = 'a'
+    ideMap    = {"ide0:0" => "a", "ide0:1" => "b", "ide1:0" => "c", "ide1:1" => "d"}
+    @devHash = {}
+    @vmConfig.getAllDiskKeys.each do |dk|
+      if dk =~ /^ide.*$/
+        @devHash[dk] = "/dev/hd" + ideMap[dk]
+        $log.debug "LinuxMount: devHash[#{dk}] = /dev/hd#{ideMap[dk]}" if $log.debug?
+      elsif dk =~ /^scsi.*$/
+        @devHash[dk] = "/dev/sd" + sdLetter
+        $log.debug "LinuxMount: devHash[#{dk}] = /dev/sd#{sdLetter}" if $log.debug?
+        sdLetter.succ!
+      end
+    end
+
+    #
+    # Build hash for fstab fs_spec look up.
+    #
+    fsSpecHash = {}
+    @volumes.each do |v|
+      $log.debug "LinuxMount: Volume = #{v.dInfo.localDev} (#{v.dInfo.hardwareId}, partition = #{v.partNum})" if $log.debug?
+      if v == @rootVolume
+        fs = @rootFS
+      else
+        unless (fs = MiqFS.getFS(v))
+          $log.debug "LinuxMount: No filesystem on Volume: #{v.dInfo.localDev}, partition = #{v.partNum}" if $log.debug?
+          next
+        end
+      end
+      @allFileSystems << fs
+
+      #
+      # Specific file systems can be identified by fs UUID
+      # or file system volume label.
+      #
+      unless fs.volName.empty?
+        $log.debug "LinuxMount: adding \"LABEL=#{fs.volName}\" to fsSpecHash" if $log.debug?
+        fsSpecHash["LABEL=#{fs.volName}"]  = fs
+        $log.debug "LinuxMount: adding \"LABEL=/#{fs.volName}\" to fsSpecHash" if $log.debug?
+        fsSpecHash["LABEL=/#{fs.volName}"] = fs
+      end
+      unless fs.fsId.empty?
+        $log.debug "LinuxMount: adding \"UUID=#{fs.fsId}\" to fsSpecHash" if $log.debug?
+        fsSpecHash["UUID=#{fs.fsId}"] = fs
+      end
+
+      #
+      # Logical volumes can be identified by their lv specific
+      # entries under /dev.
+      #
+      if v.dInfo.lvObj
+        lvName = v.dInfo.lvObj.lvName
+        vgName = v.dInfo.lvObj.vgObj.vgName
+        fsSpecHash["/dev/#{vgName}/#{lvName}"] = fs
+        fsSpecHash["/dev/mapper/#{vgName.gsub('-','--')}-#{lvName.gsub('-','--')}"] = fs
+        fsSpecHash["UUID=#{v.dInfo.lvObj.lvId}"] = fs
+        $log.debug "LinuxMount: Volume = #{v.dInfo.localDev}, partition = #{v.partNum} is a logical volume" if $log.debug?
+        next
+      end
+
+      #
+      # Physical volumes are identified by entries under
+      # /dev based on OS hardware scan.
+      # TODO: support physical volume UUIDs
+      #
+      $log.debug "LinuxMount: v.dInfo.hardwareId = #{v.dInfo.hardwareId}" if $log.debug?
+      if v.partNum == 0
+        fsSpecHash[@devHash[v.dInfo.hardwareId]] = fs
+      else
+        fsSpecHash[@devHash[v.dInfo.hardwareId] + v.partNum.to_s] = fs
+      end
+    end
+
+    #
+    # Assign OS-specific names to all physical volumes.
+    #
+    @osNames = {}
+    @volMgr.allPhysicalVolumes.each do |v|
+      if $log.debug?
+        $log.debug "LinuxMount: v.dInfo.hardwareId = #{v.dInfo.hardwareId}"
+        $log.debug "LinuxMount: v.partNum.to_s = #{v.partNum}"
+        $log.debug "LinuxMount: @devHash[v.dInfo.hardwareId] = #{@devHash[v.dInfo.hardwareId]}"
+      end
+      @osNames[v.dInfo.hardwareId + ':' + v.partNum.to_s] = @devHash[v.dInfo.hardwareId] + v.partNum.to_s
+    end
+
+    #
+    # Build a tree of file systems and their associated mont points.
+    #
+    root_added = false
+    @mountPoints = {}
+    $log.debug "LinuxMount: processing #{FSTAB_FILE_NAME}" if $log.debug?
+    @rootFS.fileOpen(FSTAB_FILE_NAME, &:read).each_line do |fstl|
+      $log.debug "LinuxMount: fstab line: #{fstl}" if $log.debug?
+      next if fstl =~ /^#.*$/ || fstl =~ /^\s*$/
+      fsSpec, mtPoint = fstl.split(/\s+/)
+      $log.debug "LinuxMount: fsSpec: #{fsSpec}, mtPoint: #{mtPoint}" if $log.debug?
+      next if fsSpec == "none" || mtPoint == "swap"
+      next unless (fs = fsSpecHash[fsSpec])
+      $log.debug "LinuxMount: Adding fsSpec: #{fsSpec}, mtPoint: #{mtPoint}" if $log.debug?
+      addMountPoint(mtPoint, fs, fsSpec)
+      root_added = true if mtPoint == '/'
+    end
+    saveFs(@rootFS, "/", "ROOT") unless root_added
+  end # def fs_init
+
+  #
+  # Given a path to a file, return true if it's a symbolic link.
+  # Otherwise, return false.
+  #
+  def fileSymLink?(p)
+    #
+    # We can't just expand the links in the whole path,
+    # because then, the target file will no longer be a link.
+    # So, we expand the path to the target file, then open
+    # the target file through that path to obtain the link data.
+    #
+    np = normalizePath(p)
+    d = File.dirname(np)
+    f = File.basename(np)
+
+    # Expand the path to the target file.
+    exp_dir = expandLinks(d)
+
+    # Get the file system where the target file resides, and it's local path.
+    fs, lp = getFsPathBase(File.join(exp_dir, f))
+    (fs.fileSymLink?(lp))
+  end
+
+  #
+  # Given a path to a symbolic link, return the full
+  # path to where the link points.
+  #
+  def getLinkPath(p)
+    #
+    # We can't just expand the links in the whole path,
+    # because then, the target file will no longer be a link.
+    # So, we expand the path to the target file, then open
+    # the target file through that path to obtain the link data.
+    #
+    np = normalizePath(p)
+    d = File.dirname(np)
+    f = File.basename(np)
+
+    # Expand the path to the target file.
+    exp_dir = expandLinks(d)
+
+    # Get the file system where the target file resides, and it's local path.
+    fs, lp = getFsPathBase(File.join(exp_dir, f))
+    # Read the link data from the file, through its file system.
+    sp = getSymLink(fs, lp)
+    # Construct and return the full path to the link target.
+    return(sp) if sp[0, 1] == '/'
+    (normalizePath(File.join(exp_dir, sp)))
+  end
+
+  private
+
+  def normalizePath(p)
+    # When running on windows, File.expand_path will add a drive letter.
+    # Remove it if it's there.
+    np = File.expand_path(p, @cwd).gsub(/^[a-zA-Z]:/, "")
+    # puts "LinuxMount::normalizePath: p = #{p}, np = #{np}"
+    (np)
+  end
+
+  class PathNode
+    attr_accessor :children, :fs
+
+    def initialize
+      @children = {}
+      @fs = nil
+    end
+  end # def PathNode
+
+  #
+  # Add the file system to the mount point tree.
+  #
+  def addMountPoint(mp, fs, fsSpec)
+    saveFs(fs, mp, fsSpec)
+    return if mp == '/'
+    path = mp.split('/')
+    path.delete("")
+    h = @mountPoints
+    tn = nil
+    path.each do |d|
+      h[d] = PathNode.new unless h[d]
+      tn = h[d]
+      h = h[d].children
+    end
+    tn.fs = fs if tn
+  end
+
+  #
+  # Expand symbolic links and perform mount indirection look up.
+  #
+  def getFsPath(path)
+    if path.kind_of? Array
+      if path.length == 0
+        localPath = @cwd
+      else
+        localPath = normalizePath(path[0])
+      end
+    else
+      localPath = normalizePath(path)
+    end
+
+    p = getFsPathBase(expandLinks(localPath))
+    # getFsPathBase(path)
+  end
+
+  #
+  # Mount indirection look up.
+  # Given a path, return its corresponding file system
+  # and the part of the path relative to that file system.
+  # It assumes symbolic links have already been expanded.
+  #
+  def getFsPathBase(path)
+    if path.kind_of? Array
+      if path.length == 0
+        localPath = @cwd
+      else
+        localPath = normalizePath(path[0])
+      end
+    else
+      localPath = normalizePath(path)
+    end
+
+    fs = @rootFS
+    p = localPath.split('/')
+    p.delete("")
+
+    h = @mountPoints
+    while d = p.shift
+      return fs, localPath unless h[d]
+      if tfs = h[d].fs
+        fs = tfs
+        localPath = '/' + p.join('/')
+      end
+      h = h[d].children
+    end
+    return fs, localPath
+  end
+
+  #
+  # Expand symbolic links in the path.
+  # This must be done here, because a symlink in one file system
+  # can point to a file in another filesystem.
+  #
+  def expandLinks(p)
+    cp = '/'
+    components = p.split('/')
+    components.shift if components[0] == "" # root
+
+    #
+    # For each component of the path, check to see
+    # if it's a symbolic link. If so, expand it
+    # relative to its base directory.
+    #
+    components.each do |c|
+      ncp = File.join(cp, c)
+      #
+      # Each file system know how to check for,
+      # and read its own links.
+      #
+      fs, lp = getFsPathBase(ncp)
+      if fs.fileSymLink?(lp)
+        sl = getSymLink(fs, lp)
+        if sl[0, 1] == '/'
+          cp = sl
+        else
+          cp = File.join(cp, sl)
+        end
+      else
+        cp = ncp
+      end
+    end
+    (cp)
+  end
+
+  def getSymLink(fs, p)
+    fs.fileOpen(p, &:read)
+  end
+end # module LinuxMount