Error handling and refactoring in tools/linux/procfs.py, and rename multi-process-rss.py.

tools/linux/procfs.py

 #!/usr/bin/env python
 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # A Python library to read and store procfs (/proc) information on Linux.
 #
 # Each information storage class in this file stores original data as original
 # as reasonablly possible. Translation is done when requested. It is to make it
 # always possible to probe the original data.
@@ skipping 74 matching lines @@
   def load_file(stat_f):
     raw = stat_f.readlines()
     stat = ProcStat._PATTERN.match(raw[0])
     return ProcStat(raw,
                     stat.groupdict().get('PID'),
                     stat.groupdict().get('VSIZE'),
                     stat.groupdict().get('RSS'))
 
   @staticmethod
   def load(pid):
-    with open(os.path.join('/proc', str(pid), 'stat'), 'r') as stat_f:
-      return ProcStat.load_file(stat_f)
+    try:
+      with open(os.path.join('/proc', str(pid), 'stat'), 'r') as stat_f:
+        return ProcStat.load_file(stat_f)
+    except IOError:
+      return None
 
   @property
   def raw(self):
     return self._raw
 
   @property
   def pid(self):
     return int(self._pid)
 
   @property
@@ skipping 21 matching lines @@
     self._size = size
     self._resident = resident
     self._share = share
     self._text = text
     self._lib = lib
     self._data = data
     self._dt = dt
 
   @staticmethod
   def load_file(statm_f):
-    raw = statm_f.readlines()
+    try:
+      raw = statm_f.readlines()
+    except (IOError, OSError):
+      return None
     statm = ProcStatm._PATTERN.match(raw[0])
     return ProcStatm(raw,
                      statm.groupdict().get('SIZE'),
                      statm.groupdict().get('RESIDENT'),
                      statm.groupdict().get('SHARE'),
                      statm.groupdict().get('TEXT'),
                      statm.groupdict().get('LIB'),
                      statm.groupdict().get('DATA'),
                      statm.groupdict().get('DT'))
 
   @staticmethod
   def load(pid):
-    with open(os.path.join('/proc', str(pid), 'statm'), 'r') as statm_f:
-      return ProcStatm.load_file(statm_f)
+    try:
+      with open(os.path.join('/proc', str(pid), 'statm'), 'r') as statm_f:
+        return ProcStatm.load_file(statm_f)
+    except (IOError, OSError):
+      return None
 
   @property
   def raw(self):
     return self._raw
 
   @property
   def size(self):
     return int(self._size)
 
   @property
@@ skipping 160 matching lines @@
 
   @staticmethod
   def load_file(maps_f):
     table = ProcMaps()
     for line in maps_f:
       table.append_line(line)
     return table
 
   @staticmethod
   def load(pid):
-    with open(os.path.join('/proc', str(pid), 'maps'), 'r') as maps_f:
-      return ProcMaps.load_file(maps_f)
+    try:
+      with open(os.path.join('/proc', str(pid), 'maps'), 'r') as maps_f:
+        return ProcMaps.load_file(maps_f)
+    except (IOError, OSError):
+      return None
 
   def append_line(self, line):
     entry = self.parse_line(line)
     if entry:
       self._append_entry(entry)
     return entry
 
   @staticmethod
   def parse_line(line):
     matched = ProcMaps.MAPS_PATTERN.match(line)
@@ skipping 203 matching lines @@
 
   @staticmethod
   def load(pid, maps):
     total_present = 0
     total_swapped = 0
     total_vsize = 0
     in_process_dup = 0
     vma_internals = collections.OrderedDict()
     process_pageframe_set = set()
 
-    pagemap_fd = os.open(
-        os.path.join('/proc', str(pid), 'pagemap'), os.O_RDONLY)
+    try:
+      pagemap_fd = os.open(
+          os.path.join('/proc', str(pid), 'pagemap'), os.O_RDONLY)
+    except (IOError, OSError):
+      return None
     for vma in maps:
       present = 0
       swapped = 0
       vsize = 0
       pageframes = collections.defaultdict(int)
       begin_offset = ProcPagemap._offset(vma.begin)
       chunk_size = ProcPagemap._offset(vma.end) - begin_offset
-      os.lseek(pagemap_fd, begin_offset, os.SEEK_SET)
-      buf = os.read(pagemap_fd, chunk_size)
+      try:
+        os.lseek(pagemap_fd, begin_offset, os.SEEK_SET)
+        buf = os.read(pagemap_fd, chunk_size)
+      except (IOError, OSError):
+        return None
       if len(buf) < chunk_size:
         _LOGGER.warn('Failed to read pagemap at 0x%x in %d.' % (vma.begin, pid))
       pagemap_values = struct.unpack(
           '=%dQ' % (len(buf) / ProcPagemap._BYTES_PER_PAGEMAP_VALUE), buf)
       for pagemap_value in pagemap_values:
         vsize += ProcPagemap._BYTES_PER_OS_PAGE
         if pagemap_value & ProcPagemap._MASK_PRESENT:
           if (pagemap_value & ProcPagemap._MASK_PFN) in process_pageframe_set:
             in_process_dup += ProcPagemap._BYTES_PER_OS_PAGE
           else:
             process_pageframe_set.add(pagemap_value & ProcPagemap._MASK_PFN)
           if (pagemap_value & ProcPagemap._MASK_PFN) not in pageframes:
             present += ProcPagemap._BYTES_PER_OS_PAGE
           pageframes[pagemap_value & ProcPagemap._MASK_PFN] += 1
         if pagemap_value & ProcPagemap._MASK_SWAPPED:
           swapped += ProcPagemap._BYTES_PER_OS_PAGE
       vma_internals[vma] = ProcPagemap.VMA(vsize, present, swapped, pageframes)
       total_present += present
       total_swapped += swapped
       total_vsize += vsize
-    os.close(pagemap_fd)
+    try:
+      os.close(pagemap_fd)
+    except OSError:
+      return None
 
     return ProcPagemap(total_vsize, total_present, total_swapped,
                        vma_internals, in_process_dup)
 
   @staticmethod
   def _offset(virtual_address):
     return virtual_address / ProcPagemap._VIRTUAL_TO_PAGEMAP_OFFSET
 
   @property
   def vsize(self):
@@ skipping 120 matching lines @@
     print ' status: %d (Peak:%d)' % (procs[pid].status.vm_rss * 1024,
                                      procs[pid].status.vm_hwm * 1024)
     print '  smaps: %d' % (procs[pid].smaps.rss * 1024)
     print 'pagemap: %d' % procs[pid].pagemap.present
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))