Merge remote branch 'cros/upstream' into tempbranch

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 41 matching lines @@
     for arg in args.split():
         if arg.startswith(root_prefix):
             # set the current root value with the one from the argument
             # thus after processing all the arguments we keep the last
             # root value (so root= options from args overrides any from
             # 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)
+    # Add the kernel entry. it will keep all arguments from the default entry.
+    # args='_dummy_' is used to workaround a boottool limitation of not being
+    # able to add arguments to a kernel that does not already have any of its
+    # own by way of its own append= section below the image= line in lilo.conf.
+    bootloader.add_kernel(image, tag, initrd=initrd, root=root, args='_dummy_')
+    # Now, for each argument in arglist, try to add it to the kernel that was
+    # just added. In each step, if the arg already existed on the args string,
+    # that particular arg will be skipped
+    for a in arglist:
+        bootloader.add_args(kernel=tag, args=a)
+    bootloader.remove_args(kernel=tag, args='_dummy_')
 
 
 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)
+        self.add_to_bootloader(args)
 
         # 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)
 
 
+    def add_to_bootloader(self, args=''):
+        # 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)
+
+
 class kernel(BootableKernel):
     """ 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
@@ skipping 179 matching lines @@
             self.logfile.write(log)
             self.applied_patches.append(patch_id)
 
 
     def get_kernel_tree(self, base_tree):
         """Extract/link base_tree to self.build_dir"""
 
         # if base_tree is a dir, assume uncompressed kernel
         if os.path.isdir(base_tree):
             print 'Symlinking existing kernel source'
+            if os.path.islink(self.build_dir):
+                os.remove(self.build_dir)
             os.symlink(base_tree, self.build_dir)
 
         # otherwise, extract tarball
         else:
             os.chdir(os.path.dirname(self.src_dir))
             # Figure out local destination for tarball
             tarball = os.path.join(self.src_dir, os.path.basename(base_tree.split(';')[0]))
             utils.get_file(base_tree, tarball)
             print 'Extracting kernel tarball:', tarball, '...'
             utils.extract_tarball_to_dir(tarball, self.build_dir)
@@ skipping 45 matching lines @@
         utils.force_copy(self.build_dir+'/System.map',
                                   self.results_dir)
 
 
     def build_timed(self, threads, timefile = '/dev/null', make_opts = '',
                                                     output = '/dev/null'):
         """time the bulding of the kernel"""
         os.chdir(self.build_dir)
         self.set_cross_cc()
 
-        self.clean(logged=False)
+        self.clean()
         build_string = "/usr/bin/time -o %s make %s -j %s vmlinux" \
                                         % (timefile, make_opts, threads)
         build_string += ' > %s 2>&1' % output
         print build_string
         utils.system(build_string)
 
         if (not os.path.isfile('vmlinux')):
             errmsg = "no vmlinux found, kernel build failed"
             raise error.TestError(errmsg)
 
@@ skipping 27 matching lines @@
         if os.path.isfile(initrd):
             print "Existing %s file, will remove it." % initrd
             os.remove(initrd)
 
         args = self.job.config_get('kernel.mkinitrd_extra_args')
 
         # don't leak 'None' into mkinitrd command
         if not args:
             args = ''
 
+        # It is important to match the version with a real directory inside
+        # /lib/modules
+        real_version_list = glob.glob('/lib/modules/%s*' % version)
+        rl = len(real_version_list)
+        if rl == 0:
+            logging.error("No directory %s found under /lib/modules. Initramfs"
+                          "creation will most likely fail and your new kernel"
+                          "will fail to build", version)
+        else:
+            if rl > 1:
+                logging.warning("Found more than one possible match for "
+                                "kernel version %s under /lib/modules", version)
+            version = os.path.basename(real_version_list[0])
+
         if vendor in ['Red Hat', 'Fedora Core']:
-            utils.system('mkinitrd %s %s %s' % (args, initrd, version))
+            try:
+                cmd = os_dep.command('dracut')
+                full_cmd = '%s -f %s %s' % (cmd, initrd, version)
+            except ValueError:
+                cmd = os_dep.command('mkinitrd')
+                full_cmd = '%s %s %s %s' % (cmd, args, initrd, version)
+            utils.system(full_cmd)
         elif vendor in ['SUSE']:
             utils.system('mkinitrd %s -k %s -i %s -M %s' %
                          (args, image, initrd, system_map))
         elif vendor in ['Debian', 'Ubuntu']:
             if os.path.isfile('/usr/sbin/mkinitrd'):
                 cmd = '/usr/sbin/mkinitrd'
             elif os.path.isfile('/usr/sbin/mkinitramfs'):
                 cmd = '/usr/sbin/mkinitramfs'
             else:
                 raise error.TestError('No Debian initrd builder')
@@ skipping 277 matching lines @@
                     self.version, self.release = utils.system_output(
                             'rpm --queryformat="%{VERSION}\\n%{RELEASE}\\n" -q '
                             + rpm_name).splitlines()[0:2]
 
                     # prefer /boot/kernel-version before /boot/kernel
                     if self.full_version:
                         break
 
             # search for initrd
             for file in files:
-                if file.startswith('/boot/initrd'):
+                if file.startswith('/boot/init'):
                     self.initrd = file
                     # prefer /boot/initrd-version before /boot/initrd
                     if len(file) > len('/boot/initrd'):
                         break
 
         if self.image == None:
             errmsg = "specified rpm file(s) don't contain /boot/vmlinuz"
             raise error.TestError(errmsg)
 
         # install vmlinux
@@ skipping 100 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)