summaryrefslogtreecommitdiff
path: root/util/gem5img.py
diff options
context:
space:
mode:
Diffstat (limited to 'util/gem5img.py')
-rwxr-xr-xutil/gem5img.py372
1 files changed, 372 insertions, 0 deletions
diff --git a/util/gem5img.py b/util/gem5img.py
new file mode 100755
index 000000000..f02ccb105
--- /dev/null
+++ b/util/gem5img.py
@@ -0,0 +1,372 @@
+#!/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()