launch.py

#!/usr/bin/python

#
# LEGACY SCRIPT -- use run.py instead
#

import sys
import subprocess, os
from subprocess import Popen, call

dnsmasq = None
smbd = None

def hostnet_up():
  # NOTE: if we're going to support spawning multiple vms at the
  # same time, we'd only need to create br0 and tap0 once.  This
  # would imply some sort of tracking mechanism.  But that felt
  # less like simple scripts and more like bloated virt-manager,
  # so it's not happening.
  # oh btw, the taps need to be promiscuous for samba to work.
  global dnsmasq
  global smbd
  #global nmbd
  # setup bridge
  call(['sudo', 'brctl','addbr','br0'])
  call(['sudo', 'ip', 'addr', 'add', '192.168.101.1/24',
	 'broadcast', '192.168.101.255', 'dev', 'br0'])
  call(['sudo', 'ip', 'link', 'set', 'dev', 'br0', 'address',
        '42:48:12:34:56:78'])
  call(['sudo', 'ip', 'link', 'set', 'br0', 'up'])

  # setup host's adapter
  call(['sudo', 'ip', 'tuntap', 'add', 'dev', 'tap0', 'mode', 'tap'])
  call(['sudo', 'ip', 'addr', 'add', '192.168.101.2',
	 'broadcast', '192.168.101.255', 'dev', 'tap0'])
  call(['sudo', 'ip', 'link', 'set', 'tap0', 'up', 'promisc', 'on'])
  call(['sudo', 'brctl', 'addif', 'br0', 'tap0'])

  # setup guest's adapter
  call(['sudo', 'ip', 'tuntap', 'add', 'dev', 'tap1', 'mode', 'tap'])
  call(['sudo', 'ip', 'link', 'set', 'tap1', 'up', 'promisc', 'on'])
  call(['sudo', 'brctl', 'addif', 'br0', 'tap1'])

  # fire up the servers
  dnsmasq = Popen(['sudo', 'dnsmasq', '-k',
                   '--interface=br0', '--bind-interfaces',
		   '--dhcp-range=192.168.101.10,192.168.101.254'])
  smbd = Popen(['sudo', 'smbd', '-i', '-s', 'conf/smb.conf', '--piddir=.'])
  
def hostnet_down():
  # kill daemons politely
  call(['sudo', 'kill', str(-15), str(dnsmasq.pid)])
  call(['sudo', 'kill', str(-15), str(smbd.pid)])

  # remove taps from bridge
  call(['sudo', 'brctl', 'delif', 'br0', 'tap0'])
  call(['sudo', 'brctl', 'delif', 'br0', 'tap1'])

  # delete interfaces
  call(['sudo', 'ip', 'link', 'delete', 'tap1'])
  call(['sudo', 'ip', 'link', 'delete', 'tap0'])
  call(['sudo', 'ip', 'link', 'delete', 'br0'])


qemu_parts = {
  'emu': {
    'enable-kvm': '',
    'ctrl-grab': ''
  },
  'emu-nohead': {
    'display': 'none',
    'enable-kvm': ''
  },
  'cpu1': {
    'cpu': 'host,hv_relaxed,hv_spinlocks=0x1fff,hv_vapic,hv_time'
  },
  'cpu2': {
    'smp': '4,cores=4'
  },
  'memory': {
    'm': '8G'
  },
  'mobo35': {
    'M': 'q35',
#    'bios': '/usr/share/qemu/sgabios.bin'
  },
  'mobopc': {
    'M': 'pc',
#    'bios': '/usr/share/qemu/sgabios.bin',
  },
  'moboisa': {
    'm': '64M',
    'M': 'isapc',
    'bios': '/usr/share/qemu/bios.bin'
  },
  'hostnet': {
    'netdev': 'tap,id=hostnet,ifname=tap1,script=no,downscript=no',
    'net': 'nic,model=virtio,macaddr=52:54:ea:d6:1b:ae,netdev=hostnet'
  },
  'usernet1': {
    'netdev': 'user,id=usernet',
    'net': 'nic,model=e3000,macaddr=52:54:ad:47:98:03,netdev=usernet'
  },
  'usernet2': {
    'netdev': 'user,id=usernet',
    'net': 'nic,model=virtio,macaddr=52:54:ad:47:98:03,netdev=usernet'
  },
  'usb': {
    'usb': '',
    'usbdevice': [
     ]
  },
  'vga1': {
    'vga': 'vmware'
  },
  'vga2': {
    'vga': 'none'
  },
  'vga3': {
    'device': [
      'ioh3420,bus=pcie.0,addr=1c,multifunction=on,port=1,chassis=1,id=root.1',
      'vfio-pci,host=07:00.0,bus=root.1,addr=00.0,multifunction=on,x-vga=on'
    ]
  },
  'vgahack': {
    'device': 'isa-cirrus-vga'
  },
  'audio': {
    'device': [
      'ich9-intel-hda',
      'hda-micro'
    ]
  },
  'drive': {
    'drive': [
    ]
  },
  'splash': {
    'boot': 'menu=on,splash=splash/boot.bmp,splash-time=5000'
  },
  'name': {
    'name': ''
  }
} 

