| #!/usr/bin/python |
| # |
| # gem5img.py |
| # Script for managing a gem5 disk image. |
| # |
| |
| from optparse import OptionParser |
| import os |
| from os import environ as env |
| import string |
| from subprocess import CalledProcessError, Popen, PIPE, STDOUT |
| from sys import exit, argv |
| |
| |
| # Some constants. |
| MaxLBACylinders = 16383 |
| MaxLBAHeads = 16 |
| MaxLBASectors = 63 |
| MaxLBABlocks = MaxLBACylinders * MaxLBAHeads * MaxLBASectors |
| |
| BlockSize = 512 |
| MB = 1024 * 1024 |
| |
| # Setup PATH to look in the sbins. |
| env['PATH'] += ':/sbin:/usr/sbin' |
| |
| # Whether to print debug output. |
| debug = False |
| |
| # Figure out cylinders, heads and sectors from a size in blocks. |
| def chsFromSize(sizeInBlocks): |
| if sizeInBlocks >= MaxLBABlocks: |
| sizeInMBs = (sizeInBlocks * BlockSize) / MB |
| print '%d MB is too big for LBA, truncating file.' % sizeInMBs |
| return (MaxLBACylinders, MaxLBAHeads, MaxLBASectors) |
| |
| sectors = sizeInBlocks |
| if sizeInBlocks > 63: |
| sectors = 63 |
| |
| headSize = sizeInBlocks / sectors |
| heads = 16 |
| if headSize < 16: |
| heads = sizeInBlocks |
| |
| cylinders = sizeInBlocks / (sectors * heads) |
| |
| return (cylinders, heads, sectors) |
| |
| |
| # Figure out if we should use sudo. |
| def needSudo(): |
| if not hasattr(needSudo, 'notRoot'): |
| needSudo.notRoot = (os.geteuid() != 0) |
| if needSudo.notRoot: |
| print 'You are not root. Using sudo.' |
| return needSudo.notRoot |
| |
| # Run an external command. |
| def runCommand(command, inputVal=''): |
| print "%>", ' '.join(command) |
| proc = Popen(command, stdin=PIPE) |
| proc.communicate(inputVal) |
| return proc.returncode |
| |
| # Run an external command and capture its output. This is intended to be |
| # used with non-interactive commands where the output is for internal use. |
| def getOutput(command, inputVal=''): |
| global debug |
| if debug: |
| print "%>", ' '.join(command) |
| proc = Popen(command, stderr=STDOUT, |
| stdin=PIPE, stdout=PIPE) |
| (out, err) = proc.communicate(inputVal) |
| return (out, proc.returncode) |
| |
| # Run a command as root, using sudo if necessary. |
| def runPriv(command, inputVal=''): |
| realCommand = command |
| if needSudo(): |
| realCommand = [findProg('sudo')] + command |
| return runCommand(realCommand, inputVal) |
| |
| def privOutput(command, inputVal=''): |
| realCommand = command |
| if needSudo(): |
| realCommand = [findProg('sudo')] + command |
| return getOutput(realCommand, inputVal) |
| |
| # Find the path to a program. |
| def findProg(program, cleanupDev=None): |
| (out, returncode) = getOutput(['which', program]) |
| if returncode != 0: |
| if cleanupDev: |
| cleanupDev.destroy() |
| exit("Unable to find program %s, check your PATH variable." % program) |
| return string.strip(out) |
| |
| class LoopbackDevice(object): |
| def __init__(self, devFile=None): |
| self.devFile = devFile |
| def __str__(self): |
| return str(self.devFile) |
| |
| def setup(self, fileName, offset=False): |
| assert not self.devFile |
| (out, returncode) = privOutput([findProg('losetup'), '-f']) |
| if returncode != 0: |
| print out |
| return returncode |
| self.devFile = string.strip(out) |
| command = [findProg('losetup'), self.devFile, fileName] |
| if offset: |
| off = findPartOffset(self.devFile, fileName, 0) |
| command = command[:1] + \ |
| ["-o", "%d" % off] + \ |
| command[1:] |
| return runPriv(command) |
| |
| def destroy(self): |
| assert self.devFile |
| returncode = runPriv([findProg('losetup'), '-d', self.devFile]) |
| self.devFile = None |
| return returncode |
| |
| def findPartOffset(devFile, fileName, partition): |
| # Attach a loopback device to the file so we can use sfdisk on it. |
| dev = LoopbackDevice() |
| dev.setup(fileName) |
| # Dump the partition information. |
| command = [findProg('sfdisk'), '-d', dev.devFile] |
| (out, returncode) = privOutput(command) |
| if returncode != 0: |
| print out |
| exit(returncode) |
| lines = out.splitlines() |
| # Make sure the first few lines of the output look like what we expect. |
| assert(lines[0][0] == '#') |
| assert(lines[1] == 'unit: sectors') |
| assert(lines[2] == '') |
| # This line has information about the first partition. |
| chunks = lines[3].split() |
| # The fourth chunk is the offset of the partition in sectors followed by |
| # a comma. We drop the comma and convert that to an integer. |
| sectors = string.atoi(chunks[3][:-1]) |
| # Free the loopback device and return an answer. |
| dev.destroy() |
| return sectors * BlockSize |
| |
| def mountPointToDev(mountPoint): |
| (mountTable, returncode) = getOutput([findProg('mount')]) |
| if returncode != 0: |
| print mountTable |
| exit(returncode) |
| mountTable = mountTable.splitlines() |
| for line in mountTable: |
| chunks = line.split() |
| if os.path.samefile(chunks[2], mountPoint): |
| return LoopbackDevice(chunks[0]) |
| return None |
| |
| |
| # Commands for the gem5img.py script |
| commands = {} |
| commandOrder = [] |
| |
| class Command(object): |
| def addOption(self, *args, **kargs): |
| self.parser.add_option(*args, **kargs) |
| |
| def __init__(self, name, description, posArgs): |
| self.name = name |
| self.description = description |
| self.func = None |
| self.posArgs = posArgs |
| commands[self.name] = self |
| commandOrder.append(self.name) |
| usage = 'usage: %prog [options]' |
| posUsage = '' |
| for posArg in posArgs: |
| (argName, argDesc) = posArg |
| usage += ' %s' % argName |
| posUsage += '\n %s: %s' % posArg |
| usage += posUsage |
| self.parser = OptionParser(usage=usage, description=description) |
| self.addOption('-d', '--debug', dest='debug', action='store_true', |
| help='Verbose output.') |
| |
| def parseArgs(self, argv): |
| (self.options, self.args) = self.parser.parse_args(argv[2:]) |
| if len(self.args) != len(self.posArgs): |
| self.parser.error('Incorrect number of arguments') |
| global debug |
| if self.options.debug: |
| debug = True |
| |
| def runCom(self): |
| if not self.func: |
| exit('Unimplemented command %s!' % self.name) |
| self.func(self.options, self.args) |
| |
| |
| # A command which prepares an image with an partition table and an empty file |
| # system. |
| initCom = Command('init', 'Create an image with an empty file system.', |
| [('file', 'Name of the image file.'), |
| ('mb', 'Size of the file in MB.')]) |
| initCom.addOption('-t', '--type', dest='fstype', action='store', |
| default='ext2', |
| help='Type of file system to use. Appended to mkfs.') |
| |
| # A command to mount the first partition in the image. |
| mountCom = Command('mount', 'Mount the first partition in the disk image.', |
| [('file', 'Name of the image file.'), |
| ('mount point', 'Where to mount the image.')]) |
| |
| def mountComFunc(options, args): |
| (path, mountPoint) = args |
| if not os.path.isdir(mountPoint): |
| print "Mount point %s is not a directory." % mountPoint |
| |
| dev = LoopbackDevice() |
| if dev.setup(path, offset=True) != 0: |
| exit(1) |
| |
| if runPriv([findProg('mount'), str(dev), mountPoint]) != 0: |
| dev.destroy() |
| exit(1) |
| |
| mountCom.func = mountComFunc |
| |
| # A command to unmount the first partition in the image. |
| umountCom = Command('umount', 'Unmount the first partition in the disk image.', |
| [('mount point', 'What mount point to unmount.')]) |
| |
| def umountComFunc(options, args): |
| (mountPoint,) = args |
| if not os.path.isdir(mountPoint): |
| print "Mount point %s is not a directory." % mountPoint |
| exit(1) |
| |
| dev = mountPointToDev(mountPoint) |
| if not dev: |
| print "Unable to find mount information for %s." % mountPoint |
| |
| # Unmount the loopback device. |
| if runPriv([findProg('umount'), mountPoint]) != 0: |
| exit(1) |
| |
| # Destroy the loopback device. |
| dev.destroy() |
| |
| umountCom.func = umountComFunc |
| |
| |
| # A command to create an empty file to hold the image. |
| newCom = Command('new', 'File creation part of "init".', |
| [('file', 'Name of the image file.'), |
| ('mb', 'Size of the file in MB.')]) |
| |
| def newImage(file, mb): |
| (cylinders, heads, sectors) = chsFromSize((mb * MB) / BlockSize) |
| size = cylinders * heads * sectors * BlockSize |
| |
| # We lseek to the end of the file and only write one byte there. This |
| # leaves a "hole" which many file systems are smart enough not to actually |
| # store to disk and which is defined to read as zero. |
| fd = os.open(file, os.O_WRONLY | os.O_CREAT) |
| os.lseek(fd, size - 1, os.SEEK_SET) |
| os.write(fd, '\0') |
| |
| def newComFunc(options, args): |
| (file, mb) = args |
| mb = string.atoi(mb) |
| newImage(file, mb) |
| |
| |
| newCom.func = newComFunc |
| |
| # A command to partition the image file like a raw disk device. |
| partitionCom = Command('partition', 'Partition part of "init".', |
| [('file', 'Name of the image file.')]) |
| |
| def partition(dev, cylinders, heads, sectors): |
| # Use fdisk to partition the device |
| comStr = '0,\n;\n;\n;\n' |
| return runPriv([findProg('sfdisk'), '--no-reread', '-D', \ |
| '-C', "%d" % cylinders, \ |
| '-H', "%d" % heads, \ |
| '-S', "%d" % sectors, \ |
| str(dev)], inputVal=comStr) |
| |
| def partitionComFunc(options, args): |
| (path,) = args |
| |
| dev = LoopbackDevice() |
| if dev.setup(path) != 0: |
| exit(1) |
| |
| # Figure out the dimensions of the file. |
| size = os.path.getsize(path) |
| if partition(dev, *chsFromSize(size / BlockSize)) != 0: |
| dev.destroy() |
| exit(1) |
| |
| dev.destroy() |
| |
| partitionCom.func = partitionComFunc |
| |
| # A command to format the first partition in the image. |
| formatCom = Command('format', 'Formatting part of "init".', |
| [('file', 'Name of the image file.')]) |
| formatCom.addOption('-t', '--type', dest='fstype', action='store', |
| default='ext2', |
| help='Type of file system to use. Appended to mkfs.') |
| |
| def formatImage(dev, fsType): |
| return runPriv([findProg('mkfs.%s' % fsType, dev), str(dev)]) |
| |
| def formatComFunc(options, args): |
| (path,) = args |
| |
| dev = LoopbackDevice() |
| if dev.setup(path, offset=True) != 0: |
| exit(1) |
| |
| # Format the device. |
| if formatImage(dev, options.fstype) != 0: |
| dev.destroy() |
| exit(1) |
| |
| dev.destroy() |
| |
| formatCom.func = formatComFunc |
| |
| def initComFunc(options, args): |
| (path, mb) = args |
| mb = string.atoi(mb) |
| newImage(path, mb) |
| dev = LoopbackDevice() |
| if dev.setup(path) != 0: |
| exit(1) |
| size = os.path.getsize(path) |
| if partition(dev, *chsFromSize((mb * MB) / BlockSize)) != 0: |
| dev.destroy() |
| exit(1) |
| dev.destroy() |
| if dev.setup(path, offset=True) != 0: |
| exit(1) |
| if formatImage(dev, options.fstype) != 0: |
| dev.destroy() |
| exit(1) |
| dev.destroy() |
| |
| initCom.func = initComFunc |
| |
| |
| # Figure out what command was requested and execute it. |
| if len(argv) < 2 or argv[1] not in commands: |
| print 'Usage: %s [command] <command arguments>' |
| print 'where [command] is one of ' |
| for name in commandOrder: |
| command = commands[name] |
| print ' %s: %s' % (command.name, command.description) |
| print 'Watch for orphaned loopback devices and delete them with' |
| print 'losetup -d. Mounted images will belong to root, so you may need' |
| print 'to use sudo to modify their contents.' |
| exit(1) |
| |
| command = commands[argv[1]] |
| command.parseArgs(argv) |
| command.runCom() |
