def testNotEqual(self):
"""Test that CommandLine equal compare works."""
# Confirm that == is False, and != is True
self.assertFalse(
kernel_cmdline.CommandLine('a b -- d e') ==
kernel_cmdline.CommandLine('a b -- d f'))
self.assertTrue(
kernel_cmdline.CommandLine('a b -- d e') !=
kernel_cmdline.CommandLine('a b -- d f'))
def testDashesOnly(self):
"""Test that '--' behaves as expected."""
expected_kern = []
expected_init = []
cmd = kernel_cmdline.CommandLine('--')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testEmptyArg(self):
"""Test that '' behaves as expected."""
expected_kern = []
expected_init = []
cmd = kernel_cmdline.CommandLine('')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testEmptyKern(self):
"""Test that '-- a' behaves as expected."""
expected_kern = []
expected_init = [kernel_cmdline.KernelArg('a', None)]
cmd = kernel_cmdline.CommandLine('-- a')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testMissingKernB(self):
"""Test the path where KERN-B fails to dump config"""
self.keyset.keys['keyA_kernel_data_key'] = keys.KeyPair(
'keyA_kernel_data_key', self.keytempdir.tempdir)
self.rc.AddCmdResult(partial_mock.InOrder(
['dump_kernel_config', '/dev/loop9999p2']),
output=SAMPLE_KERNEL_CONFIG)
self.rc.AddCmdResult(partial_mock.In('/dev/loop9999p4'), returncode=1)
imagefile.UpdateRootfsHash(self.image,
self.image.GetPartitionDevName('KERN-A'),
self.keyset, 'keyA_')
self.assertEqual(5, self.rc.call_count)
expected_kernel_cmdline = kernel_cmdline.CommandLine(
'console= loglevel=7 init=/sbin/init cros_secure oops=panic panic=-1 '
'root=/dev/dm-0 rootwait ro dm_verity.error_behavior=3 '
'dm_verity.max_bios=-1 dm_verity.dev_wait=1 dm="1 vroot none ro 1,0 '
'800 verity alg=sha1" noinitrd cros_debug vt.global_cursor_default=0 '
'kern_guid=%U add_efi_memmap boot=local noresume noswap '
'i915.modeset=1 tpm_tis.force=1 tpm_tis.interrupts=0 '
'nmi_watchdog=panic,lapic disablevmx=off')
expected_calls = [
mock.call('/dev/loop9999p2', expected_kernel_cmdline,
self.keyset.keys['keyA_kernel_data_key']),
]
self.assertEqual(expected_calls, self.ukc.call_args_list)
def testSimple(self):
self.rc.SetDefaultCmdResult()
loop_kern = '/dev/loop9999p2'
cmd_line = kernel_cmdline.CommandLine(SAMPLE_KERNEL_CONFIG)
key = keys.KeyPair('key', '/keydir')
imagefile._UpdateKernelConfig(loop_kern, cmd_line, key)
self.assertEqual(1, self.rc.call_count)
expected_cmdA = [
'sudo', '--', 'vbutil_kernel', '--repack', loop_kern, '--keyblock',
'/keydir/key.keyblock', '--signprivate', '/keydir/key.vbprivk',
'--version', '1', '--oldblob', '/dev/loop9999p2', '--config',
mock.ANY
]
self.rc.assertCommandCalled(expected_cmdA)
def _GetKernelCmdLine(loop_kern, check=True):
"""Get the kernel commandline for |loop_kern|.
Args:
loop_kern: Device file for the partition to inspect.
check: Whether failure to read the command line is acceptable.
Returns:
CommandLine() containing the kernel config.
"""
config = GetKernelConfig(loop_kern, check)
if config is None:
return None
else:
return kernel_cmdline.CommandLine(config)
def testExpandsDm(self):
"""Test that we do not expand dm="..."."""
expected_kern = [
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('dm', '"1 vroot b=c 1,0 1200"'),
kernel_cmdline.KernelArg('c.d', 'e')
]
expected_init = [
kernel_cmdline.KernelArg('dm', '"not split"'),
kernel_cmdline.KernelArg('a', None)
]
cmd = kernel_cmdline.CommandLine(
'a dm="1 vroot b=c 1,0 1200" c.d=e -- dm="not split" a')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testTempfileDeletedOnDelete(self):
"""Test that the tempfile is deleted only when the object is deleted."""
self.rc.AddCmdResult(partial_mock.In('verity'),
output=SAMPLE_VERITY_OUTPUT)
rootfs_hash = imagefile.CalculateRootfsHash(
self.image, kernel_cmdline.CommandLine(SAMPLE_KERNEL_CONFIG))
# We don't actually care about the return, it's checked elsewhere.
file_name = rootfs_hash.hashtree_filename
self.assertExists(file_name)
# We poke __del__ directly because Python does not guarantee when it will
# be called relative to a del statement. The only thing del guarantees is
# decrementing the object ref counter, not when the GC runs and clears it.
rootfs_hash.__del__()
self.assertNotExists(file_name)
# Call it explicitly for fun. This makes sure the func can be called more
# than once which is how the code is written.
del rootfs_hash
def testSimple(self):
"""Test a simple command line string."""
expected_kern = [
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('b', ''),
kernel_cmdline.KernelArg('c', 'd'),
kernel_cmdline.KernelArg('e.f', 'd'),
kernel_cmdline.KernelArg('a', None)
]
expected_init = [
kernel_cmdline.KernelArg('x', None),
kernel_cmdline.KernelArg('y', ''),
kernel_cmdline.KernelArg('z', 'zz'),
kernel_cmdline.KernelArg('y', None)
]
cmd = kernel_cmdline.CommandLine('a b= c=d e.f=d a -- x y= z=zz y')
self.assertEqual(cmd.kern_args, expected_kern)
self.assertEqual(cmd.init_args, expected_init)
def testNoKernBHash(self):
"""Test no KERN-B hash case."""
self.rc.AddCmdResult(partial_mock.InOrder(
['dump_kernel_config', '/dev/loop9999p2']),
output=SAMPLE_KERNEL_CONFIG)
recovery = keys.KeyPair('recovery', self.keytempdir.tempdir, version=3)
self.keyset.keys['recovery'] = recovery
imagefile.UpdateRecoveryKernelHash(self.image, self.keyset)
self.rc.assertCommandCalled(
['sudo', '--', 'dump_kernel_config', '/dev/loop9999p2'],
capture_output=True,
print_cmd=False,
check=True,
encoding='utf-8')
new_cmdline = SAMPLE_KERNEL_CONFIG.strip()
self.loginfo.assert_called_once_with('New cmdline for kernel A is %s',
new_cmdline)
self.ukc.assert_called_once_with(
'/dev/loop9999p2', kernel_cmdline.CommandLine(new_cmdline),
recovery)
def testSimple(self):
"""Test the simple case for CalculateRootfsHash."""
self.rc.AddCmdResult(partial_mock.In('verity'),
output=SAMPLE_VERITY_OUTPUT)
rootfs_hash = imagefile.CalculateRootfsHash(
self.image, kernel_cmdline.CommandLine(SAMPLE_KERNEL_CONFIG))
expected_rc = [
mock.call([
'sudo', '--', 'verity', 'mode=create', 'alg=sha1',
'payload=/dev/loop9999p3', 'payload_blocks=486400',
'hashtree=%s' % rootfs_hash.hashtree_filename,
'salt=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
'bbbbbbbbbbbbbbb'
],
capture_output=True,
print_cmd=False,
encoding='utf-8')
]
self.assertEqual(expected_rc, self.rc.call_args_list)
self.assertEqual(
kernel_cmdline.DmConfig(
'1 vroot none ro 1,0 3891200 verity '
'payload=PARTUUID=%U/PARTNROFF=1 hashtree=PARTUUID=%U/PARTNROFF=1 '
'hashstart=3891200 alg=sha1 '
'root_hexdigest=9999999999999999999999999999999999999999 salt=bbbbb'
'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'),
rootfs_hash.calculated_dm_config)
self.assertEqual(
'console= loglevel=7 init=/sbin/init cros_secure oops=panic panic=-1 '
'root=/dev/dm-0 rootwait ro dm_verity.error_behavior=3 '
'dm_verity.max_bios=-1 dm_verity.dev_wait=1 dm="1 vroot none ro '
'1,0 3891200 verity payload=PARTUUID=%U/PARTNROFF=1 '
'hashtree=PARTUUID=%U/PARTNROFF=1 hashstart=3891200 alg=sha1 '
'root_hexdigest=9999999999999999999999999999999999999999 '
'salt=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
'bbbb" noinitrd cros_debug vt.global_cursor_default=0 kern_guid=%U '
'add_efi_memmap boot=local noresume noswap i915.modeset=1 '
'tpm_tis.force=1 tpm_tis.interrupts=0 nmi_watchdog=panic,lapic '
'disablevmx=off', rootfs_hash.calculated_kernel_cmdline.Format())
def testSetDmConfig(self):
"""Test that SetDmConfig sets the dm= parameter."""
cmd = kernel_cmdline.CommandLine('a -- b')
cmd.SetDmConfig(kernel_cmdline.DmConfig(DM))
self.assertEqual(kernel_cmdline.KernelArg('dm', DM), cmd.kern_args[1])
def testSetDmConfigAcceptsNone(self):
"""Test that SetDmConfig deletes the dm= parameter when set to None."""
cmd = kernel_cmdline.CommandLine('a dm="0 vroot none 0" -- b')
cmd.SetDmConfig(None)
self.assertEqual(None, cmd.GetDmConfig())
self.assertFalse('dm' in cmd.kern_args)
def testGetDmConfigHandlesMissing(self):
"""Test that GetDmConfig works with no dm= parameter."""
cmd = kernel_cmdline.CommandLine('a b')
self.assertEqual(None, cmd.GetDmConfig())
def testGetDmConfig(self):
"""Test that GetDmConfig returns the DmConfig we expect."""
cmd = kernel_cmdline.CommandLine(CMDLINE)
dm = kernel_cmdline.DmConfig(DM)
self.assertEqual(dm, cmd.GetDmConfig())
def testFormat(self):
"""Test that the output is correct."""
self.assertEqual(CMDLINE, kernel_cmdline.CommandLine(CMDLINE).Format())
def testSetKernelParameter(self):
"""Test SetKernelParameter calls update."""
mock_update = self.PatchObject(kernel_cmdline.KernelArgList, 'update')
cmd = kernel_cmdline.CommandLine('a b c b=3')
cmd.SetKernelParameter('d', 'e')
mock_update.assert_called_once_with({'d': 'e'})
def testGetKernelParameterPassesDefault(self):
"""Test GetKernelParameter calls Get with default=."""
get = self.PatchObject(kernel_cmdline.KernelArgList, 'get')
cmd = kernel_cmdline.CommandLine('a b c b=3')
cmd.GetKernelParameter(1, default=3)
get.assert_called_once_with(1, default=3)
