Get size using --get-size in flashrom_util.py instead of reading whole flash.

client/common_lib/flashrom_util.py

 #!/usr/bin/env python
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 This module provides convenience routines to access Flash ROM (EEPROM).
  - flashrom_util is a low level wrapper of flashrom(8) program.
  - FlashromUtility is a high level object which provides more advanced
    features like journaling-alike (log-based) changing.
@@ skipping 307 matching lines @@
         assert section_name in layout_map, "Invalid section: " + section_name
         pos = layout_map[section_name]
         if pos[0] >= pos[1] or pos[1] >= len(base_image):
             raise TestError('INTERNAL ERROR: invalid layout map.')
         if len(data) != pos[1] - pos[0] + 1:
             raise TestError('INTERNAL ERROR: unmatched data size.')
         return base_image[0 : pos[0]] + data + base_image[pos[1] + 1 :]
 
     def get_size(self):
         """ Gets size of current flash ROM """
-        # TODO(hungte) Newer version of tool (flashrom) may support --get-size
-        # command which is faster in future. Right now we use back-compatible
-        # method: read whole and then get length.
-        image = self.read_whole()
-        return len(image)
+        cmd = '%s"%s" --get-size' % (self.cmd_prefix, self.tool_path)
+        if self.verbose:
+            print 'flashrom_util.get_size(): ', cmd
+        output = utils.system_output(cmd, ignore_status=True)
+        last_line = output.rpartition('\n')[2]
+        try:
+            size = long(last_line)
+        except ValueError:
+            raise TestError('INTERNAL ERROR: unable to get the flash size.')
+        return size
 
     def detect_target_map(self):
         """
         Detects the target selection map.
         Use machine architecture in current implementation.
         """
         arch = utils.get_arch()
         for regex, target_map in DEFAULT_ARCH_TARGET_MAP.items():
             if re.match(regex, arch):
                 return target_map
@@ skipping 407 matching lines @@
         sys.exit(1)
 
 
 class mock_utils(object):
     """ a mock for autotest_li.client.bin.utils """
     def get_arch(self):
         arch = os.popen('uname -m').read().rstrip()
         arch = re.sub(r"i\d86", r"i386", arch, 1)
         return arch
 
-    def system(self, cmd, ignore_status=False):
+    def run_command(self, cmd, ignore_status=False):
         p = subprocess.Popen(cmd, shell=True,
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
         p.wait()
-        if p.returncode:
-            err_msg = p.stderr.read()
-            print p.stdout.read()
-            print err_msg
-            if not ignore_status:
-                raise TestError("failed to execute: %s\nError messages: %s" % (
-                    cmd, err_msg()))
-        return p.returncode
+        if p.returncode and not ignore_status:

[Hung-Te, 2010/09/02 02:10:22]

oops, please keep the print stdout.read() and err_msg when return code is not
zero. Because we really need the output from flashrom which helps debugging...

[Tom Wai-Hong Tam, 2010/09/02 02:55:24]

OK. Will change it in other CL: http://codereview.chromium.org/3343003

+            raise TestError("failed to execute: %s\nError messages: %s" % (
+                cmd, p.stderr.read()))
+        return (p.returncode, p.stdout.read())
+
+    def system(self, cmd, ignore_status=False):
+        (returncode, output) = self.run_command(cmd, ignore_status)
+        return returncode
+
+    def system_output(self, cmd, ignore_status=False):
+        (returncode, output) = self.run_command(cmd, ignore_status)
+        return output
 
 
 # import autotest or mock utilities
 try:
     # print 'using autotest'
     from autotest_lib.client.bin import test, utils
     from autotest_lib.client.common_lib.error import TestError
 except ImportError:
     # print 'using mocks'
     utils = mock_utils()
     TestError = mock_TestError
 
 
 # main stub
 if __name__ == "__main__":
     # TODO(hungte) provide unit tests or command line usage
     pass