Revert "Merge remote branch 'cros/upstream' into tempbranch2"

client/bin/kernel.py

 import os, shutil, copy, pickle, re, glob, time, logging
 from autotest_lib.client.bin import kernel_config, os_dep, kernelexpand, test
 from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib import log, error, packages
 
 
 def tee_output_logdir_mark(fn):
     def tee_logdir_mark_wrapper(self, *args, **dargs):
         mark = self.__class__.__name__ + "." + fn.__name__
         logging.info("--- START %s ---", mark)
@@ skipping 46 matching lines @@
             # base_args)
             root = arg[len(root_prefix):]
         else:
             arglist.append(arg)
 
     # add the kernel entry
     bootloader.add_kernel(image, tag, initrd=initrd, args=' '.join(arglist),
                           root=root)
 
 
-class BootableKernel(object):
-
-    def __init__(self, job):
-        self.job = job
-        self.installed_as = None  # kernel choice in bootloader menu
-        self.image = None
-        self.initrd = ''
-
-
-    def _boot_kernel(self, args, ident_check, expected_ident, subdir, notes):
-        """
-        Boot a kernel, with post-boot kernel id check
-
-        @param args:  kernel cmdline arguments
-        @param ident_check: check kernel id after boot
-        @param expected_ident:
-        @param subdir: job-step qualifier in status log
-        @param notes:  additional comment in status log
-        """
-
-        # If we can check the kernel identity do so.
-        if ident_check:
-            when = int(time.time())
-            args += " IDENT=%d" % when
-            self.job.next_step_prepend(["job.end_reboot_and_verify", when,
-                                        expected_ident, subdir, notes])
-        else:
-            self.job.next_step_prepend(["job.end_reboot", subdir,
-                                        expected_ident, notes])
-
-        # Point bootloader to the selected tag.
-        _add_kernel_to_bootloader(self.job.bootloader,
-                                  self.job.config_get('boot.default_args'),
-                                  self.installed_as, args, self.image,
-                                  self.initrd)
-
-        # defer fsck for next reboot, to avoid reboots back to default kernel
-        utils.system('touch /fastboot')  # this file is removed automatically
-
-        # Boot it.
-        self.job.start_reboot()
-        self.job.reboot(tag=self.installed_as)
-
-
-class kernel(BootableKernel):
+class kernel(object):
     """ Class for compiling kernels.
 
     Data for the object includes the src files
     used to create the kernel, patches applied, config (base + changes),
     the build directory itself, and logged output
 
     Properties:
             job
                     Backpointer to the job object we're part of
             autodir
@@ skipping 24 matching lines @@
                         3. A local directory (will symlink it)
                         4. A shorthand expandable (eg '2.6.11-git3')
         subdir
                 subdir in the results directory (eg "build")
                 (holds config/, debug/, results/)
         tmp_dir
 
         leave
                 Boolean, whether to leave existing tmpdir or not
         """
-        super(kernel, self).__init__(job)
+        self.job = job
         self.autodir = job.autodir
 
         self.src_dir    = os.path.join(tmp_dir, 'src')
         self.build_dir  = os.path.join(tmp_dir, build_dir)
                 # created by get_kernel_tree
         self.config_dir = os.path.join(subdir, 'config')
         self.log_dir    = os.path.join(subdir, 'debug')
         self.results_dir = os.path.join(subdir, 'results')
         self.subdir     = os.path.basename(subdir)
 
+        self.installed_as = None
+
         if not leave:
             if os.path.isdir(self.src_dir):
                 utils.system('rm -rf ' + self.src_dir)
             if os.path.isdir(self.build_dir):
                 utils.system('rm -rf ' + self.build_dir)
 
         if not os.path.exists(self.src_dir):
             os.mkdir(self.src_dir)
         for path in [self.config_dir, self.log_dir, self.results_dir]:
             if os.path.exists(path):
@@ skipping 308 matching lines @@
         if not kernel_config.modules_needed('.config'):
             return
 
         utils.system('make modules_install INSTALL_MOD_PATH=%s' % prefix)
         if prefix == '/':
             self.initrd = self.boot_dir + '/initrd-' + tag
             self.mkinitrd(self.get_kernel_build_ver(), self.image,
                           self.system_map, self.initrd)
 
 
+    def add_to_bootloader(self, tag='autotest', args=''):
+        """ add this kernel to bootloader, taking an
+            optional parameter of space separated parameters
+            e.g.:  kernel.add_to_bootloader('mykernel', 'ro acpi=off')
+        """
+        _add_kernel_to_bootloader(self.job.bootloader,
+                                  self.job.config_get('boot.default_args'),
+                                  tag, args, self.image, self.initrd)
+
+
     def get_kernel_build_arch(self, arch=None):
         """
         Work out the current kernel architecture (as a kernel arch)
         """
         if not arch:
             arch = utils.get_current_kernel_arch()
         if re.match('i.86', arch):
             return 'i386'
         elif re.match('sun4u', arch):
             return 'sparc64'
@@ skipping 46 matching lines @@
             raise error.JobError('kernel has no identity')
 
         return release + '::' + version
 
 
     def boot(self, args='', ident=True):
         """ install and boot this kernel, do not care how
             just make it happen.
         """
 