qemu_drives = {
  'ide1': {
    'cdrom': 'ide',
    'disks': 'ide',
    'drive': [
      'if=ide,file=vm/{}/disk.img,media=disk'
    ]
  },
  'ide2': {
    'cdrom': 'ide',
    'disks': 'ide',
    'drive': [
      'if=ide,file=ide,vm/{}/disk.img,media=disk'
      'if=virtio,file=img/temp.qcow2,media=disk'
    ]
  },
  'virtio': {
    'cdrom': 'scsi',
    'disks': 'virtio',
    'drive': [
      'if=virtio,file=vm/{}/disk.img,media=disk'
    ]
  }
}

# note: the weird format is because we need to keep it in order
qemu_model = [
  ['archaic', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'moboisa', 'vga1', 'drive',
	      'splash', 'name' ],
    'drives': 'ide1',
    'desc': 'ISA-only system with no ethernet',
    'purpose': 'To run really ancient systems',
    'memory': '16M'
  }],
  ['basic', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'mobopc', 'vga1', 'usernet1',
	      'usb', 'drive', 'splash', 'name'],
    'drives': 'ide1',
    'desc': 'PCI-based system with 1G of ram and a PIIX chipset',
    'purpose': 'You should install your OS and get your virtio drivers'
      'ready for later systems.',
    'memory': '2G'
  }],
  ['simple', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'mobopc', 'vga1', 'usernet1',
	      'usb', 'drive', 'splash', 'name'],
    'drives': 'ide2',
    'desc': 'As above with a dummy virtio disk',
    'purpose': 'Teach your OS about virtio disks.',
    'memory': '2G'
  }],
  ['virtio', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'mobopc', 'vga1', 'usernet2',
	      'hostnet', 'usb', 'drive', 'splash', 'name'],
    'drives': 'virtio',
    'desc': 'As above with a virtio host-only network and virtio disks',
    'purpose': 'Teach your OS about virtio network adapters and '
      'install synergy.\n Your shared folder is at \\\\192.168.101.2.',
    'pre': hostnet_up,
    'post': hostnet_down,
    'memory': '2G'
  }],
  ['modern', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'mobo35', 'vga1', 'hostnet',
	      'usernet2', 'usb', 'audio', 'drive', 'splash', 'name'],
    'drives': 'virtio',
    'desc': 'q35/virtio system, 8G of ram, host-only networking, and audio',
    'purpose': 'Teach your system about the q35 architechture.\n'
      '		  Meanwhile, single-card users drown in remorse.',
    'pre': hostnet_up,
    'post': hostnet_down,
    'memory': '2G'
  }],
  ['complex', {
    'parts': ['emu', 'cpu1', 'cpu2', 'memory', 'mobo35', 'vga2', 'hostnet',
	      'usernet2', 'usb', 'vgahack', 'vga3', 'audio', 'drive',
	      'splash', 'name'],
    'drives': 'virtio',
    'desc': 'As above with pcie-passthrough',
    'purpose': 'Play some games and blurays from the comfort of X/Wayland\n'
               'Test out distros with realish hardware.',
    'pre': hostnet_up,
    'post': hostnet_down,
    'xrandr': True,
    'memory': '8G'
  }],
  ['nohead', {
    'parts': ['emu-nohead', 'cpu1', 'cpu2', 'memory', 'mobo35', 'vga2',
	       'hostnet', 'usernet2', 'usb', 'vgahack', 'vga3', 'audio',
	       'drive', 'splash', 'name'],
    'drives': 'virtio',
    'desc': 'As above but without a qemu window. You are on your own',
    'purpose': 'Enjoy your fully functional guest operating system.',
    'pre': hostnet_up,
    'post': hostnet_down,
    'xrandr': True,
    'memory': '8G'
  }]
]

