| #!/usr/bin/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. | |
| '''A module to provide interface to gpt information. | |
| gpt stands for GUID partition table, it is a data structure describing | |
| partitions present of a storage device. cgpt is a utility which allows to read | |
| and modify gpt. This module parses cgpt output to create a dictionary | |
| including information about all defined partitions including their properties. | |
| It also allows to modify partition properties as required. | |
| ''' | |
| class CgptError(Exception): | |
| pass | |
| class CgptHandler(object): | |
| '''Object representing one or more gpts present in the system. | |
| Attributes: | |
| chros_if: an instance of chromeos_interface, initialized by the caller. | |
| devices: a dictionary keyed by the storage device names (as in | |
| /dev/sda), the contents are dictionaries of cgpt information, | |
| where keys are partiton names, and contents are in turn | |
| dictionaries of partition properties, something like the below | |
| (compressed for brevity): | |
| {'/dev/sda': { | |
| 'OEM': {'partition': 8, 'Type': 'Linux data', 'UUID': 'xxx'}, | |
| 'ROOT-A': {'partition': 3, 'Type': 'ChromeOS rootfs', 'UUID': 'xyz'}, | |
| 'ROOT-C': {'partition': 7, 'Type': 'ChromeOS rootfs', 'UUID': 'xzz'}, | |
| 'ROOT-B': {'partition': 5, 'Type': 'ChromeOS rootfs', 'UUID': 'aaa'}, | |
| ... | |
| } | |
| } | |
| ''' | |
| # This dictionary maps gpt attributes the user can modify into the cgpt | |
| # utility command line options. | |
| ATTR_TO_COMMAND = { | |
| 'priority' : 'P', | |
| 'tries' : 'T', | |
| 'successful' : 'S' | |
| } | |
| def __init__(self, chros_if): | |
| self.chros_if = chros_if | |
| self.devices = {} | |
| def read_device_info(self, dev_name): | |
| '''Get device information from cgpt and parse it into a dictionary. | |
| Inputs: | |
| dev_name: a string the Linux storage device name, (i.e. '/dev/sda') | |
| ''' | |
| device_dump = self.chros_if.run_shell_command_get_output( | |
| 'cgpt show %s' % dev_name) | |
| label = None | |
| label_data = {} | |
| device_data = {} | |
| for line in [x.strip() for x in device_dump]: | |
| if 'Label:' in line: | |
| if label and label not in device_data: | |
| device_data[label] = label_data | |
| _, _, partition, _, label = line.split() | |
| label = line.split('Label:')[1].strip('" ') | |
| label_data = {'partition': int(partition)} | |
| continue | |
| if ':' in line: | |
| name, value = line.strip().split(':') | |
| if name != 'Attr': | |
| label_data[name] = value.strip() | |
| continue | |
| # Attributes are split around '=', each attribute becomes a | |
| # separate partition property. | |
| attrs = value.strip().split() | |
| for attr in attrs: | |
| name, value = attr.split('=') | |
| label_data[name] = int(value) | |
| if label_data: | |
| device_data[label] = label_data | |
| self.devices[dev_name] = device_data | |
| def get_partition(self, device, partition_name): | |
| '''Retrieve a dictionary representing a partition on a device. | |
| Inputs: | |
| device: a string, the Linux device name | |
| partition_name: a string, the partition name as reported by cgpt. | |
| Raises: | |
| CgptError in case the device or partiton on that device are not | |
| known. | |
| ''' | |
| try: | |
| result = self.devices[device][partition_name] | |
| except KeyError: | |
| raise CgptError('could not retrieve partiton %s of device %s' % ( | |
| partition_name, device)) | |
| return result | |
| def dump_partition(self, device, partition_name): | |
| '''Return text describing a partition on a device. | |
| Inputs: | |
| device: a string, the Linux device name | |
| partition_name: a string, the partition name as reported by cgpt. | |
| Returns: | |
| A string, bunch of lines in the form <property>: <value> each, | |
| listing all partition properties as reported by cgpt. | |
| ''' | |
| partition = self.get_partition(device, partition_name) | |
| lines = ['%s: %s' % (x, str(partition[x])) for x in partition] | |
| return '\n'.join(lines) | |
| def set_partition(self, device, partition_name, partition_value): | |
| '''Set partition properties. | |
| Inputs: | |
| device: a string, the Linux device name | |
| partition_name: a string, the partition name as reported by cgpt. | |
| partiton_value: a dictionary, where keys are strings, names of the | |
| properties which need to be modified, and values are the | |
| values to set the properties to. The only properties which | |
| can be modified are those which are keys of ATTR_TO_COMMAND | |
| defined above. | |
| Raises: | |
| CgptError in case a property name is not known or not supposed to | |
| be modified. | |
| ''' | |
| current = self.get_partition(device, partition_name) | |
| options = [] | |
| for prop, value in partition_value.iteritems(): | |
| try: | |
| if value == current[prop]: | |
| continue | |
| options.append('-%s %d' % ( | |
| self.ATTR_TO_COMMAND[prop], value)) | |
| except KeyError: | |
| raise CgptError("unknown or immutable property '%s'" % prop) | |
| if not options: | |
| return | |
| command = 'cgpt add -i %d %s %s' % ( | |
| current['partition'], ' '.join(options), device) | |
| self.chros_if.run_shell_command(command) |