tools/ew.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2013 Jakub Jermar
   4 # All rights reserved.
   5 #
   6 # Redistribution and use in source and binary forms, with or without
   7 # modification, are permitted provided that the following conditions
   8 # are met:
   9 #
  10 # - Redistributions of source code must retain the above copyright
  11 #   notice, this list of conditions and the following disclaimer.
  12 # - Redistributions in binary form must reproduce the above copyright
  13 #   notice, this list of conditions and the following disclaimer in the
  14 #   documentation and/or other materials provided with the distribution.
  15 # - The name of the author may not be used to endorse or promote products
  16 #   derived from this software without specific prior written permission.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 #
  29
  30
  31 """
  32 Emulator wrapper for running HelenOS
  33 """
  34
  35 import os
  36 import sys
  37 import subprocess
  38 import autotool
  39 import platform
  40 import thread
  41 import time
  42
  43 overrides = {}
  44
  45 def is_override(str):
  46         if str in overrides.keys():
  47                 return overrides[str]
  48         return False
  49
  50 def cfg_get(platform, machine, processor):
  51         if machine == "" or emulators[platform].has_key("run"):
  52                 return emulators[platform]
  53         elif processor == "" or emulators[platform][machine].has_key("run"):
  54                 return emulators[platform][machine]
  55         else:
  56                 return emulators[platform][machine][processor]
  57
  58 def run_in_console(cmd, title):
  59         cmdline = 'xterm -T ' + '"' + title + '"' + ' -e ' + cmd
  60         print(cmdline)
  61         if not is_override('dryrun'):
  62                 subprocess.call(cmdline, shell = True);
  63
  64 def get_host_native_width():
  65         return int(platform.architecture()[0].strip('bit'))
  66
  67 def pc_options(guest_width):
  68         opts = ''
  69
  70         # Do not enable KVM if running 64 bits HelenOS
  71         # on 32 bits host
  72         host_width = get_host_native_width()
  73         if guest_width <= host_width and not is_override('nokvm'):
  74                 opts = opts + ' -enable-kvm'
  75
  76         # Remove the leading space
  77         return opts[1:]
  78
  79 def malta_options():
  80         return '-cpu 4Kc'
  81
  82 def platform_to_qemu_options(platform, machine, processor):
  83         if platform == 'amd64':
  84                 return 'system-x86_64', pc_options(64)
  85         elif platform == 'arm32':
  86                 return 'system-arm', '-M integratorcp'
  87         elif platform == 'ia32':
  88                 return 'system-i386', pc_options(32)
  89         elif platform == 'mips32':
  90                 if machine == 'lmalta':
  91                         return 'system-mipsel', malta_options()
  92                 elif machine == 'bmalta':
  93                         return 'system-mips', malta_options()
  94         elif platform == 'ppc32':
  95                 return 'system-ppc', '-m 256'
  96         elif platform == 'sparc64':
  97                 if machine != 'generic':
  98                         raise Exception
  99                 if processor == 'us':
 100                         return 'system-sparc64', '-M sun4u --prom-env boot-args="console=devices/\\hw\\pci0\\00:03.0\\com1\\a"'
 101                 elif processor == 'sun4v':
 102                         default_path = '/usr/local/opensparc/image/'
 103                 try:
 104                         if os.path.exists(default_path):
 105                                 opensparc_bins = default_path
 106                         elif os.path.exists(os.environ['OPENSPARC_BINARIES']):
 107                                 opensparc_bins = os.environ['OPENSPARC_BINARIES']
 108                         else:
 109                                 raise Exception
 110                 except:
 111                         print("Cannot find OpenSPARC binary images!")
 112                         print("Either set OPENSPARC_BINARIES environment variable accordingly or place the images in %s." % (default_path))
 113                         raise Exception
 114
 115                 return 'system-sparc64', '-M niagara -m 256 -L %s' % (opensparc_bins)
 116
 117
 118 def hdisk_mk():
 119         if not os.path.exists('hdisk.img'):
 120                 subprocess.call('tools/mkfat.py 1048576 uspace/dist/data hdisk.img', shell = True)
 121
 122 def qemu_bd_options():
 123         if is_override('nohdd'):
 124                 return ''
 125
 126         hdisk_mk()
 127
 128         return ' -drive file=hdisk.img,index=0,media=disk,format=raw'
 129
 130 def qemu_nic_ne2k_options():
 131         return ' -device ne2k_isa,irq=5,vlan=0'
 132
 133 def qemu_nic_e1k_options():
 134         return ' -device e1000,vlan=0'
 135
 136 def qemu_nic_rtl8139_options():
 137         return ' -device rtl8139,vlan=0'
 138
 139 def qemu_net_options():
 140         if is_override('nonet'):
 141                 return ''
 142
 143         nic_options = ''
 144         if 'net' in overrides.keys():
 145                 if 'e1k' in overrides['net'].keys():
 146                         nic_options += qemu_nic_e1k_options()
 147                 if 'rtl8139' in overrides['net'].keys():
 148                         nic_options += qemu_nic_rtl8139_options()
 149                 if 'ne2k' in overrides['net'].keys():
 150                         nic_options += qemu_nic_ne2k_options()
 151         else:
 152                 # Use the default NIC
 153                 nic_options += qemu_nic_e1k_options()
 154
 155         return nic_options + ' -net user,hostfwd=udp::8080-:8080,hostfwd=udp::8081-:8081,hostfwd=tcp::8080-:8080,hostfwd=tcp::8081-:8081,hostfwd=tcp::2223-:2223'
 156
 157 def qemu_usb_options():
 158         if is_override('nousb'):
 159                 return ''
 160         return ' -usb'
 161
 162 def qemu_audio_options():
 163         if is_override('nosnd'):
 164                 return ''
 165         return ' -device intel-hda -device hda-duplex'
 166
 167 def qemu_run(platform, machine, processor):
 168         cfg = cfg_get(platform, machine, processor)
 169         suffix, options = platform_to_qemu_options(platform, machine, processor)
 170         cmd = 'qemu-' + suffix
 171
 172         cmdline = cmd
 173         if options != '':
 174                 cmdline += ' ' + options
 175
 176         cmdline += qemu_bd_options()
 177
 178         if (not 'net' in cfg.keys()) or cfg['net']:
 179                 cmdline += qemu_net_options()
 180         if (not 'usb' in cfg.keys()) or cfg['usb']:
 181                 cmdline += qemu_usb_options()
 182         if (not 'audio' in cfg.keys()) or cfg['audio']:
 183                 cmdline += qemu_audio_options()
 184
 185         if cfg['image'] == 'image.iso':
 186                 cmdline += ' -boot d -cdrom image.iso'
 187         elif cfg['image'] == 'image.boot':
 188                 cmdline += ' -kernel image.boot'
 189         else:
 190                 cmdline += ' ' + cfg['image']
 191
 192         if ('console' in cfg.keys()) and not cfg['console']:
 193                 cmdline += ' -nographic'
 194
 195                 title = 'HelenOS/' + platform
 196                 if machine != '':
 197                         title += ' on ' + machine
 198                 if 'expect' in cfg.keys():
 199                         cmdline = 'expect -c \'spawn %s; expect "%s" { send "%s" } timeout exp_continue; interact\'' % (cmdline, cfg['expect']['src'], cfg['expect']['dst'])
 200                 run_in_console(cmdline, title)
 201         else:
 202                 print(cmdline)
 203                 if not is_override('dryrun'):
 204                         subprocess.call(cmdline, shell = True)
 205
 206 def ski_run(platform, machine, processor):
 207         run_in_console('ski -i contrib/conf/ski.conf', 'HelenOS/ia64 on ski')
 208
 209 def msim_run(platform, machine, processor):
 210         hdisk_mk()
 211         run_in_console('msim -c contrib/conf/msim.conf', 'HelenOS/mips32 on msim')
 212
 213 def spike_run(platform, machine, processor):
 214         run_in_console('spike image.boot', 'HelenOS/risvc64 on Spike')
 215
 216 emulators = {
 217         'amd64' : {
 218                 'run' : qemu_run,
 219                 'image' : 'image.iso'
 220         },
 221         'arm32' : {
 222                 'integratorcp' : {
 223                         'run' : qemu_run,
 224                         'image' : 'image.boot',
 225                         'net' : False,
 226                         'audio' : False
 227                 }
 228         },
 229         'ia32' : {
 230                 'run' : qemu_run,
 231                 'image' : 'image.iso'
 232         },
 233         'ia64' : {
 234                 'ski' : {
 235                         'run' : ski_run
 236                 }
 237         },
 238         'mips32' : {
 239                 'msim' : {
 240                         'run' : msim_run
 241                 },
 242                 'lmalta' : {
 243                         'run' : qemu_run,
 244                         'image' : 'image.boot',
 245                         'console' : False
 246                 },
 247                 'bmalta' : {
 248                         'run' : qemu_run,
 249                         'image' : 'image.boot',
 250                         'console' : False
 251                 },
 252         },
 253         'ppc32' : {
 254                 'run' : qemu_run,
 255                 'image' : 'image.iso',
 256                 'audio' : False
 257         },
 258         'riscv64' : {
 259                 'run' : spike_run,
 260                 'image' : 'image.boot'
 261         },
 262         'sparc64' : {
 263                 'generic' : {
 264                         'us' : {
 265                                 'run' : qemu_run,
 266                                 'image' : 'image.iso',
 267                                 'audio' : False,
 268                                 'console' : False,
 269                         },
 270                         'sun4v' : {
 271                                 'run' : qemu_run,
 272                                 'image' : '-drive if=pflash,readonly=on,file=image.iso',
 273                                 'audio' : False,
 274                                 'console' : False,
 275                                 'net' : False,
 276                                 'usb' : False,
 277                                 'expect' : {
 278                                         'src' : 'ok ',
 279                                         'dst' : 'boot\n'
 280                                 },
 281                         }
 282                 }
 283         },
 284 }
 285
 286 def usage():
 287         print("%s - emulator wrapper for running HelenOS\n" % os.path.basename(sys.argv[0]))
 288         print("%s [-d] [-h] [-net e1k|rtl8139|ne2k] [-nohdd] [-nokvm] [-nonet] [-nosnd] [-nousb]\n" %
 289             os.path.basename(sys.argv[0]))
 290         print("-d\tDry run: do not run the emulation, just print the command line.")
 291         print("-h\tPrint the usage information and exit.")
 292         print("-nohdd\tDisable hard disk, if applicable.")
 293         print("-nokvm\tDisable KVM, if applicable.")
 294         print("-nonet\tDisable networking support, if applicable.")
 295         print("-nosnd\tDisable sound, if applicable.")
 296         print("-nousb\tDisable USB support, if applicable.")
 297
 298 def fail(platform, machine):
 299         print("Cannot start emulation for the chosen configuration. (%s/%s)" % (platform, machine))
 300
 301
 302 def run():
 303         expect_nic = False
 304
 305         for i in range(1, len(sys.argv)):
 306
 307                 if expect_nic:
 308                         expect_nic = False
 309                         if not 'net' in overrides.keys():
 310                                 overrides['net'] = {}
 311                         if sys.argv[i] == 'e1k':
 312                                 overrides['net']['e1k'] = True
 313                         elif sys.argv[i] == 'rtl8139':
 314                                 overrides['net']['rtl8139'] = True
 315                         elif sys.argv[i] == 'ne2k':
 316                                 overrides['net']['ne2k'] = True
 317                         else:
 318                                 usage()
 319                                 exit()
 320
 321                 elif sys.argv[i] == '-h':
 322                         usage()
 323                         exit()
 324                 elif sys.argv[i] == '-d':
 325                         overrides['dryrun'] = True
 326                 elif sys.argv[i] == '-net' and i < len(sys.argv) - 1:
 327                         expect_nic = True
 328                 elif sys.argv[i] == '-nohdd':
 329                         overrides['nohdd'] = True
 330                 elif sys.argv[i] == '-nokvm':
 331                         overrides['nokvm'] = True
 332                 elif sys.argv[i] == '-nonet':
 333                         overrides['nonet'] = True
 334                 elif sys.argv[i] == '-nosnd':
 335                         overrides['nosnd'] = True
 336                 elif sys.argv[i] == '-nousb':
 337                         overrides['nousb'] = True
 338                 else:
 339                         usage()
 340                         exit()
 341
 342         config = {}
 343         autotool.read_config(autotool.CONFIG, config)
 344
 345         if 'PLATFORM' in config.keys():
 346                 platform = config['PLATFORM']
 347         else:
 348                 platform = ''
 349
 350         if 'MACHINE' in config.keys():
 351                 mach = config['MACHINE']
 352         else:
 353                 mach = ''
 354
 355         if 'PROCESSOR' in config.keys():
 356                 processor = config['PROCESSOR']
 357         else:
 358                 processor = ''
 359
 360         try:
 361                 emu_run = cfg_get(platform, mach, processor)['run']
 362                 emu_run(platform, mach, processor)
 363         except:
 364                 fail(platform, mach)
 365                 return
 366
 367 run()