qemu_model_drive = {}


    
def build_opts_single(opts):
  out = []
  for o in opts:
    out.append('-'+o);
  return out


def build_opts_multi(opts,fill=''):
  out = []
  for k,v in opts.iteritems():
    if type(v) == str:
      if v:
	out.append('-{} {}'.format(k,v))
      else:
        out.append('-{}'.format(k))
    else:
      for u in v:
	out.append('-{} {}'.format(k,u.format(fill)))
  return out


def qemu_build(name):
  global qemu_model_drive
  model = qemu_model_drive['model']
  out = []
  for part in model['parts']:
    out.extend(build_opts_multi(qemu_parts[part]))
  return out

def check_for_model(make):
  global qemu_model_drive
  qemu_model_dict = dict((k,v) for k,v in qemu_model)
  if make in qemu_model_dict:
    model = qemu_model_dict[make]
    qemu_model_drive = qemu_drives[model['drives']]
    qemu_model_drive['model'] = model
  else:
    print 'We don\'t make that build :('
    exit(1)

def print_usage():
    usage=[
      'No build and name specified.',
      '',
      'Usage:	sudo ' + sys.argv[0] + ' VMNAME MODEL [OPTIONS]',
      '',
      'VMNAME	The directory name where the disk.img is',
      '',
      'MODEL	What sort of devices the vm will see.  Models available are:'
    ]
    for make,model in qemu_model:
      usage.append('\t{}\t  {}'.format(make, model['desc']))
    usage+=[
      '	You will step through these systems, typically from basic to modern.',
      '	(going backwards may harm your system, and is not recommended.)',
      '	Members of the multi-gpu master race can proceed on to nohead.',
      '	Linux vms can start at modern or complex.'
      '',
      'OPTIONS	Further options tweaking the layout of the system.',
      '	cpu:smt   Use two threads per core',
      '	vga:hack  Add a dummy isa vga to kickstart some pcie cards',
      '	m:ram	  Set the amount of ram given to the OS (e.g. m:32G)',
      '	cd:img	  mount image from the _img directory as a cdrom',
      '	dd:img	  mount image from the _img directory as a disk',
      '	cdv:img	  mount image from the vm directory as a cdrom',
      '	ddv:img	  mount image from the vm directory as a disk',
      '	cdg:img	  mount image from the filesystem as a cdrom',
      '	ddg:img	  mount image from the filesystem as a disk',
      '	usb:x:y	  pass usbdevice xxxx:yyyy where available',
      '	c:cores	  Set the number of emulated cores',
      '	barf	  Your vm barfs at acpi tables',
      '',
      'Examples:',
      '\t' + sys.argv[0] + ' archaic dos',
      '\t' + sys.argv[0] + ' virtio winxp barf',
      '\t' + sys.argv[0] + ' modern win7 cpu:smt c:2',
      '\t' + sys.argv[0] + ' complex win7 vga:hack',
      '\t' + sys.argv[0] + ' nohead coinminer',
      ''
    ]
    print '\n'.join(usage)

