# HG changeset patch
# User kaf24@xxxxxxxxxxxxxxxxxxxx
# Node ID 356b14d5ffc88ae30c48c139070fd1f993190cd7
# Parent 2379e795ca69a7b855d3a7456dc69f12bd817ef9
# Parent 4125b9fea242e8752036324b0257adbd464b0b6b
merge
diff -r 2379e795ca69 -r 356b14d5ffc8 tools/python/xen/xm/main.py
--- a/tools/python/xen/xm/main.py Tue Aug 9 13:04:31 2005
+++ b/tools/python/xen/xm/main.py Tue Aug 9 13:04:54 2005
@@ -1,28 +1,113 @@
-# Copyright (C) 2004 Mike Wray <mike.wray@xxxxxx>
+# (C) Copyright IBM Corp. 2005
+# Copyright (C) 2004 Mike Wray
+#
+# Authors:
+# Sean Dague <sean at dague dot net>
+# Mike Wray <mike dot wray at hp dot com>
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License v2. Full details on license
+# terms and conditions are included with this distribution
+
"""Grand unified management application for Xen.
"""
import os
import os.path
import sys
import commands
+import re
from getopt import getopt
import socket
import warnings
warnings.filterwarnings('ignore', category=FutureWarning)
-
from xen.xend import PrettyPrint
from xen.xend import sxp
-# this is a nasty place to stick this in, but required because
-# log file access is set up via a 5 deep import chain. This
-# ensures the user sees a useful message instead of a stack trace
-if os.getuid() != 0:
- print "xm requires root access to execute, please try again as root"
- sys.exit(1)
-
-from xen.xend.XendClient import XendError, server
-from xen.xend.XendClient import main as xend_client_main
-from xen.xm import create, destroy, migrate, shutdown, sysrq
from xen.xm.opts import *
+shorthelp = """Usage: xm <subcommand> [args]
+ Control, list, and manipulate Xen guest instances
+
+xm common subcommands:
+ console <DomId> attach to console of DomId
+ create <CfgFile> create a domain based on Config File
+ destroy <DomId> terminate a domain immediately
+ help display this message
+ list [DomId, ...] list information about domains
+ mem-max <DomId> <Mem> set the maximum memory reservation for a domain
+ mem-set <DomId> <Mem> adjust the current memory usage for a domain
+ migrate <DomId> <Host> migrate a domain to another machine
+ pause <DomId> pause execution of a domain
+ reboot <DomId> reboot a domain
+ restore <File> create a domain from a saved state file
+ save <DomId> <File> save domain state (and config) to file
+ shutdown <DomId> shutdown a domain
+ unpause <DomId> unpause a paused domain
+
+For a complete list of subcommands run 'xm help --long'
+For more help on xm see the xm(1) man page
+For more help on xm create, see the xmdomain.cfg(5) man page"""
+
+longhelp = """Usage: xm <subcommand> [args]
+ Control, list, and manipulate Xen guest instances
+
+xm full list of subcommands:
+
+ Domain Commands:
+ console <DomId> attach to console of DomId
+ cpus-list <DomId> <VCpu> get the list of cpus for a VCPU
+ cpus-set <DomId> <VCpu> <CPUS> set which cpus a VCPU can use.
+ create <ConfigFile> create a domain
+ destroy <DomId> terminate a domain immediately
+ domid <DomName> convert a domain name to a domain id
+ domname <DomId> convert a domain id to a domain name
+ list list information about domains
+ mem-max <DomId> <Mem> set domain maximum memory limit
+ mem-set <DomId> <Mem> set the domain's memory dynamically
+ migrate <DomId> <Host> migrate a domain to another machine
+ pause <DomId> pause execution of a domain
+ reboot [-w|-a] <DomId> reboot a domain
+ restore <File> create a domain from a saved state file
+ save <DomId> <File> save domain state (and config) to file
+ shutdown [-w|-a] <DomId> shutdown a domain
+ sysrq <DomId> <letter> send a sysrq to a domain
+ unpause <DomId> unpause a paused domain
+ vcpu-enable <DomId> <VCPU> disable VCPU in a domain
+ vcpu-disable <DomId> <VCPU> enable VCPU in a domain
+ vcpu-list <DomId> get the list of VCPUs for a domain
+
+ Xen Host Commands:
+ dmesg [--clear] read or clear Xen's message buffer
+ info get information about the xen host
+ log print the xend log
+
+ Scheduler Commands:
+ bvt <options> set BVT scheduler parameters
+ bvt_ctxallow <Allow> set the BVT scheduler context switch allowance
+ sedf <options> set simple EDF parameters
+
+ Virtual Device Commands:
+ block-create <DomId> <BackDev> <FrontDev> <Mode> [BackDomId]
+ Create a new virtual block device
+ block-destroy <DomId> <DevId> Destroy a domain's virtual block device
+ block-list <DomId> List virtual block devices for a domain
+ block-refresh <DomId> <DevId> Refresh a virtual block device for a domain
+ network-limit <DomId> <Vif> <Credit> <Period>
+ Limit the transmission rate of a virtual network interface
+ network-list <DomId> List virtual network interfaces for a domain
+
+For a short list of subcommands run 'xm help'
+For more help on xm see the xm(1) man page
+For more help on xm create, see the xmdomain.cfg(5) man page"""
+
+####################################################################
+#
+# Utility functions
+#
+####################################################################
+
+def arg_check(args,num,name):
+ if len(args) < num:
+ err("'xm %s' requires %s argument(s)!\n" % (name, num))
+ usage(name)
def unit(c):
if not c.isalpha():
@@ -49,692 +134,318 @@
else:
return value * (base / dst_base)
-class Group:
-
- name = ""
- info = ""
-
- def __init__(self, xm):
- self.xm = xm
- self.progs = {}
-
- def addprog(self, prog):
- self.progs[prog.name] = prog
-
- def getprog(self, name):
- return self.progs.get(name)
-
- def proglist(self):
- kl = self.progs.keys()
- kl.sort()
- return [ self.getprog(k) for k in kl ]
-
- def help(self, args):
- if self.info:
- print
- print self.info
- print
+def err(msg):
+ print >>sys.stderr, "Error:", msg
+
+def handle_xend_error(cmd, dom, ex):
+ error = str(ex)
+ if error == "Not found" and dom != None:
+ err("Domain '%s' not found when running 'xm %s'" % (dom, cmd))
+ sys.exit(1)
+ else:
+ raise ex
+
+
+#########################################################################
+#
+# Main xm functions
+#
+#########################################################################
+
+def xm_create(args):
+ from xen.xm import create
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ create.main(args)
+
+def xm_save(args):
+ arg_check(args,2,"save")
+
+ dom = args[0] # TODO: should check if this exists
+ savefile = os.path.abspath(args[1])
+
+ from xen.xend.XendClient import server
+ server.xend_domain_save(dom, savefile)
+
+def xm_restore(args):
+ arg_check(args,1,"restore")
+
+ savefile = os.path.abspath(args[0])
+
+ from xen.xend.XendClient import server
+ info = server.xend_domain_restore(savefile)
+ PrettyPrint.prettyprint(info)
+ id = sxp.child_value(info, 'id')
+ if id is not None:
+ server.xend_domain_unpause(id)
+
+def xm_migrate(args):
+ # TODO: arg_check
+ from xen.xm import migrate
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ migrate.main(args)
+
+def xm_list(args):
+ use_long = 0
+ show_vcpus = 0
+ (options, params) = getopt(args, 'lv', ['long','vcpus'])
+
+ n = len(params)
+ for (k, v) in options:
+ if k in ['-l', '--long']:
+ use_long = 1
+ if k in ['-v', '--vcpus']:
+ show_vcpus = 1
+
+ domsinfo = []
+ from xen.xend.XendClient import server
+ if n == 0:
+ doms = server.xend_domains()
+ doms.sort()
+ else:
+ doms = params
+ for dom in doms:
+ info = server.xend_domain(dom)
+ domsinfo.append(parse_doms_info(info))
+
+ if use_long:
+ # this actually seems like a bad idea, as it just dumps sexp out
+ PrettyPrint.prettyprint(info)
+ elif show_vcpus:
+ xm_show_vcpus(domsinfo)
+ else:
+ xm_brief_list(domsinfo)
+
+def parse_doms_info(info):
+ dominfo = {}
+ dominfo['dom'] = int(sxp.child_value(info, 'id', '-1'))
+ dominfo['name'] = sxp.child_value(info, 'name', '??')
+ dominfo['mem'] = int(sxp.child_value(info, 'memory', '0'))
+ dominfo['cpu'] = str(sxp.child_value(info, 'cpu', '0'))
+ dominfo['vcpus'] = int(sxp.child_value(info, 'vcpus', '0'))
+ # if there is more than 1 cpu, the value doesn't mean much
+ if dominfo['vcpus'] > 1:
+ dominfo['cpu'] = '-'
+ dominfo['state'] = sxp.child_value(info, 'state', '??')
+ dominfo['cpu_time'] = float(sxp.child_value(info, 'cpu_time', '0'))
+ # security identifiers
+ if ((int(sxp.child_value(info, 'ssidref', '0'))) != 0):
+ dominfo['ssidref1'] = int(sxp.child_value(info, 'ssidref', '0')) &
0xffff
+ dominfo['ssidref2'] = (int(sxp.child_value(info, 'ssidref', '0')) >>
16) & 0xffff
+ # get out the vcpu information
+ dominfo['vcpulist'] = []
+ vcpu_to_cpu = sxp.child_value(info, 'vcpu_to_cpu', '-1').split('|')
+ cpumap = sxp.child_value(info, 'cpumap', [])
+ mask = ((int(sxp.child_value(info, 'vcpus', '0')))**2) - 1
+ count = 0
+ for cpu in vcpu_to_cpu:
+ vcpuinfo = {}
+ vcpuinfo['name'] = sxp.child_value(info, 'name', '??')
+ vcpuinfo['dom'] = int(sxp.child_value(info, 'id', '-1'))
+ vcpuinfo['vcpu'] = int(count)
+ vcpuinfo['cpu'] = int(cpu)
+ vcpuinfo['cpumap'] = int(cpumap[count])&mask
+ count = count + 1
+ dominfo['vcpulist'].append(vcpuinfo)
+ return dominfo
+
+def xm_brief_list(domsinfo):
+ print 'Name Id Mem(MB) CPU VCPU(s) State Time(s)'
+ for dominfo in domsinfo:
+ if dominfo.has_key("ssidref1"):
+ print ("%(name)-16s %(dom)3d %(mem)7d %(cpu)3s %(vcpus)5d
%(state)5s %(cpu_time)7.1f %s:%(ssidref2)02x/p:%(ssidref1)02x" % dominfo)
else:
- print
-
- def shortHelp(self, args):
- self.help(args)
- for p in self.proglist():
- p.shortHelp(args)
-
-class Prog:
- """Base class for sub-programs.
- """
-
- """Program group it belongs to"""
- group = 'all'
- """Program name."""
- name = '??'
- """Short program info."""
- info = ''
-
- def __init__(self, xm):
- self.xm = xm
-
- def err(self, msg):
- self.xm.err(msg)
-
- def help(self, args):
- self.shortHelp(args)
-
- def shortHelp(self, args):
- print "%-14s %s" % (self.name, self.info)
-
- def main(self, args):
- """Program main entry point.
- """
- pass
-
-
-class ProgUnknown(Prog):
-
- name = 'unknown'
- info = ''
-
- def help(self, args):
- self.xm.err("Unknown command: %s\nTry '%s help' for more information."
- % (args[0], self.xm.name))
-
- main = help
-
-class Xm:
- """Main application.
- """
-
- def __init__(self):
- self.name = 'xm'
- self.unknown = ProgUnknown(self)
- self.progs = {}
- self.groups = {}
-
- def err(self, msg):
- print >>sys.stderr, "Error:", msg
- sys.exit(1)
-
- def main(self, args):
- try:
- self.main_call(args)
- except socket.error, ex:
- print >>sys.stderr, ex
- self.err("Error connecting to xend, is xend running?")
- except XendError, ex:
- self.err(str(ex))
-
- def main_call(self, args):
- """Main entry point. Dispatches to the progs.
- """
- self.name = args[0]
- if len(args) < 2:
- args.append('help')
- help = self.helparg(args)
- p = self.getprog(args[1], self.unknown)
- if help or len(args) < 2:
- p.help(args[1:])
+ print ("%(name)-16s %(dom)3d %(mem)7d %(cpu)3s %(vcpus)5d
%(state)5s %(cpu_time)7.1f" % dominfo)
+
+def xm_show_vcpus(domsinfo):
+ print 'Name Id VCPU CPU CPUMAP'
+ for dominfo in domsinfo:
+ for vcpuinfo in dominfo['vcpulist']:
+ print ("%(name)-16s %(dom)3d %(vcpu)4d %(cpu)3d 0x%(cpumap)x" %
+ vcpuinfo)
+
+def xm_vcpu_list(args):
+ args.insert(0,"-v")
+ xm_list(args)
+
+def xm_destroy(args):
+ arg_check(args,1,"destroy")
+
+ from xen.xm import destroy
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ destroy.main(args)
+
+# TODO: make reboot do the right thing, right now
+# reboot and shutdown are exactly the same
+def xm_reboot(args):
+ arg_check(args,1,"reboot")
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ from xen.xm import shutdown
+ shutdown.main(args)
+
+def xm_shutdown(args):
+ arg_check(args,1,"shutdown")
+
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ from xen.xm import shutdown
+ shutdown.main(args)
+
+def xm_sysrq(args):
+ from xen.xm import sysrq
+ # ugly hack because the opt parser apparently wants
+ # the subcommand name just to throw it away!
+ args.insert(0,"bogus")
+ sysrq.main(args)
+
+def xm_pause(args):
+ arg_check(args, 1, "pause")
+ dom = args[0]
+
+ from xen.xend.XendClient import server
+ server.xend_domain_pause(dom)
+
+def xm_unpause(args):
+ arg_check(args, 1, "unpause")
+ dom = args[0]
+
+ from xen.xend.XendClient import server
+ server.xend_domain_unpause(dom)
+
+#############################################################
+
+def cpu_make_map(cpulist):
+ cpus = []
+ cpumap = 0
+ for c in cpulist.split(','):
+ if c.find('-') != -1:
+ (x,y) = c.split('-')
+ for i in range(int(x),int(y)+1):
+ cpus.append(int(i))
else:
- p.main(args[1:])
-
- def helparg(self, args):
- for a in args:
- if a in ['-h', '--help']:
- return 1
- return 0
-
- def prog(self, pklass):
- """Add a sub-program.
-
- pklass program class (Prog subclass)
- """
- p = pklass(self)
- self.progs[p.name] = p
- self.getgroup(p.group).addprog(p)
- return p
-
- def getprog(self, name, val=None):
- """Get a sub-program.
- name Name of the sub-program (or optionally, an unambiguous
- prefix of its name)
- val Default return value if no (unique) match is found
- """
-
- match = None
- for progname in self.progs.keys():
- if progname == name:
- match = progname
- break
- if progname.startswith(name):
- if not match:
- match = progname
- else:
- return val # name is ambiguous - bail out
-
- return self.progs.get(match, val)
-
- def group(self, klass):
- g = klass(self)
- self.groups[g.name] = g
- return g
-
- def getgroup(self, name):
- return self.groups[name]
-
- def grouplist(self):
- kl = self.groups.keys()
- kl.sort()
- return [ self.getgroup(k) for k in kl ]
-
-# Create the application object, then add the sub-program classes.
-xm = Xm()
-
-class GroupAll(Group):
-
- name = "all"
- info = ""
-
-xm.group(GroupAll)
-
-class GroupDomain(Group):
-
- name = "domain"
- info = "Commands on domains:"
-
-xm.group(GroupDomain)
-
-class GroupScheduler(Group):
-
- name = "scheduler"
- info = "Comands controlling scheduling:"
-
-xm.group(GroupScheduler)
-
-class GroupHost(Group):
-
- name = "host"
- info = "Commands related to the xen host (node):"
-
-xm.group(GroupHost)
-
-class GroupConsole(Group):
-
- name = "console"
- info = "Commands related to consoles:"
-
-xm.group(GroupConsole)
-
-class GroupVbd(Group):
-
- name = "vbd"
- info = "Commands related to virtual block devices:"
-
-xm.group(GroupVbd)
-
-class GroupVif(Group):
-
- name = "vif"
- info = "Commands related to virtual network interfaces:"
-
-xm.group(GroupVif)
-
-class ProgHelp(Prog):
-
- name = "help"
- info = "Print help."
-
- def help(self, args):
- if len(args) == 2:
- name = args[1]
- p = self.xm.getprog(name)
- if p:
- p.help(args[1:])
- else:
- print '%s: Unknown command: %s' % (self.name, name)
- else:
- for g in self.xm.grouplist():
- g.shortHelp(args)
- print "\nTry '%s help CMD' for help on CMD" % self.xm.name
-
- main = help
-
-xm.prog(ProgHelp)
-
-class ProgCreate(Prog):
-
- group = 'domain'
- name = "create"
- info = """Create a domain."""
-
- def help(self, args):
- create.main([args[0], '-h'])
-
- def main(self, args):
- create.main(args)
-
-xm.prog(ProgCreate)
-
-class ProgSave(Prog):
- group = 'domain'
- name = "save"
- info = """Save domain state (and config) to file."""
-
- def help(self, args):
- print args[0], "DOM FILE"
- print """\nSave domain with id DOM to FILE."""
-
- def main(self, args):
- if len(args) < 3: self.err("%s: Missing arguments" % args[0])
- dom = args[1]
- savefile = os.path.abspath(args[2])
- server.xend_domain_save(dom, savefile)
-
-xm.prog(ProgSave)
-
-class ProgRestore(Prog):
- group = 'domain'
- name = "restore"
- info = """Create a domain from a saved state."""
-
- def help(self, args):
- print args[0], "FILE"
- print "\nRestore a domain from FILE."
-
- def main(self, args):
- if len(args) < 2: self.err("%s: Missing arguments" % args[0])
- savefile = os.path.abspath(args[1])
- info = server.xend_domain_restore(savefile)
- PrettyPrint.prettyprint(info)
- id = sxp.child_value(info, 'id')
- if id is not None:
- server.xend_domain_unpause(id)
-
-xm.prog(ProgRestore)
-
-class ProgMigrate(Prog):
- group = 'domain'
- name = "migrate"
- info = """Migrate a domain to another machine."""
-
- def help(self, args):
- migrate.help([self.name] + args)
-
- def main(self, args):
- migrate.main(args)
-
-xm.prog(ProgMigrate)
-
-class ProgList(Prog):
- group = 'domain'
- name = "list"
- info = """List information about domains."""
-
- short_options = 'lv'
- long_options = ['long','vcpus']
-
- def help(self, args):
- if help:
- print args[0], '[options] [DOM...]'
- print """\nGet information about domains.
- Either all domains or the domains given.
-
- -l, --long Get more detailed information.
- -v, --vcpus Show VCPU to CPU mapping.
- """
- return
-
- def main(self, args):
- use_long = 0
- show_vcpus = 0
- (options, params) = getopt(args[1:],
- self.short_options,
- self.long_options)
- n = len(params)
- for (k, v) in options:
- if k in ['-l', '--long']:
- use_long = 1
- if k in ['-v', '--vcpus']:
- show_vcpus = 1
-
- if n == 0:
- doms = server.xend_domains()
- doms.sort()
- else:
- doms = params
-
- if use_long:
- self.long_list(doms)
- elif show_vcpus:
- self.show_vcpus(doms)
- else:
- self.brief_list(doms)
-
- def brief_list(self, doms):
- print 'Name Id Mem(MB) CPU VCPU(s) State Time(s)'
- for dom in doms:
- info = server.xend_domain(dom)
- d = {}
- d['dom'] = int(sxp.child_value(info, 'id', '-1'))
- d['name'] = sxp.child_value(info, 'name', '??')
- d['mem'] = int(sxp.child_value(info, 'memory', '0'))
- d['cpu'] = str(sxp.child_value(info, 'cpu', '0'))
- d['vcpus'] = int(sxp.child_value(info, 'vcpus', '0'))
- d['state'] = sxp.child_value(info, 'state', '??')
- d['cpu_time'] = float(sxp.child_value(info, 'cpu_time', '0'))
- if d['vcpus'] > 1:
- d['cpu'] = '-'
- if ((int(sxp.child_value(info, 'ssidref', '0'))) != 0):
- d['ssidref1'] = int(sxp.child_value(info, 'ssidref', '0')) &
0xffff
- d['ssidref2'] = (int(sxp.child_value(info, 'ssidref', '0')) >>
16) & 0xffff
- print ("%(name)-16s %(dom)3d %(mem)7d %(cpu)3s %(vcpus)5d
%(state)5s %(cpu_time)7.1f %s:%(ssidref2)02x/p:%(ssidref1)02x" % d)
- else:
- print ("%(name)-16s %(dom)3d %(mem)7d %(cpu)3s %(vcpus)5d
%(state)5s %(cpu_time)7.1f" % d)
-
- def show_vcpus(self, doms):
- print 'Name Id VCPU CPU CPUMAP'
- for dom in doms:
- info = server.xend_domain(dom)
- vcpu_to_cpu = sxp.child_value(info, 'vcpu_to_cpu', '-1').split('|')
- cpumap = sxp.child_value(info, 'cpumap', [])
- mask = ((int(sxp.child_value(info, 'vcpus', '0')))**2) - 1
- count = 0
- for cpu in vcpu_to_cpu:
- d = {}
- d['name'] = sxp.child_value(info, 'name', '??')
- d['dom'] = int(sxp.child_value(info, 'id', '-1'))
- d['vcpu'] = int(count)
- d['cpu'] = int(cpu)
- d['cpumap'] = int(cpumap[count])&mask
- count = count + 1
- print ("%(name)-16s %(dom)3d %(vcpu)4d %(cpu)3d
0x%(cpumap)x" % d)
-
- def long_list(self, doms):
- for dom in doms:
- info = server.xend_domain(dom)
- PrettyPrint.prettyprint(info)
-
-xm.prog(ProgList)
-
-class ProgDestroy(Prog):
- group = 'domain'
- name = "destroy"
- info = """Terminate a domain immediately."""
-
- def help(self, args):
- destroy.main([args[0], '-h'])
-
- def main(self, args):
- destroy.main(args)
-
-xm.prog(ProgDestroy)
-
-class ProgShutdown(Prog):
- group = 'domain'
- name = "shutdown"
- info = """Shutdown a domain."""
-
- def help(self, args):
- shutdown.main([args[0], '-h'])
-
- def main(self, args):
- shutdown.main(args)
-
-xm.prog(ProgShutdown)
-
-class ProgSysrq(Prog):
- group = 'domain'
- name = "sysrq"
- info = """Send a sysrq to a domain."""
-
- def help(self, args):
- sysrq.main([args[0], '-h'])
-
- def main(self, args):
- sysrq.main(args)
-
-xm.prog(ProgSysrq)
-
-class ProgPause(Prog):
- group = 'domain'
- name = "pause"
- info = """Pause execution of a domain."""
-
- def help(self, args):
- print args[0], 'DOM'
- print '\nPause execution of domain DOM.'
-
- def main(self, args):
- if len(args) < 2: self.err("%s: Missing domain" % args[0])
- dom = args[1]
- server.xend_domain_pause(dom)
-
-xm.prog(ProgPause)
-
-class ProgUnpause(Prog):
- group = 'domain'
- name = "unpause"
- info = """Unpause a paused domain."""
-
- def help(self, args):
- print args[0], 'DOM'
- print '\nUnpause execution of domain DOM.'
-
- def main(self, args):
- if len(args) < 2: self.err("%s: Missing domain" % args[0])
- dom = args[1]
- server.xend_domain_unpause(dom)
-
-xm.prog(ProgUnpause)
-
-class ProgPincpu(Prog):
- group = 'domain'
- name = "pincpu"
- info = """Set which cpus a VCPU can use. """
-
- def help(self, args):
- print args[0],'DOM VCPU CPUS'
- print '\nSet which cpus VCPU in domain DOM can use.'
-
- # convert list of cpus to bitmap integer value
- def make_map(self, cpulist):
- cpus = []
- cpumap = 0
- for c in cpulist.split(','):
- if c.find('-') != -1:
- (x,y) = c.split('-')
- for i in range(int(x),int(y)+1):
- cpus.append(int(i))
- else:
- cpus.append(int(c))
- cpus.sort()
- for c in cpus:
- cpumap = cpumap | 1<<c
-
- return cpumap
-
- def main(self, args):
- if len(args) != 4: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- vcpu = int(args[2])
- cpumap = self.make_map(args[3]);
- server.xend_domain_pincpu(dom, vcpu, cpumap)
-
-xm.prog(ProgPincpu)
-
-class ProgMaxmem(Prog):
- group = 'domain'
- name = 'maxmem'
- info = """Set domain memory limit."""
-
- def help(self, args):
- print args[0], "DOM MEMORY"
- print "\nSet the memory limit for domain DOM to MEMORY megabytes."
-
- def main(self, args):
- if len(args) != 3: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- mem = int_unit(args[2], 'm')
- server.xend_domain_maxmem_set(dom, mem)
-
-xm.prog(ProgMaxmem)
-
-class ProgSetMem(Prog):
- group = 'domain'
- name = 'set-mem'
- info = """Set the domain's memory footprint using the balloon driver."""
-
- def help(self, args):
- print args[0], "DOM MEMORY_TARGET"
- print """\nRequest domain DOM to adjust its memory footprint to
-MEMORY_TARGET megabytes"""
-
- def main(self, args):
- if len(args) != 3: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- mem_target = int_unit(args[2], 'm')
- server.xend_domain_mem_target_set(dom, mem_target)
-
-xm.prog(ProgSetMem)
-
-class ProgVcpuhotplug(Prog):
- group = 'domain'
- name = 'vcpu-hotplug'
- info = """Enable or disable a VCPU in a domain."""
-
- def help(self, args):
- print args[0], "DOM VCPU [0|1]"
- print """\nRequest virtual processor VCPU to be disabled or enabled in
-domain DOM"""
-
- def main(self, args):
- if len(args) != 4: self.err("%s: Invalid arguments(s)" % args[0])
- name = args[1]
- vcpu = int(args[2])
- state = int(args[3])
- dom = server.xend_domain(name)
- id = sxp.child_value(dom, 'id')
- server.xend_domain_vcpu_hotplug(id, vcpu, state)
-
-xm.prog(ProgVcpuhotplug)
-
-class ProgDomid(Prog):
- group = 'domain'
- name = 'domid'
- info = 'Convert a domain name to a domain id.'
-
- def help(self, args):
- print args[0], "DOM"
- print '\nGet the domain id for the domain with name DOM.'
-
- def main (self, args):
- if len(args) != 2: self.err("%s: Invalid argument(s)" % args[0])
- name = args[1]
- dom = server.xend_domain(name)
- print sxp.child_value(dom, 'id')
-
-xm.prog(ProgDomid)
-
-class ProgDomname(Prog):
- group = 'domain'
- name = 'domname'
- info = 'Convert a domain id to a domain name.'
-
- def help(self, args):
- print args[0], "DOM"
- print '\nGet the name for the domain with id DOM.'
-
- def main (self, args):
- if len(args) != 2: self.err("%s: Invalid argument(s)" % args[0])
- name = args[1]
- dom = server.xend_domain(name)
- print sxp.child_value(dom, 'name')
-
-xm.prog(ProgDomname)
-
-class ProgBvt(Prog):
- group = 'scheduler'
- name = "bvt"
- info = """Set BVT scheduler parameters."""
-
- def help(self, args):
- print args[0], "DOM MCUADV WARPBACK WARPVALUE WARPL WARPU"
- print '\nSet Borrowed Virtual Time scheduler parameters.'
-
- def main(self, args):
- if len(args) != 7: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- v = map(long, args[2:7])
- server.xend_domain_cpu_bvt_set(dom, *v)
-
-xm.prog(ProgBvt)
-
-class ProgBvtslice(Prog):
- group = 'scheduler'
- name = "bvt_ctxallow"
- info = """Set the BVT scheduler context switch allowance."""
-
- def help(self, args):
- print args[0], 'CTX_ALLOW'
- print '\nSet Borrowed Virtual Time scheduler context switch allowance.'
-
- def main(self, args):
- if len(args) < 2: self.err('%s: Missing context switch allowance'
- % args[0])
- slice = int(args[1])
- server.xend_node_cpu_bvt_slice_set(slice)
-
-xm.prog(ProgBvtslice)
-
-class ProgSedf(Prog):
- group = 'scheduler'
- name= "sedf"
- info = """Set simple EDF parameters."""
-
- def help(self, args):
- print args[0], "DOM PERIOD SLICE LATENCY EXTRATIME WEIGHT"
- print "\nSet simple EDF parameters."
-
- def main(self, args):
- if len(args) != 7: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- v = map(int, args[2:7])
- server.xend_domain_cpu_sedf_set(dom, *v)
-
-xm.prog(ProgSedf)
-
-class ProgInfo(Prog):
- group = 'host'
- name = "info"
- info = """Get information about the xen host."""
-
- def main(self, args):
- info = server.xend_node()
- for x in info[1:]:
- print "%-23s:" % x[0], x[1]
-
-xm.prog(ProgInfo)
-
-class ProgConsole(Prog):
- group = 'console'
- name = "console"
- info = """Open a console to a domain."""
-
- def help(self, args):
- print args[0], "DOM"
- print "\nOpen a console to domain DOM."
-
- def main(self, args):
- if len(args) < 2: self.err("%s: Missing domain" % args[0])
- dom = args[1]
- info = server.xend_domain(dom)
- domid = int(sxp.child_value(info, 'id', '-1'))
- cmd = "/usr/libexec/xen/xenconsole %d" % domid
- os.execvp('/usr/libexec/xen/xenconsole', cmd.split())
-
-xm.prog(ProgConsole)
-
-class ProgCall(Prog):
- name = "call"
- info = "Call xend api functions."
-
- def help (self, args):
- print args[0], "function args..."
- print """
- Call a xend HTTP API function. The leading 'xend_' on the function
-can be omitted. See xen.xend.XendClient for the API functions.
-"""
-
- def main(self, args):
- xend_client_main(args)
-
-xm.prog(ProgCall)
-
-class ProgDmesg(Prog):
- group = 'host'
- name = "dmesg"
- info = """Read or clear Xen's message buffer."""
-
+ cpus.append(int(c))
+ cpus.sort()
+ for c in cpus:
+ cpumap = cpumap | 1<<c
+
+ return cpumap
+
+def xm_cpus_set(args):
+ arg_check(args, 3, "cpus-set")
+
+ dom = args[0]
+ vcpu = int(args[1])
+ cpumap = cpu_make_map(args[2])
+
+ from xen.xend.XendClient import server
+ server.xend_domain_pincpu(dom, vcpu, cpumap)
+
+def xm_mem_max(args):
+ arg_check(args, 2, "mem-max")
+
+ dom = args[0]
+ mem = int_unit(args[1], 'm')
+
+ from xen.xend.XendClient import server
+ server.xend_domain_maxmem_set(dom, mem)
+
+def xm_mem_set(args):
+ arg_check(args, 2, "mem-set")
+
+ dom = args[0]
+ mem_target = int_unit(args[1], 'm')
+
+ from xen.xend.XendClient import server
+ server.xend_domain_mem_target_set(dom, mem_target)
+
+# TODO: why does this lookup by name? and what if that fails!?
+def xm_vcpu_enable(args):
+ arg_check(args, 2, "vcpu-enable")
+
+ name = args[0]
+ vcpu = int(args[1])
+
+ from xen.xend.XendClient import server
+ dom = server.xend_domain(name)
+ id = sxp.child_value(dom, 'id')
+ server.xend_domain_vcpu_hotplug(id, vcpu, 1)
+
+def xm_vcpu_disable(args):
+ arg_check(args, 2, "vcpu-disable")
+
+ name = args[0]
+ vcpu = int(args[1])
+
+ from xen.xend.XendClient import server
+ dom = server.xend_domain(name)
+ id = sxp.child_value(dom, 'id')
+ server.xend_domain_vcpu_hotplug(id, vcpu, 0)
+
+def xm_domid(args):
+ name = args[0]
+
+ from xen.xend.XendClient import server
+ dom = server.xend_domain(name)
+ print sxp.child_value(dom, 'id')
+
+def xm_domname(args):
+ name = args[0]
+
+ from xen.xend.XendClient import server
+ dom = server.xend_domain(name)
+ print sxp.child_value(dom, 'name')
+
+def xm_bvt(args):
+ arg_check(args, 6, "bvt")
+ dom = args[0]
+ v = map(long, args[1:6])
+ from xen.xend.XendClient import server
+ server.xend_domain_cpu_bvt_set(dom, *v)
+
+def xm_bvt_ctxallow(args):
+ arg_check(args, 1, "bvt_ctxallow")
+
+ slice = int(args[0])
+ from xen.xend.XendClient import server
+ server.xend_node_cpu_bvt_slice_set(slice)
+
+def xm_sedf(args):
+ arg_check(args, 6, "sedf")
+
+ dom = args[0]
+ v = map(int, args[1:5])
+ from xen.xend.XendClient import server
+ server.xend_domain_cpu_sedf_set(dom, *v)
+
+def xm_info(args):
+ from xen.xend.XendClient import server
+ info = server.xend_node()
+
+ for x in info[1:]:
+ print "%-23s:" % x[0], x[1]
+
+# TODO: remove as soon as console server shows up
+def xm_console(args):
+ arg_check(args,1,"console")
+
+ dom = args[0]
+ from xen.xend.XendClient import server
+ info = server.xend_domain(dom)
+ domid = int(sxp.child_value(info, 'id', '-1'))
+ cmd = "/usr/libexec/xen/xenconsole %d" % domid
+ os.execvp('/usr/libexec/xen/xenconsole', cmd.split())
+ console = sxp.child(info, "console")
+
+def xm_dmesg(args):
+
gopts = Opts(use="""[-c|--clear]
Read Xen's message buffer (boot output, warning and error messages) or clear
@@ -744,161 +455,212 @@
gopts.opt('clear', short='c',
fn=set_true, default=0,
use="Clear the contents of the Xen message buffer.")
-
- short_options = ['-c']
- long_options = ['--clear']
-
- def help(self, args):
- self.gopts.argv = args
- self.gopts.usage()
-
- def main(self, args):
- self.gopts.parse(args)
- if not (1 <= len(args) <=2):
- self.gopts.err('Invalid arguments: ' + str(args))
-
- if not self.gopts.vals.clear:
- print server.xend_node_get_dmesg()
- else:
- server.xend_node_clear_dmesg()
-
-xm.prog(ProgDmesg)
-
-class ProgLog(Prog):
- group = 'host'
- name = "log"
- info = """Print the xend log."""
-
- def main(self, args):
- print server.xend_node_log()
-
-xm.prog(ProgLog)
-
-class ProgVifCreditLimit(Prog):
- group = 'vif'
- name= "vif-limit"
- info = """Limit the transmission rate of a virtual network interface."""
-
- def help(self, args):
- print args[0], "DOMAIN VIF CREDIT_IN_BYTES PERIOD_IN_USECS"
- print "\nSet the credit limit of a virtual network interface."
-
- def main(self, args):
- if len(args) != 5: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- v = map(int, args[2:5])
- server.xend_domain_vif_limit(dom, *v)
-
-xm.prog(ProgVifCreditLimit)
-
-class ProgVifList(Prog):
- group = 'vif'
- name = 'vif-list'
- info = """List virtual network interfaces for a domain."""
-
- def help(self, args):
- print args[0], "DOM"
- print "\nList virtual network interfaces for domain DOM"
-
- def main(self, args):
- if len(args) != 2: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- for x in server.xend_domain_devices(dom, 'vif'):
- sxp.show(x)
+ # Work around for gopts
+ args.insert(0,"bogus")
+ gopts.parse(args)
+ if not (1 <= len(args) <= 2):
+ err('Invalid arguments: ' + str(args))
+
+ from xen.xend.XendClient import server
+ if not gopts.vals.clear:
+ print server.xend_node_get_dmesg()
+ else:
+ server.xend_node_clear_dmesg()
+
+def xm_log(args):
+ from xen.xend.XendClient import server
+ print server.xend_node_log()
+
+def xm_network_limit(args):
+ arg_check(args,4,"network-limit")
+ dom = args[0]
+ v = map(int, args[1:4])
+ from xen.xend.XendClient import server
+ server.xend_domain_vif_limit(dom, *v)
+
+def xm_network_list(args):
+ arg_check(args,1,"network-list")
+ dom = args[0]
+ from xen.xend.XendClient import server
+ for x in server.xend_domain_devices(dom, 'vif'):
+ sxp.show(x)
+ print
+
+def xm_block_list(args):
+ arg_check(args,1,"block-list")
+ dom = args[0]
+ from xen.xend.XendClient import server
+ for x in server.xend_domain_devices(dom, 'vbd'):
+ sxp.show(x)
+ print
+
+def xm_block_create(args):
+ n = len(args)
+ if n < 4 or n > 5:
+ err("%s: Invalid argument(s)" % args[0])
+ usage("block-create")
+
+ dom = args[0]
+ vbd = ['vbd',
+ ['uname', args[1]],
+ ['dev', args[2]],
+ ['mode', args[3]]]
+ if n == 5:
+ vbd.append(['backend', args[4]])
+
+ from xen.xend.XendClient import server
+ server.xend_domain_device_create(dom, vbd)
+
+def xm_block_refresh(args):
+ arg_check(args,2,"block-refresh")
+
+ dom = args[0]
+ dev = args[1]
+
+ from xen.xend.XendClient import server
+ server.xend_domain_device_refresh(dom, 'vbd', dev)
+
+def xm_block_destroy(args):
+ arg_check(args,2,"block-destroy")
+
+ dom = args[0]
+ dev = args[1]
+
+ from xen.xend.XendClient import server
+ server.xend_domain_device_destroy(dom, 'vbd', dev)
+
+commands = {
+ # console commands
+ "console": xm_console,
+ # domain commands
+ "domid": xm_domid,
+ "domname": xm_domname,
+ "create": xm_create,
+ "destroy": xm_destroy,
+ "restore": xm_restore,
+ "save": xm_save,
+ "shutdown": xm_shutdown,
+ "reboot": xm_reboot,
+ "list": xm_list,
+ # memory commands
+ "mem-max": xm_mem_max,
+ "mem-set": xm_mem_set,
+ # cpu commands
+ "cpus-set": xm_cpus_set,
+# "cpus-list": xm_cpus_list,
+ "vcpu-enable": xm_vcpu_enable,
+ "vcpu-disable": xm_vcpu_disable,
+ "vcpu-list": xm_vcpu_list,
+ # migration
+ "migrate": xm_migrate,
+ # special
+ "sysrq": xm_sysrq,
+ "pause": xm_pause,
+ "unpause": xm_unpause,
+ # host commands
+ "dmesg": xm_dmesg,
+ "info": xm_info,
+ "log": xm_log,
+ # scheduler
+ "bvt": xm_bvt,
+ "bvt_ctxallow": xm_bvt_ctxallow,
+ "sedf": xm_sedf,
+ # block
+ "block-create": xm_block_create,
+ "block-destroy": xm_block_destroy,
+ "block-list": xm_block_list,
+ "block-refresh": xm_block_refresh,
+ # network
+ "network-limit": xm_network_limit,
+ "network-list": xm_network_list
+ }
+
+aliases = {
+ "balloon": "mem-set",
+ "vif-list": "network-list",
+ "vif-limit": "network-limit",
+ "vbd-create": "block-create",
+ "vbd-destroy": "block-destroy",
+ "vbd-list": "block-list",
+ "vbd-refresh": "block-refresh",
+ }
+
+help = {
+ "--long": longhelp
+ }
+
+def xm_lookup_cmd(cmd):
+ if commands.has_key(cmd):
+ return commands[cmd]
+ elif aliases.has_key(cmd):
+ deprecated(cmd,aliases[cmd])
+ return commands[aliases[cmd]]
+ else:
+ err('Sub Command %s not found!' % cmd)
+ usage()
+
+def deprecated(old,new):
+ err('Option %s is deprecated, and will be removed in future!!!' % old)
+ err('Option %s is the new replacement, see "xm help %s" for more info' %
(new, new))
+
+def usage(cmd=None):
+ if cmd == "full":
+ print fullhelp
+ elif help.has_key(cmd):
+ print help[cmd]
+ else:
+ print shorthelp
+ sys.exit(1)
+
+def main(argv=sys.argv):
+ if len(argv) < 2:
+ usage()
+
+ if re.compile('-*help').match(argv[1]):
+ if len(argv) > 2 and help.has_key(argv[2]):
+ usage(argv[2])
+ else:
+ usage()
+ sys.exit(0)
+
+ cmd = xm_lookup_cmd(argv[1])
+
+ # strip off prog name and subcmd
+ args = argv[2:]
+ if cmd:
+ try:
+ from xen.xend.XendClient import XendError
+ rc = cmd(args)
+ if rc:
+ usage()
+ except socket.error, ex:
+ print >>sys.stderr, ex
+ err("Error connecting to xend, is xend running?")
+ sys.exit(1)
+ except IOError:
+ err("Most commands need root access. Please try again as root")
+ sys.exit(1)
+ except XendError, ex:
+ if len(args) > 0:
+ handle_xend_error(argv[1], args[0], ex)
+ else:
+ print "Unexpected error:", sys.exc_info()[0]
+ print
+ print "Please report to xen-devel@xxxxxxxxxxxxxxxxxxx"
+ raise
+ except SystemExit:
+ sys.exit(1)
+ except:
+ print "Unexpected error:", sys.exc_info()[0]
print
-
-xm.prog(ProgVifList)
-
-class ProgVbdList(Prog):
- group = 'vbd'
- name = 'vbd-list'
- info = """List virtual block devices for a domain."""
-
- def help(self, args):
- print args[0], "DOM"
- print "\nList virtual block devices for domain DOM"
-
- def main(self, args):
- if len(args) != 2: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- for x in server.xend_domain_devices(dom, 'vbd'):
- sxp.show(x)
- print
-
-xm.prog(ProgVbdList)
-
-class ProgVbdCreate(Prog):
- group = 'vbd'
- name = 'vbd-create'
- info = """Create a new virtual block device for a domain"""
-
- def help(self, args):
- print args[0], "DOM UNAME DEV MODE [BACKEND]"
- print """
-Create a virtual block device for a domain.
-
- UNAME - device to export, e.g. phy:hda2
- DEV - device name in the domain, e.g. sda1
- MODE - access mode: r for read, w for read-write
- BACKEND - backend driver domain
-"""
-
- def main(self, args):
- n = len(args)
- if n < 5 or n > 6: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- vbd = ['vbd',
- ['uname', args[2]],
- ['dev', args[3]],
- ['mode', args[4]]]
- if n == 6:
- vbd.append(['backend', args[5]])
- server.xend_domain_device_create(dom, vbd)
-
-xm.prog(ProgVbdCreate)
-
-class ProgVbdRefresh(Prog):
- group = 'vbd'
- name = 'vbd-refresh'
- info = """Refresh a virtual block device for a domain"""
-
- def help(self, args):
- print args[0], "DOM DEV"
- print """
-Refresh a virtual block device for a domain.
-
- DEV - idx field in the device information
-"""
-
- def main(self, args):
- if len(args) != 3: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- dev = args[2]
- server.xend_domain_device_refresh(dom, 'vbd', dev)
-
-xm.prog(ProgVbdRefresh)
-
-
-class ProgVbdDestroy(Prog):
- group = 'vbd'
- name = 'vbd-destroy'
- info = """Destroy a domain's virtual block device"""
-
- def help(self, args):
- print args[0], "DOM DEV"
- print """
-Destroy vbd DEV attached to domain DOM. Detaches the device
-from the domain, but does not destroy the device contents.
-The device indentifier DEV is the idx field in the device
-information. This is visible in 'xm vbd-list'."""
-
- def main(self, args):
- if len(args) != 3: self.err("%s: Invalid argument(s)" % args[0])
- dom = args[1]
- dev = args[2]
- server.xend_domain_device_destroy(dom, 'vbd', dev)
-
-xm.prog(ProgVbdDestroy)
-
-def main(args):
- xm.main(args)
+ print "Please report to xen-devel@xxxxxxxxxxxxxxxxxxx"
+ raise
+
+ else:
+ usage()
+
+if __name__ == "__main__":
+ main()
+
+
+
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
Home