-        # If the kernel has not yet been installed,
-        #   install it now as default tag.
+        # If we can check the kernel identity do so.
+        expected_ident = self.get_kernel_build_ident()
+        if ident:
+            when = int(time.time())
+            args += " IDENT=%d" % (when)
+            self.job.next_step_prepend(["job.end_reboot_and_verify", when,
+                                        expected_ident, self.subdir,
+                                        self.applied_patches])
+        else:
+            self.job.next_step_prepend(["job.end_reboot", self.subdir,
+                                        expected_ident, self.applied_patches])
+
+        # Check if the kernel has been installed, if not install
+        # as the default tag and boot that.
         if not self.installed_as:
             self.install()
 
-        expected_ident = self.get_kernel_build_ident()
-        self._boot_kernel(args, ident, expected_ident,
-                          self.subdir, self.applied_patches)
+        # Boot the selected tag.
+        self.add_to_bootloader(args=args, tag=self.installed_as)
+
+        # Boot it.
+        self.job.start_reboot()
+        self.job.reboot(tag=self.installed_as)
 
 
     def get_kernel_build_ver(self):
         """Check Makefile and .config to return kernel version"""
         version = patchlevel = sublevel = extraversion = localversion = ''
 
         for line in open(self.build_dir + '/Makefile', 'r').readlines():
             if line.startswith('VERSION'):
                 version = line[line.index('=') + 1:].strip()
             if line.startswith('PATCHLEVEL'):
@@ skipping 77 matching lines @@
 
         we can't pickle the backreference to job (it contains fd's),
         nor would we want to. Same for logfile (fd's).
         """
         temp = copy.copy(self)
         temp.job = None
         temp.logfile = None
         pickle.dump(temp, open(filename, 'w'))
 
 
-class rpm_kernel(BootableKernel):
+class rpm_kernel(object):
     """
     Class for installing a binary rpm kernel package
     """
 
     def __init__(self, job, rpm_package, subdir):
-        super(rpm_kernel, self).__init__(job)
+        self.job = job
         self.rpm_package = rpm_package
         self.log_dir = os.path.join(subdir, 'debug')
         self.subdir = os.path.basename(subdir)
         if os.path.exists(self.log_dir):
             utils.system('rm -rf ' + self.log_dir)
         os.mkdir(self.log_dir)
+        self.installed_as = None
 
 
     def build(self, *args, **dargs):
         """
         Dummy function, binary kernel so nothing to build.
         """
         pass
 
 
     @log.record
@@ skipping 45 matching lines @@
             for rpm_pack in self.rpm_package:
                 vmlinux = utils.system_output(
                         'rpm -q -l -p %s | grep /boot/vmlinux' % rpm_pack)
             utils.system('cd /; rpm2cpio %s | cpio -imuv .%s 2>&1'
                          % (rpm_pack, vmlinux))
             if not os.path.exists(vmlinux):
                 raise error.TestError('%s does not exist after installing %s'
                                       % (vmlinux, rpm_pack))
 
 
+    def add_to_bootloader(self, tag='autotest', args=''):
+        """ Add this kernel to bootloader
+        """
+        _add_kernel_to_bootloader(self.job.bootloader,
+                                  self.job.config_get('boot.default_args'),
+                                  tag, args, self.image, self.initrd)
+
+
     def boot(self, args='', ident=True):
         """ install and boot this kernel
         """
 
-        # If the kernel has not yet been installed,
-        #   install it now as default tag.
+        # Check if the kernel has been installed, if not install
+        # as the default tag and boot that.
         if not self.installed_as:
             self.install()
 
+        # If we can check the kernel identity do so.
         expected_ident = self.full_version
         if not expected_ident:
             expected_ident = '-'.join([self.version,
                                        self.rpm_flavour,
                                        self.release])
+        if ident:
+            when = int(time.time())
+            args += " IDENT=%d" % (when)
+            self.job.next_step_prepend(["job.end_reboot_and_verify",
+                                        when, expected_ident, None, 'rpm'])
+        else:
+            self.job.next_step_prepend(["job.end_reboot", None,
+                                        expected_ident, []])
 
-        self._boot_kernel(args, ident, expected_ident,
-                          None, 'rpm')
+        # Boot the selected tag.
+        self.add_to_bootloader(args=args, tag=self.installed_as)
+
+        # Boot it.
+        self.job.start_reboot()
+        self.job.reboot(tag=self.installed_as)
 
 
 class rpm_kernel_suse(rpm_kernel):
     """ Class for installing openSUSE/SLE rpm kernel package
     """
 
     def install(self):
         # do not set the new kernel as the default one
         os.environ['PBL_AUTOTEST'] = '1'
 
@@ skipping 62 matching lines @@
                 # kernel from that specific path.
                 job.pkgmgr.fetch_pkg(rpm_name, os.path.join(job.pkgdir, rpm_name),
                                      repo_url=os.path.dirname(kernel_path))
 
                 rpm_paths.append(os.path.join(job.pkgdir, rpm_name))
         return rpm_kernel_vendor(job, rpm_paths, subdir)
     else:
         if len(kernel_paths) > 1:
             raise error.TestError("don't know what to do with more than one non-rpm kernel file")
         return kernel(job,kernel_paths[0], subdir, tmp_dir, build_dir, leave)