## TODO: Every arg in this function should come from a conf file
## BUT we should allow manual overrides from the command line
def process_args():
  # check for too few arguments
  if len(sys.argv) < 3:
    print_usage()
    exit(1)

  # parse first two options
  vm_model = sys.argv[1]
  vm_name = sys.argv[2]

  check_for_model(vm_model)

  # parse extra options if any -- these effect parsing of first
  isos = []
  imgs = []
  usbs = []
  vgahack = 0
  cores = 4
  smt = 0
  memory = qemu_model_drive['model']['memory']
  for arg in sys.argv[3:]:
    head,sep,tail = arg.partition(':')
    if tail:
      if arg == 'vga:hack':
	vgahack = 1
      elif arg == 'cpu:fake':
	smt = 1
      elif head == 'm':
	memory = tail
      elif head == 'cd':
	isos.append('_img/'+tail)
      elif head == 'dd':
	imgs.append('_img/'+tail)
      elif head == 'cdv':
	isos.append('{}/{}'.format(vm_name,tail))
      elif head == 'ddv':
	imgs.append('{}/{}'.format(vm_name,tail))
      elif head == 'cdg':
	isos.append(tail)
      elif head == 'ddg':
	imgs.append(tail)
      elif head == 'usb':
	usbs.append(tail)
      elif head == 'c':
	cores = int(tail)
    elif arg == 'barf':
      qemu_parts['emu']['no-acpi'] = ''
  if not vgahack:
    qemu_parts['vgahack'] = {}
  if not smt:
    qemu_parts['cpu2']['smp'] = 'cores={}'.format(cores)
  else:		#inb4 idiots confuse 'hyper'threads with actual cores
    qemu_parts['cpu2']['smp'] = 'cores={},threads=2'.format(cores)
  qemu_parts['memory']['m'] = memory
  
  # build a list of drives for the vm
  drives = qemu_model_drive['drive']
  drives[0] = drives[0].format(vm_name)
  disk_mode = qemu_model_drive['disks']
  cdrom_mode = qemu_model_drive['cdrom']
  for img in imgs:
    if img:
      drives.append('if={},file={},media=disk'.
		    format(disk_mode,img))
  for iso in isos:
    if iso:
      drives.append('if={},file={},media=cdrom'.
		    format(cdrom_mode,iso))

  # build a list usbdevices for the vm
  usbdevices = []
  for usb in usbs:
    if usb:
      usbdevices.append('host:{}'.format(usb))
  
  # add accumulated option detail to the parts list
  qemu_parts['drive']['drive'] = drives
  qemu_parts['usb']['usbdevice'] = usbdevices
  qemu_parts['name']['name'] = vm_name

  # return a freshly baked parameter list
  return qemu_build(vm_name)


# ====================== #
# == MAIN ENTRY POINT == #
# ====================== #

# TODO:
# - convert cmdline params to guest config
# - better integration with caller script

#def do_launch(host_conf, guest):
print 'LEGACY SCRIPT -- use run.py instead\n'

  # check for boot splash -- remove detail entry in parts list if not there
if not os.path.exists('_splash/boot.jpg'):
  qemu_parts['boot'] = {}

# build desired model details
qemu_args = process_args()
model = qemu_model_drive['model']

# perform pre scripts
if 'pre' in model:
  model['pre']()

# setup environment vars
my_env = os.environ
if 'DISPLAY' not in my_env:
  my_env['DISPLAY'] = ':0'	# spoof running X in case we're in a tty
my_env['QEMU_AUDIO_DRV'] = 'alsa'

# turn off the display we're using
# TODO: logic for this should come for a conf file
# I've looked at XLib.ext.randr and it seems very verbose to do
# it in python code
if 'xrandr' in model:
  Popen(['xrandr', '--output', 'DVI-I-1', '--off'],
	env=my_env).wait()

# run the vm
qemu_binary = 'qemu-system-x86_64'
qemu_command = ' '.join([qemu_binary] + qemu_args).split()
print 'Launching:\n\t' + qemu_binary + ' \\\n\t  '.join([""] + qemu_args) + '\n'
# believe it or not, the sudo here is important for getting decent sound
vm = Popen(['sudo'] + qemu_command, env=my_env)
print 'FOR WHAT PURPOSE: ' + model['purpose']
vm.wait()

# turn the display back on
# TODO: Restore xrandr state from save state rather than trying
# to fudge it
if 'xrandr' in model:
  Popen(['xrandr', '--output', 'DVI-I-1', '--auto', '--left-of', 'DVI-I-2'], env=my_env).wait()

# perform post scripts
if 'post' in model:
  model['post']()