2005-11-10 19:12:31 +03:00
/*
2007-01-26 14:54:29 +03:00
* virsh . c : a Xen shell used to exercise the libvirt API
2005-11-10 19:12:31 +03:00
*
2009-01-05 16:27:43 +03:00
* Copyright ( C ) 2005 , 2007 - 2009 Red Hat , Inc .
2005-11-10 19:12:31 +03:00
*
* See COPYING . LIB for the License of this software
*
* Daniel Veillard < veillard @ redhat . com >
2005-12-08 17:22:52 +03:00
* Karel Zak < kzak @ redhat . com >
2006-05-29 19:39:31 +04:00
* Daniel P . Berrange < berrange @ redhat . com >
2005-11-10 19:12:31 +03:00
*/
2008-01-29 21:15:54 +03:00
# include <config.h>
2007-12-04 21:27:52 +03:00
2005-11-10 19:12:31 +03:00
# include <stdio.h>
2005-12-08 13:23:34 +03:00
# include <stdlib.h>
# include <string.h>
# include <stdarg.h>
2005-12-01 19:35:42 +03:00
# include <unistd.h>
2007-05-23 19:09:19 +04:00
# include <errno.h>
2005-12-08 13:23:34 +03:00
# include <getopt.h>
2005-12-01 19:35:42 +03:00
# include <sys/types.h>
2005-12-08 17:22:52 +03:00
# include <sys/time.h>
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 13:37:44 +04:00
# include "c-ctype.h"
2006-03-30 20:08:13 +04:00
# include <fcntl.h>
2006-09-29 20:23:27 +04:00
# include <locale.h>
2007-11-29 12:18:04 +03:00
# include <time.h>
2007-06-15 19:24:20 +04:00
# include <limits.h>
2007-06-05 16:06:08 +04:00
# include <assert.h>
2007-06-06 16:24:31 +04:00
# include <errno.h>
# include <sys/stat.h>
2007-08-21 14:08:12 +04:00
# include <inttypes.h>
2005-12-08 13:23:34 +03:00
2007-01-26 14:54:29 +03:00
# include <libxml/parser.h>
# include <libxml/tree.h>
# include <libxml/xpath.h>
2007-12-04 21:27:52 +03:00
# ifdef HAVE_READLINE_READLINE_H
2005-12-08 13:23:34 +03:00
# include <readline/readline.h>
# include <readline/history.h>
2007-12-04 21:27:52 +03:00
# endif
2005-12-08 13:23:34 +03:00
Standardize use of header files, making internal.h primary.
* qemud/internal.h, qemud/qemud.h: Rename this file so it
doesn't conflict with src/internal.h.
* HACKING: Document how header files should be used.
* qemud/Makefile.am: Add src/ directory to includes.
* qemud/event.c, qemud/mdns.c, qemud/qemud.c, qemud/remote.c,
qemud/remote_protocol.c, qemud/remote_protocol.h,
qemud/remote_protocol.x, src/buf.c, src/libvirt.c,
src/nodeinfo.c, src/qemu_conf.c, src/qemu_driver.c,
src/stats_linux.c, src/storage_backend.c, src/storage_backend_fs.c,
src/storage_backend_iscsi.c, src/storage_backend_logical.c,
src/storage_conf.c, src/storage_driver.c, src/util.c,
src/util.h, src/virsh.c, src/virterror.c, src/xend_internal.c,
src/xml.c, tests/reconnect.c, tests/xmlrpctest.c,
tests/qparamtest.c: Standardize use of header files.
* docs/*, po/*: Rebuild docs.
2008-05-23 12:24:41 +04:00
# include "internal.h"
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 18:55:04 +03:00
# include "buf.h"
2007-01-26 14:54:29 +03:00
# include "console.h"
2008-01-21 18:27:14 +03:00
# include "util.h"
2005-12-08 13:23:34 +03:00
static char * progname ;
# ifndef TRUE
# define TRUE 1
# define FALSE 0
# endif
2008-01-21 18:27:14 +03:00
# define VIRSH_MAX_XML_FILE 10*1024*1024
2005-12-08 13:23:34 +03:00
# define VSH_PROMPT_RW "virsh # "
# define VSH_PROMPT_RO "virsh > "
# define GETTIMEOFDAY(T) gettimeofday(T, NULL)
# define DIFF_MSEC(T, U) \
( ( ( ( int ) ( ( T ) - > tv_sec - ( U ) - > tv_sec ) ) * 1000000.0 + \
( ( int ) ( ( T ) - > tv_usec - ( U ) - > tv_usec ) ) ) / 1000.0 )
2007-06-06 16:24:31 +04:00
/**
* The log configuration
*/
# define MSG_BUFFER 4096
# define SIGN_NAME "virsh"
# define DIR_MODE (S_IWUSR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) /* 0755 */
# define FILE_MODE (S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH) /* 0644 */
# define LOCK_MODE (S_IWUSR | S_IRUSR) /* 0600 */
# define LVL_DEBUG "DEBUG"
# define LVL_INFO "INFO"
# define LVL_NOTICE "NOTICE"
# define LVL_WARNING "WARNING"
# define LVL_ERROR "ERROR"
2008-08-12 12:25:48 +04:00
# ifndef WEXITSTATUS
# define WEXITSTATUS(x) ((x) & 0xff)
# endif
2007-06-06 16:24:31 +04:00
/**
* vshErrorLevel :
*
* Indicates the level of an log message
*/
typedef enum {
VSH_ERR_DEBUG = 0 ,
VSH_ERR_INFO ,
VSH_ERR_NOTICE ,
VSH_ERR_WARNING ,
VSH_ERR_ERROR
} vshErrorLevel ;
2005-12-08 13:23:34 +03:00
/*
* virsh command line grammar :
*
* command_line = < command > \ n | < command > ; < command > ; . . .
*
* command = < keyword > < option > < data >
*
* option = < bool_option > | < int_option > | < string_option >
* data = < string >
*
* bool_option = - - optionname
* int_option = - - optionname < number >
* string_option = - - optionname < string >
2007-02-07 16:50:18 +03:00
*
2006-01-25 12:46:22 +03:00
* keyword = [ a - zA - Z ]
* number = [ 0 - 9 ] +
* string = [ ^ [ : blank : ] ] | " [[:alnum:]] " $
2005-12-08 13:23:34 +03:00
*
*/
/*
2007-02-07 16:50:18 +03:00
* vshCmdOptType - command option type
2006-03-15 15:13:25 +03:00
*/
2005-12-08 13:23:34 +03:00
typedef enum {
2006-03-15 15:13:25 +03:00
VSH_OT_NONE = 0 , /* none */
VSH_OT_BOOL , /* boolean option */
VSH_OT_STRING , /* string option */
VSH_OT_INT , /* int option */
VSH_OT_DATA /* string data (as non-option) */
2005-12-08 13:23:34 +03:00
} vshCmdOptType ;
/*
* Command Option Flags
*/
2006-03-15 15:13:25 +03:00
# define VSH_OFLAG_NONE 0 /* without flags */
# define VSH_OFLAG_REQ (1 << 1) /* option required */
2005-12-08 13:23:34 +03:00
/* dummy */
typedef struct __vshControl vshControl ;
typedef struct __vshCmd vshCmd ;
/*
* vshCmdInfo - - information about command
*/
2006-03-15 15:13:25 +03:00
typedef struct {
const char * name ; /* name of information */
const char * data ; /* information */
2005-12-08 13:23:34 +03:00
} vshCmdInfo ;
/*
* vshCmdOptDef - command option definition
*/
2006-03-15 15:13:25 +03:00
typedef struct {
const char * name ; /* the name of option */
vshCmdOptType type ; /* option type */
int flag ; /* flags */
const char * help ; /* help string */
2005-12-08 13:23:34 +03:00
} vshCmdOptDef ;
/*
* vshCmdOpt - command options
*/
typedef struct vshCmdOpt {
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * def ; /* pointer to relevant option */
2006-03-15 15:13:25 +03:00
char * data ; /* allocated data */
struct vshCmdOpt * next ;
2005-12-08 13:23:34 +03:00
} vshCmdOpt ;
/*
* vshCmdDef - command definition
*/
2006-03-15 15:13:25 +03:00
typedef struct {
const char * name ;
2008-08-01 17:51:18 +04:00
int ( * handler ) ( vshControl * , const vshCmd * ) ; /* command handler */
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * opts ; /* definition of command options */
const vshCmdInfo * info ; /* details about command */
2005-12-08 13:23:34 +03:00
} vshCmdDef ;
/*
* vshCmd - parsed command
*/
typedef struct __vshCmd {
2008-08-01 16:19:56 +04:00
const vshCmdDef * def ; /* command definition */
2006-03-15 15:13:25 +03:00
vshCmdOpt * opts ; /* list of command arguments */
struct __vshCmd * next ; /* next command */
2005-12-08 13:23:34 +03:00
} __vshCmd ;
/*
* vshControl
*/
typedef struct __vshControl {
2006-05-29 19:39:31 +04:00
char * name ; /* connection name */
2007-06-20 21:22:09 +04:00
virConnectPtr conn ; /* connection to hypervisor (MAY BE NULL) */
2006-03-15 15:13:25 +03:00
vshCmd * cmd ; /* the current command */
char * cmdstr ; /* string with command */
int imode ; /* interactive mode? */
int quiet ; /* quiet mode */
int debug ; /* print debug messages? */
int timing ; /* print timing info? */
2007-03-08 16:48:22 +03:00
int readonly ; /* connect readonly (first time only, not
* during explicit connect command )
*/
2007-06-06 16:24:31 +04:00
char * logfile ; /* log file name */
int log_fd ; /* log file descriptor */
2005-12-08 13:23:34 +03:00
} __vshControl ;
2005-11-10 19:12:31 +03:00
2005-12-02 17:16:21 +03:00
2008-08-01 16:19:56 +04:00
static const vshCmdDef commands [ ] ;
2005-12-08 13:23:34 +03:00
2008-08-01 17:51:18 +04:00
static void vshError ( vshControl * ctl , int doexit , const char * format , . . . )
2007-03-19 17:20:30 +03:00
ATTRIBUTE_FORMAT ( printf , 3 , 4 ) ;
2008-08-01 17:51:18 +04:00
static int vshInit ( vshControl * ctl ) ;
static int vshDeinit ( vshControl * ctl ) ;
2008-12-08 16:14:48 +03:00
static void vshUsage ( void ) ;
2007-06-06 16:24:31 +04:00
static void vshOpenLogFile ( vshControl * ctl ) ;
static void vshOutputLogFile ( vshControl * ctl , int log_level , const char * format , va_list ap ) ;
static void vshCloseLogFile ( vshControl * ctl ) ;
2005-12-08 13:23:34 +03:00
2008-08-01 17:51:18 +04:00
static int vshParseArgv ( vshControl * ctl , int argc , char * * argv ) ;
2005-12-08 13:23:34 +03:00
2008-08-01 17:51:18 +04:00
static const char * vshCmddefGetInfo ( const vshCmdDef * cmd , const char * info ) ;
2008-08-01 16:19:56 +04:00
static const vshCmdDef * vshCmddefSearch ( const char * cmdname ) ;
2008-12-08 16:14:48 +03:00
static int vshCmddefHelp ( vshControl * ctl , const char * name ) ;
2005-12-08 13:23:34 +03:00
2008-08-01 17:51:18 +04:00
static vshCmdOpt * vshCommandOpt ( const vshCmd * cmd , const char * name ) ;
static int vshCommandOptInt ( const vshCmd * cmd , const char * name , int * found ) ;
static char * vshCommandOptString ( const vshCmd * cmd , const char * name ,
2006-03-15 15:13:25 +03:00
int * found ) ;
2008-02-20 18:29:13 +03:00
#if 0
2008-08-01 17:51:18 +04:00
static int vshCommandOptStringList ( const vshCmd * cmd , const char * name , char * * * data ) ;
2008-02-20 18:29:13 +03:00
# endif
2008-08-01 17:51:18 +04:00
static int vshCommandOptBool ( const vshCmd * cmd , const char * name ) ;
2006-05-29 19:39:31 +04:00
2007-02-14 18:44:58 +03:00
# define VSH_BYID (1 << 1)
# define VSH_BYUUID (1 << 2)
# define VSH_BYNAME (1 << 3)
2006-05-29 19:39:31 +04:00
2008-08-01 17:51:18 +04:00
static virDomainPtr vshCommandOptDomainBy ( vshControl * ctl , const vshCmd * cmd ,
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
char * * name , int flag ) ;
2006-05-29 19:39:31 +04:00
/* default is lookup by Id, Name and UUID */
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
# define vshCommandOptDomain(_ctl, _cmd, _name) \
vshCommandOptDomainBy ( _ctl , _cmd , _name , VSH_BYID | VSH_BYUUID | VSH_BYNAME )
2007-02-14 18:44:58 +03:00
2008-08-01 17:51:18 +04:00
static virNetworkPtr vshCommandOptNetworkBy ( vshControl * ctl , const vshCmd * cmd ,
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
char * * name , int flag ) ;
2007-02-14 19:53:55 +03:00
/* default is lookup by Name and UUID */
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
# define vshCommandOptNetwork(_ctl, _cmd, _name) \
vshCommandOptNetworkBy ( _ctl , _cmd , _name , \
2007-02-14 19:53:55 +03:00
VSH_BYUUID | VSH_BYNAME )
2008-08-01 17:51:18 +04:00
static virStoragePoolPtr vshCommandOptPoolBy ( vshControl * ctl , const vshCmd * cmd ,
2008-02-20 18:27:08 +03:00
const char * optname , char * * name , int flag ) ;
/* default is lookup by Name and UUID */
# define vshCommandOptPool(_ctl, _cmd, _optname, _name) \
vshCommandOptPoolBy ( _ctl , _cmd , _optname , _name , \
VSH_BYUUID | VSH_BYNAME )
2008-08-01 17:51:18 +04:00
static virStorageVolPtr vshCommandOptVolBy ( vshControl * ctl , const vshCmd * cmd ,
2008-02-20 18:27:08 +03:00
const char * optname ,
const char * pooloptname ,
char * * name , int flag ) ;
/* default is lookup by Name and UUID */
# define vshCommandOptVol(_ctl, _cmd,_optname, _pooloptname, _name) \
vshCommandOptVolBy ( _ctl , _cmd , _optname , _pooloptname , _name , \
VSH_BYUUID | VSH_BYNAME )
2008-08-01 17:51:18 +04:00
static void vshPrintExtra ( vshControl * ctl , const char * format , . . . )
2007-11-08 21:00:52 +03:00
ATTRIBUTE_FORMAT ( printf , 2 , 3 ) ;
2008-08-01 17:51:18 +04:00
static void vshDebug ( vshControl * ctl , int level , const char * format , . . . )
2007-11-08 21:00:52 +03:00
ATTRIBUTE_FORMAT ( printf , 3 , 4 ) ;
2006-05-29 19:39:31 +04:00
/* XXX: add batch support */
2006-05-22 18:38:33 +04:00
# define vshPrint(_ctl, ...) fprintf(stdout, __VA_ARGS__)
2005-12-08 13:23:34 +03:00
2005-12-08 17:22:52 +03:00
static const char * vshDomainStateToString ( int state ) ;
2006-08-07 18:35:20 +04:00
static const char * vshDomainVcpuStateToString ( int state ) ;
2008-08-01 17:51:18 +04:00
static int vshConnectionUsability ( vshControl * ctl , virConnectPtr conn ,
2006-03-15 15:13:25 +03:00
int showerror ) ;
2005-12-08 13:23:34 +03:00
2008-08-01 17:51:18 +04:00
static void * _vshMalloc ( vshControl * ctl , size_t sz , const char * filename , int line ) ;
2006-04-06 14:33:06 +04:00
# define vshMalloc(_ctl, _sz) _vshMalloc(_ctl, _sz, __FILE__, __LINE__)
2008-08-01 17:51:18 +04:00
static void * _vshCalloc ( vshControl * ctl , size_t nmemb , size_t sz , const char * filename , int line ) ;
2006-04-06 14:33:06 +04:00
# define vshCalloc(_ctl, _nmemb, _sz) _vshCalloc(_ctl, _nmemb, _sz, __FILE__, __LINE__)
2008-08-01 17:51:18 +04:00
static void * _vshRealloc ( vshControl * ctl , void * ptr , size_t sz , const char * filename , int line ) ;
2007-06-19 13:12:55 +04:00
# define vshRealloc(_ctl, _ptr, _sz) _vshRealloc(_ctl, _ptr, _sz, __FILE__, __LINE__)
2008-08-01 17:51:18 +04:00
static char * _vshStrdup ( vshControl * ctl , const char * s , const char * filename , int line ) ;
2006-04-06 14:33:06 +04:00
# define vshStrdup(_ctl, _s) _vshStrdup(_ctl, _s, __FILE__, __LINE__)
2007-02-14 18:44:58 +03:00
static int idsorter ( const void * a , const void * b ) {
const int * ia = ( const int * ) a ;
const int * ib = ( const int * ) b ;
if ( * ia > * ib )
return 1 ;
else if ( * ia < * ib )
return - 1 ;
return 0 ;
}
static int namesorter ( const void * a , const void * b ) {
const char * * sa = ( const char * * ) a ;
const char * * sb = ( const char * * ) b ;
return strcasecmp ( * sa , * sb ) ;
}
2009-02-09 17:24:06 +03:00
static virErrorPtr last_error ;
/*
* Quieten libvirt until we ' re done with the command .
*/
static void
virshErrorHandler ( void * unused ATTRIBUTE_UNUSED , virErrorPtr error )
{
virFreeError ( last_error ) ;
last_error = virSaveLastError ( ) ;
if ( getenv ( " VIRSH_DEBUG " ) ! = NULL )
virDefaultErrorFunc ( error ) ;
}
/*
* Report an error when a command finishes . This is better than before
* ( when correct operation would report errors ) , but it has some
* problems : we lose the smarter formatting of virDefaultErrorFunc ( ) ,
* and it can become harder to debug problems , if errors get reported
* twice during one command . This case shouldn ' t really happen anyway ,
* and it ' s IMHO a bug that libvirt does that sometimes .
*/
static void
virshReportError ( vshControl * ctl )
{
if ( last_error = = NULL )
return ;
if ( last_error - > code = = VIR_ERR_OK ) {
vshError ( ctl , FALSE , " %s " , _ ( " unknown error " ) ) ;
goto out ;
}
vshError ( ctl , FALSE , " %s " , last_error - > message ) ;
out :
virFreeError ( last_error ) ;
last_error = NULL ;
}
2007-02-14 18:44:58 +03:00
2005-12-08 13:23:34 +03:00
/* ---------------
* Commands
* - - - - - - - - - - - - - - -
*/
/*
2007-02-07 16:50:18 +03:00
* " help " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_help [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " print help " ) } ,
{ " desc " , gettext_noop ( " Prints global help or command specific help. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_help [ ] = {
2007-06-13 13:32:44 +04:00
{ " command " , VSH_OT_DATA , 0 , gettext_noop ( " name of command " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdHelp ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 17:22:52 +03:00
const char * cmdname = vshCommandOptString ( cmd , " command " , NULL ) ;
2005-12-08 13:23:34 +03:00
if ( ! cmdname ) {
2008-08-01 16:19:56 +04:00
const vshCmdDef * def ;
2006-03-15 15:13:25 +03:00
2008-01-16 20:13:23 +03:00
vshPrint ( ctl , " %s " , _ ( " Commands: \n \n " ) ) ;
2006-03-15 15:13:25 +03:00
for ( def = commands ; def - > name ; def + + )
2006-05-22 18:38:33 +04:00
vshPrint ( ctl , " %-15s %s \n " , def - > name ,
2007-06-15 12:18:55 +04:00
N_ ( vshCmddefGetInfo ( def , " help " ) ) ) ;
2005-12-08 13:23:34 +03:00
return TRUE ;
}
2008-12-08 16:14:48 +03:00
return vshCmddefHelp ( ctl , cmdname ) ;
2005-12-08 13:23:34 +03:00
}
2007-02-23 11:58:25 +03:00
/*
* " autostart " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_autostart [ ] = {
2007-02-23 11:58:25 +03:00
{ " help " , gettext_noop ( " autostart a domain " ) } ,
{ " desc " ,
gettext_noop ( " Configure a domain to be automatically started at boot. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_autostart [ ] = {
2007-02-23 11:58:25 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " disable " , VSH_OT_BOOL , 0 , gettext_noop ( " disable autostarting " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdAutostart ( vshControl * ctl , const vshCmd * cmd )
2007-02-23 11:58:25 +03:00
{
virDomainPtr dom ;
char * name ;
int autostart ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2007-02-23 11:58:25 +03:00
return FALSE ;
autostart = ! vshCommandOptBool ( cmd , " disable " ) ;
if ( virDomainSetAutostart ( dom , autostart ) < 0 ) {
2007-04-13 12:04:08 +04:00
if ( autostart )
2008-04-10 20:54:54 +04:00
vshError ( ctl , FALSE , _ ( " Failed to mark domain %s as autostarted " ) ,
2007-04-13 12:04:08 +04:00
name ) ;
2008-04-10 20:54:54 +04:00
else
vshError ( ctl , FALSE , _ ( " Failed to unmark domain %s as autostarted " ) ,
2007-04-13 12:04:08 +04:00
name ) ;
2007-02-23 11:58:25 +03:00
virDomainFree ( dom ) ;
return FALSE ;
}
2007-04-13 12:04:08 +04:00
if ( autostart )
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Domain %s marked as autostarted \n " ) , name ) ;
2007-04-13 12:04:08 +04:00
else
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Domain %s unmarked as autostarted \n " ) , name ) ;
2007-02-23 11:58:25 +03:00
2007-06-29 17:45:50 +04:00
virDomainFree ( dom ) ;
2007-02-23 11:58:25 +03:00
return TRUE ;
}
2005-12-08 13:23:34 +03:00
/*
2007-02-07 16:50:18 +03:00
* " connect " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_connect [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " (re)connect to hypervisor " ) } ,
2006-03-15 15:13:25 +03:00
{ " desc " ,
2006-09-21 19:24:37 +04:00
gettext_noop ( " Connect to local hypervisor. This is built-in command after shell start up. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_connect [ ] = {
2006-09-21 19:24:37 +04:00
{ " name " , VSH_OT_DATA , 0 , gettext_noop ( " hypervisor connection URI " ) } ,
{ " readonly " , VSH_OT_BOOL , 0 , gettext_noop ( " read-only connection " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdConnect ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
int ro = vshCommandOptBool ( cmd , " readonly " ) ;
2007-02-07 16:50:18 +03:00
2005-12-08 13:23:34 +03:00
if ( ctl - > conn ) {
2006-03-15 15:13:25 +03:00
if ( virConnectClose ( ctl - > conn ) ! = 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " ,
2006-09-21 19:24:37 +04:00
_ ( " Failed to disconnect from the hypervisor " ) ) ;
2005-12-08 13:23:34 +03:00
return FALSE ;
}
ctl - > conn = NULL ;
}
2007-02-07 16:50:18 +03:00
2008-01-29 20:41:07 +03:00
free ( ctl - > name ) ;
2007-01-22 23:43:02 +03:00
ctl - > name = vshStrdup ( ctl , vshCommandOptString ( cmd , " name " , NULL ) ) ;
2006-05-29 19:39:31 +04:00
2007-03-08 16:48:22 +03:00
if ( ! ro ) {
2006-05-29 19:39:31 +04:00
ctl - > conn = virConnectOpen ( ctl - > name ) ;
2007-03-08 16:48:22 +03:00
ctl - > readonly = 0 ;
} else {
2006-05-29 19:39:31 +04:00
ctl - > conn = virConnectOpenReadOnly ( ctl - > name ) ;
2007-03-08 16:48:22 +03:00
ctl - > readonly = 1 ;
}
2005-12-08 13:23:34 +03:00
if ( ! ctl - > conn )
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to connect to the hypervisor " ) ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
return ctl - > conn ? TRUE : FALSE ;
}
2007-01-26 14:54:29 +03:00
/*
2007-02-07 16:50:18 +03:00
* " console " command
2007-01-26 14:54:29 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_console [ ] = {
2007-01-26 14:54:29 +03:00
{ " help " , gettext_noop ( " connect to the guest console " ) } ,
{ " desc " ,
gettext_noop ( " Connect the virtual serial console for the guest " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_console [ ] = {
2007-01-26 14:54:29 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
2007-12-07 17:56:37 +03:00
# ifndef __MINGW32__
2007-01-26 14:54:29 +03:00
static int
2008-08-01 17:51:18 +04:00
cmdConsole ( vshControl * ctl , const vshCmd * cmd )
2007-01-26 14:54:29 +03:00
{
xmlDocPtr xml = NULL ;
xmlXPathObjectPtr obj = NULL ;
xmlXPathContextPtr ctxt = NULL ;
virDomainPtr dom ;
int ret = FALSE ;
char * doc ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-01-26 14:54:29 +03:00
return FALSE ;
doc = virDomainGetXMLDesc ( dom , 0 ) ;
if ( ! doc )
2007-02-07 16:50:18 +03:00
goto cleanup ;
2007-01-26 14:54:29 +03:00
xml = xmlReadDoc ( ( const xmlChar * ) doc , " domain.xml " , NULL ,
2007-02-07 16:50:18 +03:00
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOWARNING ) ;
2007-01-26 14:54:29 +03:00
free ( doc ) ;
if ( ! xml )
goto cleanup ;
ctxt = xmlXPathNewContext ( xml ) ;
if ( ! ctxt )
goto cleanup ;
obj = xmlXPathEval ( BAD_CAST " string(/domain/devices/console/@tty) " , ctxt ) ;
if ( ( obj ! = NULL ) & & ( ( obj - > type = = XPATH_STRING ) & &
2007-02-07 16:50:18 +03:00
( obj - > stringval ! = NULL ) & & ( obj - > stringval [ 0 ] ! = 0 ) ) ) {
2007-01-28 22:47:36 +03:00
if ( vshRunConsole ( ( const char * ) obj - > stringval ) = = 0 )
2007-01-26 14:54:29 +03:00
ret = TRUE ;
} else {
2008-01-16 20:13:23 +03:00
vshPrintExtra ( ctl , " %s " , _ ( " No console available for domain \n " ) ) ;
2007-01-26 14:54:29 +03:00
}
xmlXPathFreeObject ( obj ) ;
cleanup :
2008-01-29 21:23:43 +03:00
xmlXPathFreeContext ( ctxt ) ;
2007-01-26 14:54:29 +03:00
if ( xml )
xmlFreeDoc ( xml ) ;
virDomainFree ( dom ) ;
return ret ;
}
2007-12-07 17:56:37 +03:00
# else /* __MINGW32__ */
static int
2008-08-01 17:51:18 +04:00
cmdConsole ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2007-12-07 17:56:37 +03:00
{
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " console not implemented on this platform " ) ) ;
2007-12-07 17:56:37 +03:00
return FALSE ;
}
# endif /* __MINGW32__ */
2005-12-08 13:23:34 +03:00
/*
* " list " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_list [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " list domains " ) } ,
{ " desc " , gettext_noop ( " Returns list of domains. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_list [ ] = {
2006-09-21 19:24:37 +04:00
{ " inactive " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive domains " ) } ,
{ " all " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive & active domains " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , 0 , 0 , NULL }
} ;
2005-12-08 13:23:34 +03:00
static int
2008-08-01 17:51:18 +04:00
cmdList ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2006-03-15 15:13:25 +03:00
{
2006-08-30 18:32:32 +04:00
int inactive = vshCommandOptBool ( cmd , " inactive " ) ;
int all = vshCommandOptBool ( cmd , " all " ) ;
int active = ! inactive | | all ? 1 : 0 ;
int * ids = NULL , maxid = 0 , i ;
2007-03-07 00:55:44 +03:00
char * * names = NULL ;
2006-08-30 18:32:32 +04:00
int maxname = 0 ;
inactive | = all ;
2005-12-08 13:23:34 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2007-02-07 16:50:18 +03:00
2006-08-30 18:32:32 +04:00
if ( active ) {
2007-02-07 16:50:18 +03:00
maxid = virConnectNumOfDomains ( ctl - > conn ) ;
if ( maxid < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active domains " ) ) ;
2007-02-07 16:50:18 +03:00
return FALSE ;
}
if ( maxid ) {
ids = vshMalloc ( ctl , sizeof ( int ) * maxid ) ;
if ( ( maxid = virConnectListDomains ( ctl - > conn , & ids [ 0 ] , maxid ) ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active domains " ) ) ;
2007-02-07 16:50:18 +03:00
free ( ids ) ;
return FALSE ;
}
2007-02-14 18:44:58 +03:00
qsort ( & ids [ 0 ] , maxid , sizeof ( int ) , idsorter ) ;
2006-08-26 02:40:33 +04:00
}
2006-08-30 18:32:32 +04:00
}
if ( inactive ) {
2007-02-07 16:50:18 +03:00
maxname = virConnectNumOfDefinedDomains ( ctl - > conn ) ;
if ( maxname < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive domains " ) ) ;
2008-01-29 20:41:07 +03:00
free ( ids ) ;
2007-02-07 16:50:18 +03:00
return FALSE ;
2006-08-30 18:32:32 +04:00
}
2007-02-07 16:50:18 +03:00
if ( maxname ) {
names = vshMalloc ( ctl , sizeof ( char * ) * maxname ) ;
if ( ( maxname = virConnectListDefinedDomains ( ctl - > conn , names , maxname ) ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive domains " ) ) ;
2008-01-29 20:41:07 +03:00
free ( ids ) ;
2007-02-07 16:50:18 +03:00
free ( names ) ;
return FALSE ;
}
2006-09-03 21:34:04 +04:00
2007-02-14 18:44:58 +03:00
qsort ( & names [ 0 ] , maxname , sizeof ( char * ) , namesorter ) ;
2007-02-07 16:50:18 +03:00
}
2006-08-21 21:58:09 +04:00
}
2006-09-21 19:24:37 +04:00
vshPrintExtra ( ctl , " %3s %-20s %s \n " , _ ( " Id " ) , _ ( " Name " ) , _ ( " State " ) ) ;
2006-05-22 18:38:33 +04:00
vshPrintExtra ( ctl , " ---------------------------------- \n " ) ;
2006-03-15 15:13:25 +03:00
for ( i = 0 ; i < maxid ; i + + ) {
2005-12-08 13:23:34 +03:00
virDomainInfo info ;
virDomainPtr dom = virDomainLookupByID ( ctl - > conn , ids [ i ] ) ;
2007-02-23 11:58:25 +03:00
const char * state ;
2006-03-15 15:13:25 +03:00
/* this kind of work with domains is not atomic operation */
2005-12-08 13:23:34 +03:00
if ( ! dom )
continue ;
2007-02-23 11:58:25 +03:00
if ( virDomainGetInfo ( dom , & info ) < 0 )
state = _ ( " no state " ) ;
else
2007-06-15 12:18:55 +04:00
state = N_ ( vshDomainStateToString ( info . state ) ) ;
2006-03-15 15:13:25 +03:00
2006-05-22 18:38:33 +04:00
vshPrint ( ctl , " %3d %-20s %s \n " ,
2006-03-15 15:13:25 +03:00
virDomainGetID ( dom ) ,
virDomainGetName ( dom ) ,
2007-02-23 11:58:25 +03:00
state ) ;
2005-12-09 02:01:48 +03:00
virDomainFree ( dom ) ;
2005-12-08 13:23:34 +03:00
}
2006-08-30 18:32:32 +04:00
for ( i = 0 ; i < maxname ; i + + ) {
virDomainInfo info ;
virDomainPtr dom = virDomainLookupByName ( ctl - > conn , names [ i ] ) ;
2007-02-23 11:58:25 +03:00
const char * state ;
2006-08-30 18:32:32 +04:00
/* this kind of work with domains is not atomic operation */
2007-01-23 15:28:38 +03:00
if ( ! dom ) {
2007-02-07 16:50:18 +03:00
free ( names [ i ] ) ;
2006-08-30 18:32:32 +04:00
continue ;
2007-02-07 16:50:18 +03:00
}
2007-02-23 11:58:25 +03:00
if ( virDomainGetInfo ( dom , & info ) < 0 )
state = _ ( " no state " ) ;
else
2007-06-15 12:18:55 +04:00
state = N_ ( vshDomainStateToString ( info . state ) ) ;
2007-02-23 11:58:25 +03:00
vshPrint ( ctl , " %3s %-20s %s \n " , " - " , names [ i ] , state ) ;
2006-09-21 19:24:37 +04:00
2006-08-30 18:32:32 +04:00
virDomainFree ( dom ) ;
2007-02-07 16:50:18 +03:00
free ( names [ i ] ) ;
2006-08-30 18:32:32 +04:00
}
2008-01-29 20:41:07 +03:00
free ( ids ) ;
free ( names ) ;
2005-12-08 13:23:34 +03:00
return TRUE ;
}
/*
2006-04-05 01:52:31 +04:00
* " domstate " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domstate [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " domain state " ) } ,
2008-03-13 12:21:41 +03:00
{ " desc " , gettext_noop ( " Returns state about a domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domstate [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomstate ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-05 21:14:37 +03:00
virDomainInfo info ;
2005-12-08 13:23:34 +03:00
virDomainPtr dom ;
2005-12-15 20:00:43 +03:00
int ret = TRUE ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2005-12-05 21:14:37 +03:00
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2005-12-08 13:23:34 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainGetInfo ( dom , & info ) = = 0 )
2006-05-22 18:38:33 +04:00
vshPrint ( ctl , " %s \n " ,
2007-06-15 12:18:55 +04:00
N_ ( vshDomainStateToString ( info . state ) ) ) ;
2005-12-08 13:23:34 +03:00
else
ret = FALSE ;
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2007-08-21 14:08:12 +04:00
/* "domblkstat" command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domblkstat [ ] = {
2007-08-21 14:08:12 +04:00
{ " help " , gettext_noop ( " get device block stats for a domain " ) } ,
{ " desc " , gettext_noop ( " Get device block stats for a running domain. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domblkstat [ ] = {
2007-08-21 14:08:12 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " device " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " block device " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomblkstat ( vshControl * ctl , const vshCmd * cmd )
2007-08-21 14:08:12 +04:00
{
virDomainPtr dom ;
char * name , * device ;
struct _virDomainBlockStats stats ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2007-08-21 14:08:12 +04:00
return FALSE ;
if ( ! ( device = vshCommandOptString ( cmd , " device " , NULL ) ) )
return FALSE ;
if ( virDomainBlockStats ( dom , device , & stats , sizeof stats ) = = - 1 ) {
vshError ( ctl , FALSE , _ ( " Failed to get block stats %s %s " ) ,
name , device ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
if ( stats . rd_req > = 0 )
vshPrint ( ctl , " %s rd_req %lld \n " , device , stats . rd_req ) ;
if ( stats . rd_bytes > = 0 )
vshPrint ( ctl , " %s rd_bytes %lld \n " , device , stats . rd_bytes ) ;
if ( stats . wr_req > = 0 )
vshPrint ( ctl , " %s wr_req %lld \n " , device , stats . wr_req ) ;
if ( stats . wr_bytes > = 0 )
vshPrint ( ctl , " %s wr_bytes %lld \n " , device , stats . wr_bytes ) ;
if ( stats . errs > = 0 )
vshPrint ( ctl , " %s errs %lld \n " , device , stats . errs ) ;
virDomainFree ( dom ) ;
return TRUE ;
}
/* "domifstat" command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domifstat [ ] = {
2007-08-21 14:08:12 +04:00
{ " help " , gettext_noop ( " get network interface stats for a domain " ) } ,
{ " desc " , gettext_noop ( " Get network interface stats for a running domain. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domifstat [ ] = {
2007-08-21 14:08:12 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " interface " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " interface device " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomIfstat ( vshControl * ctl , const vshCmd * cmd )
2007-08-21 14:08:12 +04:00
{
virDomainPtr dom ;
char * name , * device ;
struct _virDomainInterfaceStats stats ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2007-08-21 14:08:12 +04:00
return FALSE ;
if ( ! ( device = vshCommandOptString ( cmd , " interface " , NULL ) ) )
return FALSE ;
if ( virDomainInterfaceStats ( dom , device , & stats , sizeof stats ) = = - 1 ) {
vshError ( ctl , FALSE , _ ( " Failed to get interface stats %s %s " ) ,
name , device ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
if ( stats . rx_bytes > = 0 )
vshPrint ( ctl , " %s rx_bytes %lld \n " , device , stats . rx_bytes ) ;
if ( stats . rx_packets > = 0 )
vshPrint ( ctl , " %s rx_packets %lld \n " , device , stats . rx_packets ) ;
if ( stats . rx_errs > = 0 )
vshPrint ( ctl , " %s rx_errs %lld \n " , device , stats . rx_errs ) ;
if ( stats . rx_drop > = 0 )
vshPrint ( ctl , " %s rx_drop %lld \n " , device , stats . rx_drop ) ;
if ( stats . tx_bytes > = 0 )
vshPrint ( ctl , " %s tx_bytes %lld \n " , device , stats . tx_bytes ) ;
if ( stats . tx_packets > = 0 )
vshPrint ( ctl , " %s tx_packets %lld \n " , device , stats . tx_packets ) ;
if ( stats . tx_errs > = 0 )
vshPrint ( ctl , " %s tx_errs %lld \n " , device , stats . tx_errs ) ;
if ( stats . tx_drop > = 0 )
vshPrint ( ctl , " %s tx_drop %lld \n " , device , stats . tx_drop ) ;
virDomainFree ( dom ) ;
return TRUE ;
}
2005-12-09 02:01:48 +03:00
/*
* " suspend " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_suspend [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " suspend a domain " ) } ,
{ " desc " , gettext_noop ( " Suspend a running domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-09 02:01:48 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_suspend [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-09 02:01:48 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSuspend ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-09 02:01:48 +03:00
virDomainPtr dom ;
2005-12-15 20:00:43 +03:00
char * name ;
int ret = TRUE ;
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2005-12-09 02:01:48 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainSuspend ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s suspended \n " ) , name ) ;
2005-12-09 02:01:48 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to suspend domain %s " ) , name ) ;
2005-12-09 02:01:48 +03:00
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2006-03-30 20:08:13 +04:00
/*
* " create " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_create [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " create a domain from an XML file " ) } ,
{ " desc " , gettext_noop ( " Create a domain. " ) } ,
2006-03-30 20:08:13 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_create [ ] = {
2007-06-15 12:18:55 +04:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML domain description " ) } ,
2006-03-30 20:08:13 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdCreate ( vshControl * ctl , const vshCmd * cmd )
2006-03-30 20:08:13 +04:00
{
virDomainPtr dom ;
char * from ;
int found ;
int ret = TRUE ;
2007-05-23 19:09:19 +04:00
char * buffer ;
2006-03-30 20:08:13 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
return FALSE ;
2008-01-21 18:27:14 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-05-23 19:09:19 +04:00
2008-10-10 13:32:27 +04:00
dom = virDomainCreateXML ( ctl - > conn , buffer , 0 ) ;
2007-05-23 19:09:19 +04:00
free ( buffer ) ;
2006-03-30 20:08:13 +04:00
if ( dom ! = NULL ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s created from %s \n " ) ,
2006-03-30 20:08:13 +04:00
virDomainGetName ( dom ) , from ) ;
2008-04-10 20:54:54 +04:00
virDomainFree ( dom ) ;
2006-03-30 20:08:13 +04:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to create domain from %s " ) , from ) ;
2006-03-30 20:08:13 +04:00
ret = FALSE ;
}
return ret ;
}
2006-08-30 18:32:32 +04:00
/*
* " define " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_define [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " define (but don't start) a domain from an XML file " ) } ,
{ " desc " , gettext_noop ( " Define a domain. " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_define [ ] = {
2007-04-10 22:40:50 +04:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML domain description " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDefine ( vshControl * ctl , const vshCmd * cmd )
2006-08-30 18:32:32 +04:00
{
virDomainPtr dom ;
char * from ;
int found ;
int ret = TRUE ;
2007-05-23 19:09:19 +04:00
char * buffer ;
2006-08-30 18:32:32 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
return FALSE ;
2008-01-21 18:27:14 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-05-23 19:09:19 +04:00
dom = virDomainDefineXML ( ctl - > conn , buffer ) ;
free ( buffer ) ;
2006-08-30 18:32:32 +04:00
if ( dom ! = NULL ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s defined from %s \n " ) ,
2006-08-30 18:32:32 +04:00
virDomainGetName ( dom ) , from ) ;
2007-06-29 17:45:50 +04:00
virDomainFree ( dom ) ;
2006-08-30 18:32:32 +04:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to define domain from %s " ) , from ) ;
2006-08-30 18:32:32 +04:00
ret = FALSE ;
}
return ret ;
}
/*
* " undefine " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_undefine [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " undefine an inactive domain " ) } ,
{ " desc " , gettext_noop ( " Undefine the configuration for an inactive domain. " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_undefine [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name or uuid " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdUndefine ( vshControl * ctl , const vshCmd * cmd )
2006-08-30 18:32:32 +04:00
{
virDomainPtr dom ;
int ret = TRUE ;
char * name ;
2008-07-22 20:12:01 +04:00
int found ;
int id ;
2006-08-30 18:32:32 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-07-22 20:12:01 +04:00
name = vshCommandOptString ( cmd , " domain " , & found ) ;
if ( ! found )
return FALSE ;
if ( name & & virStrToLong_i ( name , NULL , 10 , & id ) = = 0
& & id > = 0 & & ( dom = virDomainLookupByID ( ctl - > conn , id ) ) ) {
vshError ( ctl , FALSE , _ ( " a running domain like %s cannot be undefined; \n "
" to undefine, first shutdown then undefine "
" using its name or UUID " ) , name ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomainBy ( ctl , cmd , & name ,
2008-07-17 15:49:15 +04:00
VSH_BYNAME | VSH_BYUUID ) ) )
2006-08-30 18:32:32 +04:00
return FALSE ;
if ( virDomainUndefine ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s has been undefined \n " ) , name ) ;
2006-08-30 18:32:32 +04:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to undefine domain %s " ) , name ) ;
2006-08-30 18:32:32 +04:00
ret = FALSE ;
}
2007-06-29 17:45:50 +04:00
virDomainFree ( dom ) ;
2006-08-30 18:32:32 +04:00
return ret ;
}
/*
* " start " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_start [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " start a (previously defined) inactive domain " ) } ,
{ " desc " , gettext_noop ( " Start a domain. " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_start [ ] = {
2008-12-08 16:22:44 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " name of the inactive domain " ) } ,
2006-08-30 18:32:32 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdStart ( vshControl * ctl , const vshCmd * cmd )
2006-08-30 18:32:32 +04:00
{
virDomainPtr dom ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomainBy ( ctl , cmd , NULL , VSH_BYNAME ) ) )
2006-08-30 18:32:32 +04:00
return FALSE ;
if ( virDomainGetID ( dom ) ! = ( unsigned int ) - 1 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Domain is already active " ) ) ;
2008-04-10 20:54:54 +04:00
virDomainFree ( dom ) ;
2006-08-30 18:32:32 +04:00
return FALSE ;
}
if ( virDomainCreate ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s started \n " ) ,
2007-02-23 13:27:53 +03:00
virDomainGetName ( dom ) ) ;
2006-08-30 18:32:32 +04:00
} else {
2007-02-23 13:27:53 +03:00
vshError ( ctl , FALSE , _ ( " Failed to start domain %s " ) ,
virDomainGetName ( dom ) ) ;
2006-08-30 18:32:32 +04:00
ret = FALSE ;
}
2007-06-29 17:45:50 +04:00
virDomainFree ( dom ) ;
2006-08-30 18:32:32 +04:00
return ret ;
}
2006-01-20 13:00:08 +03:00
/*
* " save " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_save [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " save a domain state to a file " ) } ,
{ " desc " , gettext_noop ( " Save a running domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2006-01-20 13:00:08 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_save [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " where to save the data " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2006-01-20 13:00:08 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSave ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2006-01-20 13:00:08 +03:00
virDomainPtr dom ;
char * name ;
char * to ;
int ret = TRUE ;
2006-03-15 15:13:25 +03:00
2006-01-20 13:00:08 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2006-01-25 12:46:22 +03:00
if ( ! ( to = vshCommandOptString ( cmd , " file " , NULL ) ) )
2006-01-20 13:00:08 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2006-01-20 13:00:08 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainSave ( dom , to ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s saved to %s \n " ) , name , to ) ;
2006-01-20 13:00:08 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to save domain %s to %s " ) , name , to ) ;
2006-01-20 13:00:08 +03:00
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2006-01-20 13:00:08 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2007-06-05 16:06:08 +04:00
/*
* " schedinfo " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_schedinfo [ ] = {
2007-06-05 16:06:08 +04:00
{ " help " , gettext_noop ( " show/set scheduler parameters " ) } ,
{ " desc " , gettext_noop ( " Show/Set scheduler parameters. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_schedinfo [ ] = {
2007-06-05 16:06:08 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2008-10-08 20:28:48 +04:00
{ " set " , VSH_OT_STRING , VSH_OFLAG_NONE , gettext_noop ( " parameter=value " ) } ,
2007-06-05 16:06:08 +04:00
{ " weight " , VSH_OT_INT , VSH_OFLAG_NONE , gettext_noop ( " weight for XEN_CREDIT " ) } ,
{ " cap " , VSH_OT_INT , VSH_OFLAG_NONE , gettext_noop ( " cap for XEN_CREDIT " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSchedinfo ( vshControl * ctl , const vshCmd * cmd )
2007-06-05 16:06:08 +04:00
{
char * schedulertype ;
2008-10-08 20:28:48 +04:00
char * set ;
char * param_name = NULL ;
long long int param_value = 0 ;
2007-06-05 16:06:08 +04:00
virDomainPtr dom ;
2007-08-21 15:53:52 +04:00
virSchedParameterPtr params = NULL ;
2007-06-05 16:06:08 +04:00
int i , ret ;
int nparams = 0 ;
int nr_inputparams = 0 ;
int inputparams = 0 ;
int weightfound = 0 ;
2008-10-08 20:28:48 +04:00
int setfound = 0 ;
2007-11-08 21:07:02 +03:00
int weight = 0 ;
2007-06-05 16:06:08 +04:00
int capfound = 0 ;
2007-11-08 21:07:02 +03:00
int cap = 0 ;
2007-06-05 16:06:08 +04:00
char str_weight [ ] = " weight " ;
char str_cap [ ] = " cap " ;
2007-08-21 15:53:52 +04:00
int ret_val = FALSE ;
2007-06-05 16:06:08 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-06-05 16:06:08 +04:00
return FALSE ;
2008-10-08 20:28:48 +04:00
/* Deprecated Xen-only options */
2007-11-06 12:41:18 +03:00
if ( vshCommandOptBool ( cmd , " weight " ) ) {
weight = vshCommandOptInt ( cmd , " weight " , & weightfound ) ;
if ( ! weightfound ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Invalid value of weight " ) ) ;
2007-11-06 12:41:18 +03:00
goto cleanup ;
} else {
nr_inputparams + + ;
}
}
if ( vshCommandOptBool ( cmd , " cap " ) ) {
cap = vshCommandOptInt ( cmd , " cap " , & capfound ) ;
if ( ! capfound ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Invalid value of cap " ) ) ;
2007-11-06 12:41:18 +03:00
goto cleanup ;
} else {
nr_inputparams + + ;
}
}
2007-06-05 16:06:08 +04:00
2008-10-08 20:28:48 +04:00
if ( vshCommandOptBool ( cmd , " set " ) ) {
set = vshCommandOptString ( cmd , " set " , & setfound ) ;
if ( ! setfound ) {
vshError ( ctl , FALSE , " %s " , _ ( " Error getting param " ) ) ;
goto cleanup ;
}
param_name = vshMalloc ( ctl , strlen ( set ) + 1 ) ;
if ( param_name = = NULL )
goto cleanup ;
2008-10-09 18:50:25 +04:00
if ( sscanf ( set , " %[^=]=%lli " , param_name , & param_value ) ! = 2 ) {
2008-10-08 20:28:48 +04:00
vshError ( ctl , FALSE , " %s " , _ ( " Invalid value of param " ) ) ;
goto cleanup ;
}
nr_inputparams + + ;
}
2007-06-05 16:06:08 +04:00
params = vshMalloc ( ctl , sizeof ( virSchedParameter ) * nr_inputparams ) ;
2007-06-29 17:45:50 +04:00
if ( params = = NULL ) {
2007-08-21 15:53:52 +04:00
goto cleanup ;
2007-06-29 17:45:50 +04:00
}
2007-06-05 16:06:08 +04:00
if ( weightfound ) {
strncpy ( params [ inputparams ] . field , str_weight , sizeof ( str_weight ) ) ;
params [ inputparams ] . type = VIR_DOMAIN_SCHED_FIELD_UINT ;
params [ inputparams ] . value . ui = weight ;
2008-02-05 22:27:37 +03:00
inputparams + + ;
2007-06-05 16:06:08 +04:00
}
if ( capfound ) {
strncpy ( params [ inputparams ] . field , str_cap , sizeof ( str_cap ) ) ;
params [ inputparams ] . type = VIR_DOMAIN_SCHED_FIELD_UINT ;
params [ inputparams ] . value . ui = cap ;
inputparams + + ;
}
2008-10-08 20:28:48 +04:00
/* End Deprecated Xen-only options */
if ( setfound ) {
strncpy ( params [ inputparams ] . field , param_name , sizeof ( params [ 0 ] . field ) ) ;
params [ inputparams ] . type = VIR_DOMAIN_SCHED_FIELD_LLONG ;
params [ inputparams ] . value . l = param_value ;
inputparams + + ;
}
2007-06-05 16:06:08 +04:00
assert ( inputparams = = nr_inputparams ) ;
/* Set SchedulerParameters */
if ( inputparams > 0 ) {
ret = virDomainSetSchedulerParameters ( dom , params , inputparams ) ;
2007-06-29 17:45:50 +04:00
if ( ret = = - 1 ) {
2007-08-21 15:53:52 +04:00
goto cleanup ;
2008-04-10 20:54:54 +04:00
}
2007-06-05 16:06:08 +04:00
}
free ( params ) ;
2007-08-21 15:53:52 +04:00
params = NULL ;
2007-06-05 16:06:08 +04:00
/* Print SchedulerType */
schedulertype = virDomainGetSchedulerType ( dom , & nparams ) ;
if ( schedulertype ! = NULL ) {
2007-06-13 13:32:44 +04:00
vshPrint ( ctl , " %-15s: %s \n " , _ ( " Scheduler " ) ,
2007-06-05 16:06:08 +04:00
schedulertype ) ;
free ( schedulertype ) ;
} else {
2007-06-13 13:32:44 +04:00
vshPrint ( ctl , " %-15s: %s \n " , _ ( " Scheduler " ) , _ ( " Unknown " ) ) ;
2007-08-21 15:53:52 +04:00
goto cleanup ;
2007-06-05 16:06:08 +04:00
}
/* Get SchedulerParameters */
params = vshMalloc ( ctl , sizeof ( virSchedParameter ) * nparams ) ;
2007-08-21 15:53:52 +04:00
if ( params = = NULL ) {
goto cleanup ;
}
2007-06-05 16:06:08 +04:00
for ( i = 0 ; i < nparams ; i + + ) {
params [ i ] . type = 0 ;
memset ( params [ i ] . field , 0 , sizeof params [ i ] . field ) ;
}
ret = virDomainGetSchedulerParameters ( dom , params , & nparams ) ;
2007-06-29 17:45:50 +04:00
if ( ret = = - 1 ) {
2007-08-21 15:53:52 +04:00
goto cleanup ;
2007-06-29 17:45:50 +04:00
}
2007-08-21 15:53:52 +04:00
ret_val = TRUE ;
2007-06-05 16:06:08 +04:00
if ( nparams ) {
for ( i = 0 ; i < nparams ; i + + ) {
switch ( params [ i ] . type ) {
case VIR_DOMAIN_SCHED_FIELD_INT :
printf ( " %-15s: %d \n " , params [ i ] . field , params [ i ] . value . i ) ;
break ;
case VIR_DOMAIN_SCHED_FIELD_UINT :
printf ( " %-15s: %u \n " , params [ i ] . field , params [ i ] . value . ui ) ;
break ;
case VIR_DOMAIN_SCHED_FIELD_LLONG :
printf ( " %-15s: %Ld \n " , params [ i ] . field , params [ i ] . value . l ) ;
break ;
case VIR_DOMAIN_SCHED_FIELD_ULLONG :
printf ( " %-15s: %Lu \n " , params [ i ] . field , params [ i ] . value . ul ) ;
break ;
case VIR_DOMAIN_SCHED_FIELD_DOUBLE :
printf ( " %-15s: %f \n " , params [ i ] . field , params [ i ] . value . d ) ;
break ;
case VIR_DOMAIN_SCHED_FIELD_BOOLEAN :
printf ( " %-15s: %d \n " , params [ i ] . field , params [ i ] . value . b ) ;
break ;
default :
printf ( " not implemented scheduler parameter type \n " ) ;
}
}
}
2007-08-21 15:53:52 +04:00
cleanup :
2008-01-29 20:41:07 +03:00
free ( params ) ;
2008-10-08 20:28:48 +04:00
free ( param_name ) ;
2007-06-29 17:45:50 +04:00
virDomainFree ( dom ) ;
2007-08-21 15:53:52 +04:00
return ret_val ;
2007-06-05 16:06:08 +04:00
}
2006-01-20 13:00:08 +03:00
/*
* " restore " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_restore [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " restore a domain from a saved state in a file " ) } ,
{ " desc " , gettext_noop ( " Restore a domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2006-01-20 13:00:08 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_restore [ ] = {
2006-09-21 19:24:37 +04:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " the state to restore " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2006-01-20 13:00:08 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdRestore ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2006-01-20 13:00:08 +03:00
char * from ;
int found ;
int ret = TRUE ;
2006-03-15 15:13:25 +03:00
2006-01-20 13:00:08 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainRestore ( ctl - > conn , from ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain restored from %s \n " ) , from ) ;
2006-01-20 13:00:08 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to restore domain from %s " ) , from ) ;
2006-01-20 13:00:08 +03:00
ret = FALSE ;
}
return ret ;
}
2006-11-22 20:48:29 +03:00
/*
* " dump " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_dump [ ] = {
2006-11-22 20:48:29 +03:00
{ " help " , gettext_noop ( " dump the core of a domain to a file for analysis " ) } ,
{ " desc " , gettext_noop ( " Core dump a domain. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_dump [ ] = {
2006-11-22 20:48:29 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " where to dump the core " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDump ( vshControl * ctl , const vshCmd * cmd )
2006-11-22 20:48:29 +03:00
{
virDomainPtr dom ;
char * name ;
char * to ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( to = vshCommandOptString ( cmd , " file " , NULL ) ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2006-11-22 20:48:29 +03:00
return FALSE ;
if ( virDomainCoreDump ( dom , to , 0 ) = = 0 ) {
2008-08-15 05:41:49 +04:00
vshPrint ( ctl , _ ( " Domain %s dumped to %s \n " ) , name , to ) ;
2006-11-22 20:48:29 +03:00
} else {
vshError ( ctl , FALSE , _ ( " Failed to core dump domain %s to %s " ) ,
name , to ) ;
ret = FALSE ;
}
virDomainFree ( dom ) ;
return ret ;
}
2005-12-09 02:01:48 +03:00
/*
* " resume " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_resume [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " resume a domain " ) } ,
{ " desc " , gettext_noop ( " Resume a previously suspended domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-09 02:01:48 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_resume [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-09 02:01:48 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdResume ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-09 02:01:48 +03:00
virDomainPtr dom ;
2005-12-15 20:00:43 +03:00
int ret = TRUE ;
char * name ;
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2005-12-09 02:01:48 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainResume ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s resumed \n " ) , name ) ;
2005-12-09 02:01:48 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to resume domain %s " ) , name ) ;
2005-12-09 02:01:48 +03:00
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2005-12-16 15:16:41 +03:00
/*
* " shutdown " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_shutdown [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " gracefully shutdown a domain " ) } ,
{ " desc " , gettext_noop ( " Run shutdown in the target domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-16 15:16:41 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_shutdown [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-16 15:16:41 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdShutdown ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-16 15:16:41 +03:00
virDomainPtr dom ;
int ret = TRUE ;
char * name ;
2006-03-15 15:13:25 +03:00
2005-12-16 15:16:41 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2005-12-16 15:16:41 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainShutdown ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s is being shutdown \n " ) , name ) ;
2005-12-16 15:16:41 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to shutdown domain %s " ) , name ) ;
2005-12-16 15:16:41 +03:00
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2005-12-16 15:16:41 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2006-04-03 17:46:43 +04:00
/*
* " reboot " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_reboot [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " reboot a domain " ) } ,
{ " desc " , gettext_noop ( " Run a reboot command in the target domain. " ) } ,
2006-04-03 17:46:43 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_reboot [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-04-03 17:46:43 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdReboot ( vshControl * ctl , const vshCmd * cmd )
2006-04-03 17:46:43 +04:00
{
virDomainPtr dom ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2006-04-03 17:46:43 +04:00
return FALSE ;
if ( virDomainReboot ( dom , 0 ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s is being rebooted \n " ) , name ) ;
2006-04-03 17:46:43 +04:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to reboot domain %s " ) , name ) ;
2006-04-03 17:46:43 +04:00
ret = FALSE ;
}
virDomainFree ( dom ) ;
return ret ;
}
2005-12-09 02:01:48 +03:00
/*
* " destroy " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_destroy [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " destroy a domain " ) } ,
{ " desc " , gettext_noop ( " Destroy a given domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-09 02:01:48 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_destroy [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-09 02:01:48 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDestroy ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-09 02:01:48 +03:00
virDomainPtr dom ;
2005-12-15 20:00:43 +03:00
int ret = TRUE ;
char * name ;
2006-03-15 15:13:25 +03:00
2005-12-09 02:01:48 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , & name ) ) )
2005-12-09 02:01:48 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
if ( virDomainDestroy ( dom ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " Domain %s destroyed \n " ) , name ) ;
2005-12-09 02:01:48 +03:00
} else {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " Failed to destroy domain %s " ) , name ) ;
2005-12-09 02:01:48 +03:00
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2008-05-22 00:53:30 +04:00
virDomainFree ( dom ) ;
2005-12-08 13:23:34 +03:00
return ret ;
}
/*
2006-04-04 18:37:32 +04:00
* " dominfo " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_dominfo [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " domain information " ) } ,
{ " desc " , gettext_noop ( " Returns basic information about the domain. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_dominfo [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDominfo ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
virDomainInfo info ;
virDomainPtr dom ;
2008-05-27 13:41:25 +04:00
int ret = TRUE , autostart ;
2006-09-03 21:34:04 +04:00
unsigned int id ;
Mon Jan 23 14:36:18 IST 2007 Mark McLoughlin <markmc@redhat.com>
* include/libvirt/libvirt.h.in: add VIR_UUID_BUFLEN and
VIR_UUID_STRING_BUFLEN
* libvirt/proxy/libvirt_proxy.c, libvirt/src/hash.c,
libvirt/src/internal.h, libvirt/src/libvirt.c,
libvirt/src/proxy_internal.c, libvirt/src/test.c,
libvirt/src/virsh.c, libvirt/src/xend_internal.c,
libvirt/src/xm_internal.c, libvirt/src/xml.c,
libvirt/python/libvir.c: use them
2007-01-23 17:39:45 +03:00
char * str , uuid [ VIR_UUID_STRING_BUFLEN ] ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2005-12-08 13:23:34 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
2006-09-03 21:34:04 +04:00
id = virDomainGetID ( dom ) ;
if ( id = = ( ( unsigned int ) - 1 ) )
2007-02-07 16:50:18 +03:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " Id: " ) , " - " ) ;
2006-09-03 21:34:04 +04:00
else
2007-02-07 16:50:18 +03:00
vshPrint ( ctl , " %-15s %d \n " , _ ( " Id: " ) , id ) ;
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " Name: " ) , virDomainGetName ( dom ) ) ;
2006-05-22 18:38:33 +04:00
if ( virDomainGetUUIDString ( dom , & uuid [ 0 ] ) = = 0 )
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " UUID: " ) , uuid ) ;
2006-03-15 15:13:25 +03:00
if ( ( str = virDomainGetOSType ( dom ) ) ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " OS Type: " ) , str ) ;
2006-03-15 15:13:25 +03:00
free ( str ) ;
}
if ( virDomainGetInfo ( dom , & info ) = = 0 ) {
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
2007-06-15 12:18:55 +04:00
N_ ( vshDomainStateToString ( info . state ) ) ) ;
2006-03-15 15:13:25 +03:00
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %d \n " , _ ( " CPU(s): " ) , info . nrVirtCpu ) ;
2006-03-15 15:13:25 +03:00
if ( info . cpuTime ! = 0 ) {
2007-02-07 16:50:18 +03:00
double cpuUsed = info . cpuTime ;
2006-03-15 15:13:25 +03:00
2006-06-13 23:08:40 +04:00
cpuUsed / = 1000000000.0 ;
2006-03-15 15:13:25 +03:00
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , " %-15s %.1lfs \n " , _ ( " CPU time: " ) , cpuUsed ) ;
2005-12-08 13:23:34 +03:00
}
2006-03-15 15:13:25 +03:00
2007-03-15 17:27:09 +03:00
if ( info . maxMem ! = UINT_MAX )
vshPrint ( ctl , " %-15s %lu kB \n " , _ ( " Max memory: " ) ,
2006-03-15 15:13:25 +03:00
info . maxMem ) ;
2007-03-15 17:27:09 +03:00
else
2008-05-29 18:56:12 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " Max memory: " ) ,
2007-03-15 17:27:09 +03:00
_ ( " no limit " ) ) ;
2007-02-07 16:50:18 +03:00
vshPrint ( ctl , " %-15s %lu kB \n " , _ ( " Used memory: " ) ,
2006-03-15 15:13:25 +03:00
info . memory ) ;
2005-12-08 13:23:34 +03:00
} else {
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2008-05-27 13:41:25 +04:00
if ( ! virDomainGetAutostart ( dom , & autostart ) ) {
2008-05-29 18:56:12 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " Autostart: " ) ,
2008-05-27 13:41:25 +04:00
autostart ? _ ( " enable " ) : _ ( " disable " ) ) ;
}
2005-12-09 02:01:48 +03:00
virDomainFree ( dom ) ;
2005-12-08 13:23:34 +03:00
return ret ;
}
2007-09-28 18:28:12 +04:00
/*
* " freecell " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_freecell [ ] = {
2007-09-28 18:28:12 +04:00
{ " help " , gettext_noop ( " NUMA free memory " ) } ,
{ " desc " , gettext_noop ( " display available free memory for the NUMA cell. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_freecell [ ] = {
2007-09-28 18:28:12 +04:00
{ " cellno " , VSH_OT_DATA , 0 , gettext_noop ( " NUMA cell number " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdFreecell ( vshControl * ctl , const vshCmd * cmd )
2007-09-28 18:28:12 +04:00
{
int ret ;
int cell , cell_given ;
unsigned long long memory ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
cell = vshCommandOptInt ( cmd , " cellno " , & cell_given ) ;
if ( ! cell_given ) {
2007-09-30 17:22:16 +04:00
memory = virNodeGetFreeMemory ( ctl - > conn ) ;
} else {
2008-04-10 20:54:54 +04:00
ret = virNodeGetCellsFreeMemory ( ctl - > conn , & memory , cell , 1 ) ;
if ( ret ! = 1 )
return FALSE ;
2007-09-28 18:28:12 +04:00
}
if ( cell = = - 1 )
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , " %s: %llu kB \n " , _ ( " Total " ) , memory ) ;
2007-09-28 18:28:12 +04:00
else
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , " %d: %llu kB \n " , cell , memory ) ;
2007-09-28 18:28:12 +04:00
return TRUE ;
}
2006-08-07 18:35:20 +04:00
/*
* " vcpuinfo " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vcpuinfo [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " domain vcpu information " ) } ,
{ " desc " , gettext_noop ( " Returns basic information about the domain virtual CPUs. " ) } ,
2006-08-07 18:35:20 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vcpuinfo [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2006-08-07 18:35:20 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVcpuinfo ( vshControl * ctl , const vshCmd * cmd )
2006-08-07 18:35:20 +04:00
{
virDomainInfo info ;
virDomainPtr dom ;
virNodeInfo nodeinfo ;
virVcpuInfoPtr cpuinfo ;
unsigned char * cpumap ;
int ncpus ;
size_t cpumaplen ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2006-08-07 18:35:20 +04:00
return FALSE ;
if ( virNodeGetInfo ( ctl - > conn , & nodeinfo ) ! = 0 ) {
virDomainFree ( dom ) ;
2007-02-07 16:50:18 +03:00
return FALSE ;
2006-08-07 18:35:20 +04:00
}
if ( virDomainGetInfo ( dom , & info ) ! = 0 ) {
virDomainFree ( dom ) ;
return FALSE ;
}
2007-03-22 21:30:57 +03:00
cpuinfo = vshMalloc ( ctl , sizeof ( virVcpuInfo ) * info . nrVirtCpu ) ;
2006-08-07 18:35:20 +04:00
cpumaplen = VIR_CPU_MAPLEN ( VIR_NODEINFO_MAXCPUS ( nodeinfo ) ) ;
2007-03-22 21:30:57 +03:00
cpumap = vshMalloc ( ctl , info . nrVirtCpu * cpumaplen ) ;
2006-08-07 18:35:20 +04:00
2007-02-07 16:50:18 +03:00
if ( ( ncpus = virDomainGetVcpus ( dom ,
cpuinfo , info . nrVirtCpu ,
cpumap , cpumaplen ) ) > = 0 ) {
2006-08-07 18:35:20 +04:00
int n ;
2007-02-07 16:50:18 +03:00
for ( n = 0 ; n < ncpus ; n + + ) {
unsigned int m ;
vshPrint ( ctl , " %-15s %d \n " , _ ( " VCPU: " ) , n ) ;
vshPrint ( ctl , " %-15s %d \n " , _ ( " CPU: " ) , cpuinfo [ n ] . cpu ) ;
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
2007-06-15 12:18:55 +04:00
N_ ( vshDomainVcpuStateToString ( cpuinfo [ n ] . state ) ) ) ;
2007-02-07 16:50:18 +03:00
if ( cpuinfo [ n ] . cpuTime ! = 0 ) {
double cpuUsed = cpuinfo [ n ] . cpuTime ;
cpuUsed / = 1000000000.0 ;
vshPrint ( ctl , " %-15s %.1lfs \n " , _ ( " CPU time: " ) , cpuUsed ) ;
}
vshPrint ( ctl , " %-15s " , _ ( " CPU Affinity: " ) ) ;
for ( m = 0 ; m < VIR_NODEINFO_MAXCPUS ( nodeinfo ) ; m + + ) {
vshPrint ( ctl , " %c " , VIR_CPU_USABLE ( cpumap , cpumaplen , n , m ) ? ' y ' : ' - ' ) ;
}
vshPrint ( ctl , " \n " ) ;
if ( n < ( ncpus - 1 ) ) {
vshPrint ( ctl , " \n " ) ;
}
}
2006-08-07 18:35:20 +04:00
} else {
2007-06-15 12:18:55 +04:00
if ( info . state = = VIR_DOMAIN_SHUTOFF ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " ,
2007-06-15 12:18:55 +04:00
_ ( " Domain shut off, virtual CPUs not present. " ) ) ;
}
2006-08-07 18:35:20 +04:00
ret = FALSE ;
}
free ( cpumap ) ;
free ( cpuinfo ) ;
virDomainFree ( dom ) ;
return ret ;
}
/*
* " vcpupin " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vcpupin [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " control domain vcpu affinity " ) } ,
{ " desc " , gettext_noop ( " Pin domain VCPUs to host physical CPUs. " ) } ,
2006-08-07 18:35:20 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vcpupin [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " vcpu " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vcpu number " ) } ,
{ " cpulist " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " host cpu number(s) (comma separated) " ) } ,
2006-08-07 18:35:20 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVcpupin ( vshControl * ctl , const vshCmd * cmd )
2006-08-07 18:35:20 +04:00
{
virDomainInfo info ;
virDomainPtr dom ;
virNodeInfo nodeinfo ;
int vcpu ;
char * cpulist ;
int ret = TRUE ;
int vcpufound = 0 ;
unsigned char * cpumap ;
int cpumaplen ;
2007-06-19 13:32:04 +04:00
int i ;
enum { expect_num , expect_num_or_comma } state ;
2006-08-07 18:35:20 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2006-08-07 18:35:20 +04:00
return FALSE ;
vcpu = vshCommandOptInt ( cmd , " vcpu " , & vcpufound ) ;
if ( ! vcpufound ) {
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 16:43:01 +03:00
vshError ( ctl , FALSE , " %s " ,
_ ( " vcpupin: Invalid or missing vCPU number. " ) ) ;
2006-08-07 18:35:20 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
if ( ! ( cpulist = vshCommandOptString ( cmd , " cpulist " , NULL ) ) ) {
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 16:43:01 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " vcpupin: Missing cpulist " ) ) ;
2006-08-07 18:35:20 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
2007-02-07 16:50:18 +03:00
2006-08-07 18:35:20 +04:00
if ( virNodeGetInfo ( ctl - > conn , & nodeinfo ) ! = 0 ) {
virDomainFree ( dom ) ;
return FALSE ;
}
if ( virDomainGetInfo ( dom , & info ) ! = 0 ) {
2008-04-04 15:20:45 +04:00
vshError ( ctl , FALSE , " %s " ,
2008-04-10 20:54:54 +04:00
_ ( " vcpupin: failed to get domain informations. " ) ) ;
2006-08-07 18:35:20 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
if ( vcpu > = info . nrVirtCpu ) {
2008-04-28 13:09:52 +04:00
vshError ( ctl , FALSE , " %s " , _ ( " vcpupin: Invalid vCPU number. " ) ) ;
2006-08-07 18:35:20 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
2007-06-19 13:32:04 +04:00
/* Check that the cpulist parameter is a comma-separated list of
* numbers and give an intelligent error message if not .
*/
if ( cpulist [ 0 ] = = ' \0 ' ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " cpulist: Invalid format. Empty string. " ) ) ;
2007-06-19 13:32:04 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
state = expect_num ;
for ( i = 0 ; cpulist [ i ] ; i + + ) {
switch ( state ) {
case expect_num :
2008-05-09 17:50:14 +04:00
if ( ! c_isdigit ( cpulist [ i ] ) ) {
2007-06-19 13:32:04 +04:00
vshError ( ctl , FALSE , _ ( " cpulist: %s: Invalid format. Expecting digit at position %d (near '%c'). " ) , cpulist , i , cpulist [ i ] ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
state = expect_num_or_comma ;
break ;
case expect_num_or_comma :
if ( cpulist [ i ] = = ' , ' )
state = expect_num ;
2008-05-09 17:50:14 +04:00
else if ( ! c_isdigit ( cpulist [ i ] ) ) {
2007-06-19 13:32:04 +04:00
vshError ( ctl , FALSE , _ ( " cpulist: %s: Invalid format. Expecting digit or comma at position %d (near '%c'). " ) , cpulist , i , cpulist [ i ] ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
}
}
if ( state = = expect_num ) {
vshError ( ctl , FALSE , _ ( " cpulist: %s: Invalid format. Trailing comma at position %d. " ) , cpulist , i ) ;
virDomainFree ( dom ) ;
return FALSE ;
}
2006-08-07 18:35:20 +04:00
cpumaplen = VIR_CPU_MAPLEN ( VIR_NODEINFO_MAXCPUS ( nodeinfo ) ) ;
2007-03-22 21:30:57 +03:00
cpumap = vshCalloc ( ctl , 1 , cpumaplen ) ;
2006-08-07 18:35:20 +04:00
do {
unsigned int cpu = atoi ( cpulist ) ;
if ( cpu < VIR_NODEINFO_MAXCPUS ( nodeinfo ) ) {
VIR_USE_CPU ( cpumap , cpu ) ;
2007-03-22 13:27:54 +03:00
} else {
vshError ( ctl , FALSE , _ ( " Physical CPU %d doesn't exist. " ) , cpu ) ;
free ( cpumap ) ;
virDomainFree ( dom ) ;
return FALSE ;
2006-08-07 18:35:20 +04:00
}
2007-06-15 17:44:19 +04:00
cpulist = strchr ( cpulist , ' , ' ) ;
2006-08-07 18:35:20 +04:00
if ( cpulist )
cpulist + + ;
} while ( cpulist ) ;
if ( virDomainPinVcpu ( dom , vcpu , cpumap , cpumaplen ) ! = 0 ) {
ret = FALSE ;
}
free ( cpumap ) ;
virDomainFree ( dom ) ;
return ret ;
}
2006-08-16 21:30:33 +04:00
/*
* " setvcpus " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_setvcpus [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " change number of virtual CPUs " ) } ,
2008-03-13 12:21:41 +03:00
{ " desc " , gettext_noop ( " Change the number of virtual CPUs in the guest domain. " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_setvcpus [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " count " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " number of virtual CPUs " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSetvcpus ( vshControl * ctl , const vshCmd * cmd )
2006-08-16 21:30:33 +04:00
{
virDomainPtr dom ;
int count ;
2007-03-08 11:31:07 +03:00
int maxcpu ;
2006-08-16 21:30:33 +04:00
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2006-08-16 21:30:33 +04:00
return FALSE ;
count = vshCommandOptInt ( cmd , " count " , & count ) ;
2007-08-15 14:18:33 +04:00
if ( count < = 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Invalid number of virtual CPUs. " ) ) ;
2006-08-16 21:30:33 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
2007-03-08 11:31:07 +03:00
maxcpu = virDomainGetMaxVcpus ( dom ) ;
2007-08-15 14:18:33 +04:00
if ( maxcpu < = 0 ) {
2007-03-08 11:31:07 +03:00
virDomainFree ( dom ) ;
return FALSE ;
}
if ( count > maxcpu ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Too many virtual CPUs. " ) ) ;
2007-03-08 11:31:07 +03:00
virDomainFree ( dom ) ;
return FALSE ;
}
2006-08-16 21:30:33 +04:00
if ( virDomainSetVcpus ( dom , count ) ! = 0 ) {
ret = FALSE ;
}
virDomainFree ( dom ) ;
return ret ;
}
/*
* " setmemory " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_setmem [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " change memory allocation " ) } ,
{ " desc " , gettext_noop ( " Change the current memory allocation in the guest domain. " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_setmem [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2007-04-02 15:56:38 +04:00
{ " kilobytes " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " number of kilobytes of memory " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSetmem ( vshControl * ctl , const vshCmd * cmd )
2006-08-16 21:30:33 +04:00
{
virDomainPtr dom ;
2007-06-18 12:33:08 +04:00
virDomainInfo info ;
2007-04-02 15:56:38 +04:00
int kilobytes ;
2006-08-16 21:30:33 +04:00
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2006-08-16 21:30:33 +04:00
return FALSE ;
2007-04-02 15:56:38 +04:00
kilobytes = vshCommandOptInt ( cmd , " kilobytes " , & kilobytes ) ;
if ( kilobytes < = 0 ) {
2006-08-16 21:30:33 +04:00
virDomainFree ( dom ) ;
2007-04-02 15:56:38 +04:00
vshError ( ctl , FALSE , _ ( " Invalid value of %d for memory size " ) , kilobytes ) ;
2006-08-16 21:30:33 +04:00
return FALSE ;
}
2007-06-18 12:33:08 +04:00
if ( virDomainGetInfo ( dom , & info ) ! = 0 ) {
virDomainFree ( dom ) ;
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Unable to verify MaxMemorySize " ) ) ;
2007-06-18 12:33:08 +04:00
return FALSE ;
}
if ( kilobytes > info . maxMem ) {
virDomainFree ( dom ) ;
vshError ( ctl , FALSE , _ ( " Invalid value of %d for memory size " ) , kilobytes ) ;
return FALSE ;
}
2007-04-02 15:56:38 +04:00
if ( virDomainSetMemory ( dom , kilobytes ) ! = 0 ) {
2006-08-16 21:30:33 +04:00
ret = FALSE ;
}
virDomainFree ( dom ) ;
return ret ;
}
/*
* " setmaxmem " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_setmaxmem [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " change maximum memory limit " ) } ,
{ " desc " , gettext_noop ( " Change the maximum memory allocation limit in the guest domain. " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_setmaxmem [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2007-04-10 22:40:50 +04:00
{ " kilobytes " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " maximum memory limit in kilobytes " ) } ,
2006-08-16 21:30:33 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdSetmaxmem ( vshControl * ctl , const vshCmd * cmd )
2006-08-16 21:30:33 +04:00
{
virDomainPtr dom ;
2007-06-18 12:33:08 +04:00
virDomainInfo info ;
2007-04-02 15:56:38 +04:00
int kilobytes ;
2006-08-16 21:30:33 +04:00
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2006-08-16 21:30:33 +04:00
return FALSE ;
2007-04-02 15:56:38 +04:00
kilobytes = vshCommandOptInt ( cmd , " kilobytes " , & kilobytes ) ;
if ( kilobytes < = 0 ) {
2006-08-16 21:30:33 +04:00
virDomainFree ( dom ) ;
2007-04-02 15:56:38 +04:00
vshError ( ctl , FALSE , _ ( " Invalid value of %d for memory size " ) , kilobytes ) ;
2006-08-16 21:30:33 +04:00
return FALSE ;
}
2007-06-18 12:33:08 +04:00
if ( virDomainGetInfo ( dom , & info ) ! = 0 ) {
virDomainFree ( dom ) ;
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Unable to verify current MemorySize " ) ) ;
2007-06-18 12:33:08 +04:00
return FALSE ;
}
if ( kilobytes < info . memory ) {
if ( virDomainSetMemory ( dom , kilobytes ) ! = 0 ) {
virDomainFree ( dom ) ;
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Unable to shrink current MemorySize " ) ) ;
2007-06-18 12:33:08 +04:00
return FALSE ;
}
}
2007-04-02 15:56:38 +04:00
if ( virDomainSetMaxMemory ( dom , kilobytes ) ! = 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Unable to change MaxMemorySize " ) ) ;
2006-08-16 21:30:33 +04:00
ret = FALSE ;
}
virDomainFree ( dom ) ;
return ret ;
}
2006-04-04 18:37:32 +04:00
/*
* " nodeinfo " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_nodeinfo [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " node information " ) } ,
{ " desc " , gettext_noop ( " Returns basic information about the node. " ) } ,
2006-04-04 18:37:32 +04:00
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNodeinfo ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2006-04-04 18:37:32 +04:00
{
virNodeInfo info ;
2006-09-21 19:24:37 +04:00
2006-04-04 18:37:32 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( virNodeGetInfo ( ctl - > conn , & info ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to get node information " ) ) ;
2006-09-21 19:24:37 +04:00
return FALSE ;
}
vshPrint ( ctl , " %-20s %s \n " , _ ( " CPU model: " ) , info . model ) ;
vshPrint ( ctl , " %-20s %d \n " , _ ( " CPU(s): " ) , info . cpus ) ;
vshPrint ( ctl , " %-20s %d MHz \n " , _ ( " CPU frequency: " ) , info . mhz ) ;
vshPrint ( ctl , " %-20s %d \n " , _ ( " CPU socket(s): " ) , info . sockets ) ;
vshPrint ( ctl , " %-20s %d \n " , _ ( " Core(s) per socket: " ) , info . cores ) ;
vshPrint ( ctl , " %-20s %d \n " , _ ( " Thread(s) per core: " ) , info . threads ) ;
vshPrint ( ctl , " %-20s %d \n " , _ ( " NUMA cell(s): " ) , info . nodes ) ;
vshPrint ( ctl , " %-20s %lu kB \n " , _ ( " Memory size: " ) , info . memory ) ;
2006-04-04 18:37:32 +04:00
return TRUE ;
}
2007-03-15 20:24:56 +03:00
/*
* " capabilities " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_capabilities [ ] = {
2007-03-15 20:24:56 +03:00
{ " help " , gettext_noop ( " capabilities " ) } ,
{ " desc " , gettext_noop ( " Returns capabilities of hypervisor/driver. " ) } ,
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdCapabilities ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2007-03-15 20:24:56 +03:00
{
char * caps ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ( caps = virConnectGetCapabilities ( ctl - > conn ) ) = = NULL ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to get capabilities " ) ) ;
2007-03-15 20:24:56 +03:00
return FALSE ;
}
vshPrint ( ctl , " %s \n " , caps ) ;
2008-01-30 22:57:54 +03:00
free ( caps ) ;
2007-03-15 20:24:56 +03:00
return TRUE ;
}
2005-12-13 19:22:05 +03:00
/*
* " dumpxml " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_dumpxml [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " domain information in XML " ) } ,
2007-04-10 22:40:50 +04:00
{ " desc " , gettext_noop ( " Output the domain information as an XML dump to stdout. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-13 19:22:05 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_dumpxml [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
2009-01-29 20:50:00 +03:00
{ " inactive " , VSH_OT_BOOL , 0 , gettext_noop ( " show inactive defined XML " ) } ,
{ " security-info " , VSH_OT_BOOL , 0 , gettext_noop ( " include security sensitive information in XML dump " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-13 19:22:05 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDumpXML ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-13 19:22:05 +03:00
virDomainPtr dom ;
2005-12-15 20:00:43 +03:00
int ret = TRUE ;
2005-12-13 19:22:05 +03:00
char * dump ;
2009-01-29 20:50:00 +03:00
int flags = 0 ;
int inactive = vshCommandOptBool ( cmd , " inactive " ) ;
int secure = vshCommandOptBool ( cmd , " security-info " ) ;
if ( inactive )
flags | = VIR_DOMAIN_XML_INACTIVE ;
if ( secure )
flags | = VIR_DOMAIN_XML_SECURE ;
2006-03-15 15:13:25 +03:00
2005-12-13 19:22:05 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2005-12-13 19:22:05 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
2009-01-29 20:50:00 +03:00
dump = virDomainGetXMLDesc ( dom , flags ) ;
2005-12-13 19:22:05 +03:00
if ( dump ! = NULL ) {
printf ( " %s " , dump ) ;
free ( dump ) ;
} else {
ret = FALSE ;
}
2006-03-15 15:13:25 +03:00
2005-12-13 19:22:05 +03:00
virDomainFree ( dom ) ;
return ret ;
}
2005-12-08 13:23:34 +03:00
/*
2006-04-05 01:52:31 +04:00
* " domname " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domname [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " convert a domain id or UUID to domain name " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domname [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain id or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomname ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
virDomainPtr dom ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomainBy ( ctl , cmd , NULL ,
2007-02-14 18:44:58 +03:00
VSH_BYID | VSH_BYUUID ) ) )
2005-12-08 13:23:34 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
2006-05-29 19:39:31 +04:00
vshPrint ( ctl , " %s \n " , virDomainGetName ( dom ) ) ;
virDomainFree ( dom ) ;
2005-12-08 13:23:34 +03:00
return TRUE ;
}
/*
2006-04-05 01:52:31 +04:00
* " domid " command
2005-12-08 13:23:34 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domid [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " convert a domain name or UUID to domain id " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domid [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name or uuid " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , 0 , 0 , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomid ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-05 14:16:07 +03:00
virDomainPtr dom ;
2006-09-03 21:34:04 +04:00
unsigned int id ;
2005-12-08 13:23:34 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomainBy ( ctl , cmd , NULL ,
2007-02-14 18:44:58 +03:00
VSH_BYNAME | VSH_BYUUID ) ) )
2005-12-08 13:23:34 +03:00
return FALSE ;
2007-02-07 16:50:18 +03:00
2006-09-03 21:34:04 +04:00
id = virDomainGetID ( dom ) ;
if ( id = = ( ( unsigned int ) - 1 ) )
2007-02-07 16:50:18 +03:00
vshPrint ( ctl , " %s \n " , " - " ) ;
2006-09-03 21:34:04 +04:00
else
2007-02-07 16:50:18 +03:00
vshPrint ( ctl , " %d \n " , id ) ;
2006-05-29 19:39:31 +04:00
virDomainFree ( dom ) ;
return TRUE ;
}
2006-03-15 15:13:25 +03:00
2006-05-29 19:39:31 +04:00
/*
* " domuuid " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_domuuid [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " convert a domain name or id to domain UUID " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2006-05-29 19:39:31 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_domuuid [ ] = {
2006-09-21 19:24:37 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain id or name " ) } ,
2006-05-29 19:39:31 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDomuuid ( vshControl * ctl , const vshCmd * cmd )
2006-05-29 19:39:31 +04:00
{
virDomainPtr dom ;
Mon Jan 23 14:36:18 IST 2007 Mark McLoughlin <markmc@redhat.com>
* include/libvirt/libvirt.h.in: add VIR_UUID_BUFLEN and
VIR_UUID_STRING_BUFLEN
* libvirt/proxy/libvirt_proxy.c, libvirt/src/hash.c,
libvirt/src/internal.h, libvirt/src/libvirt.c,
libvirt/src/proxy_internal.c, libvirt/src/test.c,
libvirt/src/virsh.c, libvirt/src/xend_internal.c,
libvirt/src/xm_internal.c, libvirt/src/xml.c,
libvirt/python/libvir.c: use them
2007-01-23 17:39:45 +03:00
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
2006-05-29 19:39:31 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
2005-12-08 13:23:34 +03:00
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomainBy ( ctl , cmd , NULL ,
2007-02-14 18:44:58 +03:00
VSH_BYNAME | VSH_BYID ) ) )
2006-05-29 19:39:31 +04:00
return FALSE ;
2006-09-21 19:24:37 +04:00
2006-05-29 19:39:31 +04:00
if ( virDomainGetUUIDString ( dom , uuid ) ! = - 1 )
vshPrint ( ctl , " %s \n " , uuid ) ;
else
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to get domain UUID " ) ) ;
2006-09-21 19:24:37 +04:00
2008-01-30 22:58:59 +03:00
virDomainFree ( dom ) ;
2005-12-08 13:23:34 +03:00
return TRUE ;
}
2007-08-21 13:31:12 +04:00
/*
* " migrate " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_migrate [ ] = {
2007-08-21 13:31:12 +04:00
{ " help " , gettext_noop ( " migrate domain to another host " ) } ,
{ " desc " , gettext_noop ( " Migrate domain to another host. Add --live for live migration. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_migrate [ ] = {
2007-08-21 13:31:12 +04:00
{ " live " , VSH_OT_BOOL , 0 , gettext_noop ( " live migration " ) } ,
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " desturi " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " connection URI of the destination host " ) } ,
{ " migrateuri " , VSH_OT_DATA , 0 , gettext_noop ( " migration URI, usually can be omitted " ) } ,
2008-11-14 11:42:47 +03:00
{ " dname " , VSH_OT_DATA , 0 , gettext_noop ( " rename to new name during migration (if supported) " ) } ,
2007-08-21 13:31:12 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdMigrate ( vshControl * ctl , const vshCmd * cmd )
2007-08-21 13:31:12 +04:00
{
virDomainPtr dom = NULL ;
const char * desturi ;
const char * migrateuri ;
2008-11-14 11:42:47 +03:00
const char * dname ;
2007-08-21 13:31:12 +04:00
int flags = 0 , found , ret = FALSE ;
virConnectPtr dconn = NULL ;
virDomainPtr ddom = NULL ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-08-21 13:31:12 +04:00
return FALSE ;
desturi = vshCommandOptString ( cmd , " desturi " , & found ) ;
if ( ! found ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " migrate: Missing desturi " ) ) ;
2007-08-21 13:31:12 +04:00
goto done ;
}
2009-01-30 18:43:05 +03:00
migrateuri = vshCommandOptString ( cmd , " migrateuri " , NULL ) ;
2007-08-21 13:31:12 +04:00
2009-01-30 18:43:05 +03:00
dname = vshCommandOptString ( cmd , " dname " , NULL ) ;
2008-11-14 11:42:47 +03:00
2007-08-21 13:31:12 +04:00
if ( vshCommandOptBool ( cmd , " live " ) )
flags | = VIR_MIGRATE_LIVE ;
/* Temporarily connect to the destination host. */
dconn = virConnectOpen ( desturi ) ;
if ( ! dconn ) goto done ;
/* Migrate. */
2008-11-14 11:42:47 +03:00
ddom = virDomainMigrate ( dom , dconn , flags , dname , migrateuri , 0 ) ;
2007-08-21 13:31:12 +04:00
if ( ! ddom ) goto done ;
ret = TRUE ;
done :
if ( dom ) virDomainFree ( dom ) ;
if ( ddom ) virDomainFree ( ddom ) ;
if ( dconn ) virConnectClose ( dconn ) ;
return ret ;
}
2007-02-23 11:58:25 +03:00
/*
* " net-autostart " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_autostart [ ] = {
2007-02-23 11:58:25 +03:00
{ " help " , gettext_noop ( " autostart a network " ) } ,
{ " desc " ,
gettext_noop ( " Configure a network to be automatically started at boot. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_autostart [ ] = {
2007-02-23 11:58:25 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name or uuid " ) } ,
{ " disable " , VSH_OT_BOOL , 0 , gettext_noop ( " disable autostarting " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkAutostart ( vshControl * ctl , const vshCmd * cmd )
2007-02-23 11:58:25 +03:00
{
virNetworkPtr network ;
char * name ;
int autostart ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetwork ( ctl , cmd , & name ) ) )
2007-02-23 11:58:25 +03:00
return FALSE ;
autostart = ! vshCommandOptBool ( cmd , " disable " ) ;
if ( virNetworkSetAutostart ( network , autostart ) < 0 ) {
2007-04-13 12:04:08 +04:00
if ( autostart )
2008-04-10 20:54:54 +04:00
vshError ( ctl , FALSE , _ ( " failed to mark network %s as autostarted " ) ,
2007-04-13 12:04:08 +04:00
name ) ;
2008-04-10 20:54:54 +04:00
else
vshError ( ctl , FALSE , _ ( " failed to unmark network %s as autostarted " ) ,
2007-04-13 12:04:08 +04:00
name ) ;
2007-02-23 11:58:25 +03:00
virNetworkFree ( network ) ;
return FALSE ;
}
2007-04-13 12:04:08 +04:00
if ( autostart )
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Network %s marked as autostarted \n " ) , name ) ;
2007-04-13 12:04:08 +04:00
else
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Network %s unmarked as autostarted \n " ) , name ) ;
2007-02-23 11:58:25 +03:00
return TRUE ;
}
2006-05-29 19:39:31 +04:00
2007-02-14 19:53:55 +03:00
/*
* " net-create " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_create [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " create a network from an XML file " ) } ,
{ " desc " , gettext_noop ( " Create a network. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_create [ ] = {
2007-02-14 19:53:55 +03:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML network description " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkCreate ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
char * from ;
int found ;
int ret = TRUE ;
2007-05-23 19:09:19 +04:00
char * buffer ;
2007-02-14 19:53:55 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
return FALSE ;
2008-01-21 18:27:14 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-05-23 19:09:19 +04:00
network = virNetworkCreateXML ( ctl - > conn , buffer ) ;
free ( buffer ) ;
2007-02-14 19:53:55 +03:00
if ( network ! = NULL ) {
vshPrint ( ctl , _ ( " Network %s created from %s \n " ) ,
virNetworkGetName ( network ) , from ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to create network from %s " ) , from ) ;
ret = FALSE ;
}
return ret ;
}
/*
* " net-define " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_define [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " define (but don't start) a network from an XML file " ) } ,
{ " desc " , gettext_noop ( " Define a network. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_define [ ] = {
2007-04-10 22:40:50 +04:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML network description " ) } ,
2007-02-14 19:53:55 +03:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkDefine ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
char * from ;
int found ;
int ret = TRUE ;
2007-05-23 19:09:19 +04:00
char * buffer ;
2007-02-14 19:53:55 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
return FALSE ;
2008-01-21 18:27:14 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-05-23 19:09:19 +04:00
network = virNetworkDefineXML ( ctl - > conn , buffer ) ;
free ( buffer ) ;
2007-02-14 19:53:55 +03:00
if ( network ! = NULL ) {
vshPrint ( ctl , _ ( " Network %s defined from %s \n " ) ,
virNetworkGetName ( network ) , from ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to define network from %s " ) , from ) ;
ret = FALSE ;
}
return ret ;
}
/*
* " net-destroy " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_destroy [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " destroy a network " ) } ,
{ " desc " , gettext_noop ( " Destroy a given network. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_destroy [ ] = {
2007-02-14 19:53:55 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkDestroy ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetwork ( ctl , cmd , & name ) ) )
2007-02-14 19:53:55 +03:00
return FALSE ;
if ( virNetworkDestroy ( network ) = = 0 ) {
vshPrint ( ctl , _ ( " Network %s destroyed \n " ) , name ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to destroy network %s " ) , name ) ;
ret = FALSE ;
}
2008-05-22 00:53:30 +04:00
virNetworkFree ( network ) ;
2007-02-14 19:53:55 +03:00
return ret ;
}
/*
* " net-dumpxml " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_dumpxml [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " network information in XML " ) } ,
2007-04-10 22:40:50 +04:00
{ " desc " , gettext_noop ( " Output the network information as an XML dump to stdout. " ) } ,
2007-02-14 19:53:55 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_dumpxml [ ] = {
2007-02-14 19:53:55 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkDumpXML ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
int ret = TRUE ;
char * dump ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetwork ( ctl , cmd , NULL ) ) )
2007-02-14 19:53:55 +03:00
return FALSE ;
dump = virNetworkGetXMLDesc ( network , 0 ) ;
if ( dump ! = NULL ) {
printf ( " %s " , dump ) ;
free ( dump ) ;
} else {
ret = FALSE ;
}
virNetworkFree ( network ) ;
return ret ;
}
/*
* " net-list " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_list [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " list networks " ) } ,
{ " desc " , gettext_noop ( " Returns list of networks. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_list [ ] = {
2007-02-14 19:53:55 +03:00
{ " inactive " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive networks " ) } ,
{ " all " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive & active networks " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkList ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2007-02-14 19:53:55 +03:00
{
int inactive = vshCommandOptBool ( cmd , " inactive " ) ;
int all = vshCommandOptBool ( cmd , " all " ) ;
int active = ! inactive | | all ? 1 : 0 ;
int maxactive = 0 , maxinactive = 0 , i ;
2007-03-07 00:55:44 +03:00
char * * activeNames = NULL , * * inactiveNames = NULL ;
2007-02-14 19:53:55 +03:00
inactive | = all ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( active ) {
2007-02-20 21:25:46 +03:00
maxactive = virConnectNumOfNetworks ( ctl - > conn ) ;
if ( maxactive < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active networks " ) ) ;
2007-02-20 21:25:46 +03:00
return FALSE ;
2007-02-14 19:53:55 +03:00
}
2007-02-20 21:25:46 +03:00
if ( maxactive ) {
2007-03-09 16:44:24 +03:00
activeNames = vshMalloc ( ctl , sizeof ( char * ) * maxactive ) ;
2007-02-20 21:25:46 +03:00
2007-03-09 16:44:24 +03:00
if ( ( maxactive = virConnectListNetworks ( ctl - > conn , activeNames ,
2008-04-10 20:54:54 +04:00
maxactive ) ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active networks " ) ) ;
2007-02-20 21:25:46 +03:00
free ( activeNames ) ;
return FALSE ;
}
2007-02-14 19:53:55 +03:00
2007-03-09 16:44:24 +03:00
qsort ( & activeNames [ 0 ] , maxactive , sizeof ( char * ) , namesorter ) ;
2007-02-20 21:25:46 +03:00
}
2007-02-14 19:53:55 +03:00
}
if ( inactive ) {
2007-02-20 21:25:46 +03:00
maxinactive = virConnectNumOfDefinedNetworks ( ctl - > conn ) ;
if ( maxinactive < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive networks " ) ) ;
2008-01-29 20:41:07 +03:00
free ( activeNames ) ;
2007-02-20 21:25:46 +03:00
return FALSE ;
2007-02-14 19:53:55 +03:00
}
2007-02-20 21:25:46 +03:00
if ( maxinactive ) {
inactiveNames = vshMalloc ( ctl , sizeof ( char * ) * maxinactive ) ;
if ( ( maxinactive = virConnectListDefinedNetworks ( ctl - > conn , inactiveNames , maxinactive ) ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive networks " ) ) ;
2008-01-29 20:41:07 +03:00
free ( activeNames ) ;
2007-02-20 21:25:46 +03:00
free ( inactiveNames ) ;
return FALSE ;
}
2007-02-14 19:53:55 +03:00
2007-02-20 21:25:46 +03:00
qsort ( & inactiveNames [ 0 ] , maxinactive , sizeof ( char * ) , namesorter ) ;
}
2007-02-14 19:53:55 +03:00
}
2007-02-23 11:58:25 +03:00
vshPrintExtra ( ctl , " %-20s %-10s %-10s \n " , _ ( " Name " ) , _ ( " State " ) , _ ( " Autostart " ) ) ;
vshPrintExtra ( ctl , " ----------------------------------------- \n " ) ;
2007-02-14 19:53:55 +03:00
for ( i = 0 ; i < maxactive ; i + + ) {
virNetworkPtr network = virNetworkLookupByName ( ctl - > conn , activeNames [ i ] ) ;
2007-02-23 11:58:25 +03:00
const char * autostartStr ;
int autostart = 0 ;
2007-02-14 19:53:55 +03:00
/* this kind of work with networks is not atomic operation */
if ( ! network ) {
free ( activeNames [ i ] ) ;
continue ;
2007-02-20 21:25:46 +03:00
}
2007-02-14 19:53:55 +03:00
2007-02-23 11:58:25 +03:00
if ( virNetworkGetAutostart ( network , & autostart ) < 0 )
autostartStr = _ ( " no autostart " ) ;
else
autostartStr = autostart ? " yes " : " no " ;
vshPrint ( ctl , " %-20s %-10s %-10s \n " ,
virNetworkGetName ( network ) ,
_ ( " active " ) ,
autostartStr ) ;
2007-02-14 19:53:55 +03:00
virNetworkFree ( network ) ;
free ( activeNames [ i ] ) ;
}
for ( i = 0 ; i < maxinactive ; i + + ) {
virNetworkPtr network = virNetworkLookupByName ( ctl - > conn , inactiveNames [ i ] ) ;
2007-02-23 11:58:25 +03:00
const char * autostartStr ;
int autostart = 0 ;
2007-02-14 19:53:55 +03:00
/* this kind of work with networks is not atomic operation */
if ( ! network ) {
free ( inactiveNames [ i ] ) ;
continue ;
2007-02-20 21:25:46 +03:00
}
2007-02-14 19:53:55 +03:00
2007-02-23 11:58:25 +03:00
if ( virNetworkGetAutostart ( network , & autostart ) < 0 )
autostartStr = _ ( " no autostart " ) ;
else
autostartStr = autostart ? " yes " : " no " ;
vshPrint ( ctl , " %-20s %s %s \n " ,
inactiveNames [ i ] ,
_ ( " inactive " ) ,
autostartStr ) ;
2007-02-14 19:53:55 +03:00
virNetworkFree ( network ) ;
free ( inactiveNames [ i ] ) ;
}
2008-01-29 20:41:07 +03:00
free ( activeNames ) ;
free ( inactiveNames ) ;
2007-02-14 19:53:55 +03:00
return TRUE ;
}
/*
* " net-name " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_name [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " convert a network UUID to network name " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2007-02-14 19:53:55 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_name [ ] = {
2007-02-14 19:53:55 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkName ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetworkBy ( ctl , cmd , NULL ,
2008-04-10 20:54:54 +04:00
VSH_BYUUID ) ) )
2007-02-14 19:53:55 +03:00
return FALSE ;
vshPrint ( ctl , " %s \n " , virNetworkGetName ( network ) ) ;
virNetworkFree ( network ) ;
return TRUE ;
}
/*
* " net-start " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_start [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " start a (previously defined) inactive network " ) } ,
{ " desc " , gettext_noop ( " Start a network. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_start [ ] = {
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " name of the inactive network " ) } ,
2007-02-14 19:53:55 +03:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkStart ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetworkBy ( ctl , cmd , NULL , VSH_BYNAME ) ) )
2007-02-23 13:27:53 +03:00
return FALSE ;
2007-02-14 19:53:55 +03:00
if ( virNetworkCreate ( network ) = = 0 ) {
vshPrint ( ctl , _ ( " Network %s started \n " ) ,
2007-02-23 13:27:53 +03:00
virNetworkGetName ( network ) ) ;
2007-02-14 19:53:55 +03:00
} else {
2007-02-23 13:27:53 +03:00
vshError ( ctl , FALSE , _ ( " Failed to start network %s " ) ,
virNetworkGetName ( network ) ) ;
2007-02-14 19:53:55 +03:00
ret = FALSE ;
}
return ret ;
}
/*
* " net-undefine " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_undefine [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " undefine an inactive network " ) } ,
{ " desc " , gettext_noop ( " Undefine the configuration for an inactive network. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_undefine [ ] = {
2007-02-14 19:53:55 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkUndefine ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetwork ( ctl , cmd , & name ) ) )
2007-02-14 19:53:55 +03:00
return FALSE ;
if ( virNetworkUndefine ( network ) = = 0 ) {
vshPrint ( ctl , _ ( " Network %s has been undefined \n " ) , name ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to undefine network %s " ) , name ) ;
ret = FALSE ;
}
return ret ;
}
/*
* " net-uuid " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_network_uuid [ ] = {
2007-02-14 19:53:55 +03:00
{ " help " , gettext_noop ( " convert a network name to network UUID " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2007-02-14 19:53:55 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_network_uuid [ ] = {
2007-02-14 19:53:55 +03:00
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdNetworkUuid ( vshControl * ctl , const vshCmd * cmd )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network ;
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( network = vshCommandOptNetworkBy ( ctl , cmd , NULL ,
2008-04-10 20:54:54 +04:00
VSH_BYNAME ) ) )
2007-02-14 19:53:55 +03:00
return FALSE ;
if ( virNetworkGetUUIDString ( network , uuid ) ! = - 1 )
vshPrint ( ctl , " %s \n " , uuid ) ;
else
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to get network UUID " ) ) ;
2007-02-14 19:53:55 +03:00
return TRUE ;
}
2005-12-08 16:26:52 +03:00
/*
2008-02-20 18:27:08 +03:00
* " pool-autostart " command
2005-12-08 16:26:52 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_autostart [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " autostart a pool " ) } ,
{ " desc " ,
gettext_noop ( " Configure a pool to be automatically started at boot. " ) } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 16:26:52 +03:00
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_autostart [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ " disable " , VSH_OT_BOOL , 0 , gettext_noop ( " disable autostarting " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
2005-12-08 16:26:52 +03:00
static int
2008-08-01 17:51:18 +04:00
cmdPoolAutostart ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2008-02-20 18:27:08 +03:00
virStoragePoolPtr pool ;
char * name ;
int autostart ;
2005-12-08 16:26:52 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2006-03-15 15:13:25 +03:00
2008-02-20 18:27:08 +03:00
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
2005-12-08 16:26:52 +03:00
return FALSE ;
2008-02-20 18:27:08 +03:00
autostart = ! vshCommandOptBool ( cmd , " disable " ) ;
2005-12-08 18:08:46 +03:00
2008-02-20 18:27:08 +03:00
if ( virStoragePoolSetAutostart ( pool , autostart ) < 0 ) {
if ( autostart )
2008-04-10 20:54:54 +04:00
vshError ( ctl , FALSE , _ ( " failed to mark pool %s as autostarted " ) ,
2008-02-20 18:27:08 +03:00
name ) ;
2008-04-10 20:54:54 +04:00
else
vshError ( ctl , FALSE , _ ( " failed to unmark pool %s as autostarted " ) ,
2008-02-20 18:27:08 +03:00
name ) ;
virStoragePoolFree ( pool ) ;
2005-12-08 18:08:46 +03:00
return FALSE ;
}
2008-02-20 18:27:08 +03:00
if ( autostart )
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Pool %s marked as autostarted \n " ) , name ) ;
2008-02-20 18:27:08 +03:00
else
2008-04-10 20:54:54 +04:00
vshPrint ( ctl , _ ( " Pool %s unmarked as autostarted \n " ) , name ) ;
2005-12-08 16:26:52 +03:00
return TRUE ;
}
2007-01-26 14:54:29 +03:00
/*
2008-02-20 18:27:08 +03:00
* " pool-create " command
2007-06-26 15:42:46 +04:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_create [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " create a pool from an XML file " ) } ,
{ " desc " , gettext_noop ( " Create a pool. " ) } ,
2007-06-26 15:42:46 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_create [ ] = {
2008-11-24 10:13:29 +03:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ ,
gettext_noop ( " file containing an XML pool description " ) } ,
2008-02-20 18:27:08 +03:00
{ NULL , 0 , 0 , NULL }
} ;
2007-06-26 15:42:46 +04:00
static int
2008-08-01 17:51:18 +04:00
cmdPoolCreate ( vshControl * ctl , const vshCmd * cmd )
2007-06-26 15:42:46 +04:00
{
2008-02-20 18:27:08 +03:00
virStoragePoolPtr pool ;
char * from ;
int found ;
int ret = TRUE ;
char * buffer ;
2007-06-26 15:42:46 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-02-20 18:27:08 +03:00
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
2007-06-26 15:42:46 +04:00
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-06-26 15:42:46 +04:00
2008-02-20 18:27:08 +03:00
pool = virStoragePoolCreateXML ( ctl - > conn , buffer , 0 ) ;
free ( buffer ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s created from %s \n " ) ,
virStoragePoolGetName ( pool ) , from ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to create pool from %s " ) , from ) ;
ret = FALSE ;
}
return ret ;
2007-06-26 15:42:46 +04:00
}
2008-12-22 19:23:36 +03:00
2008-02-20 18:29:13 +03:00
/*
2008-12-22 19:23:36 +03:00
* XML Building helper for pool - define - as and pool - create - as
2008-02-20 18:29:13 +03:00
*/
2008-12-22 19:23:36 +03:00
static const vshCmdOptDef opts_pool_X_as [ ] = {
2008-02-20 18:29:13 +03:00
{ " name " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " name of the pool " ) } ,
{ " type " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " type of the pool " ) } ,
{ " source-host " , VSH_OT_DATA , 0 , gettext_noop ( " source-host for underlying storage " ) } ,
{ " source-path " , VSH_OT_DATA , 0 , gettext_noop ( " source path for underlying storage " ) } ,
{ " source-dev " , VSH_OT_DATA , 0 , gettext_noop ( " source device for underlying storage " ) } ,
2008-12-22 19:23:36 +03:00
{ " source-name " , VSH_OT_DATA , 0 , gettext_noop ( " source name for underlying storage " ) } ,
2008-02-20 18:29:13 +03:00
{ " target " , VSH_OT_DATA , 0 , gettext_noop ( " target for underlying storage " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
2008-12-22 19:23:36 +03:00
static int buildPoolXML ( const vshCmd * cmd , char * * retname , char * * xml ) {
2008-02-20 18:29:13 +03:00
int found ;
2008-12-22 19:23:36 +03:00
char * name , * type , * srcHost , * srcPath , * srcDev , * srcName , * target ;
2008-04-28 19:14:59 +04:00
virBuffer buf = VIR_BUFFER_INITIALIZER ;
2008-02-20 18:29:13 +03:00
name = vshCommandOptString ( cmd , " name " , & found ) ;
if ( ! found )
goto cleanup ;
type = vshCommandOptString ( cmd , " type " , & found ) ;
if ( ! found )
goto cleanup ;
srcHost = vshCommandOptString ( cmd , " source-host " , & found ) ;
srcPath = vshCommandOptString ( cmd , " source-path " , & found ) ;
srcDev = vshCommandOptString ( cmd , " source-dev " , & found ) ;
2008-12-22 19:23:36 +03:00
srcName = vshCommandOptString ( cmd , " source-name " , & found ) ;
2008-02-20 18:29:13 +03:00
target = vshCommandOptString ( cmd , " target " , & found ) ;
2008-04-28 19:14:59 +04:00
virBufferVSprintf ( & buf , " <pool type='%s'> \n " , type ) ;
virBufferVSprintf ( & buf , " <name>%s</name> \n " , name ) ;
2008-02-20 18:29:13 +03:00
if ( srcHost | | srcPath | | srcDev ) {
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " <source> \n " ) ;
2008-02-20 18:29:13 +03:00
2008-12-22 19:23:36 +03:00
if ( srcHost )
virBufferVSprintf ( & buf , " <host name='%s'/> \n " , srcHost ) ;
2008-04-28 19:14:59 +04:00
if ( srcPath )
virBufferVSprintf ( & buf , " <dir path='%s'/> \n " , srcPath ) ;
if ( srcDev )
virBufferVSprintf ( & buf , " <device path='%s'/> \n " , srcDev ) ;
2008-12-22 19:23:36 +03:00
if ( srcName )
virBufferVSprintf ( & buf , " <name>%s</name> \n " , srcName ) ;
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " </source> \n " ) ;
2008-02-20 18:29:13 +03:00
}
if ( target ) {
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " <target> \n " ) ;
virBufferVSprintf ( & buf , " <path>%s</path> \n " , target ) ;
virBufferAddLit ( & buf , " </target> \n " ) ;
2008-02-20 18:29:13 +03:00
}
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " </pool> \n " ) ;
if ( virBufferError ( & buf ) ) {
vshPrint ( ctl , " %s " , _ ( " Failed to allocate XML buffer " ) ) ;
return FALSE ;
}
2008-12-22 19:23:36 +03:00
* xml = virBufferContentAndReset ( & buf ) ;
* retname = name ;
return TRUE ;
cleanup :
free ( virBufferContentAndReset ( & buf ) ) ;
return FALSE ;
}
/*
* " pool-create-as " command
*/
static const vshCmdInfo info_pool_create_as [ ] = {
{ " help " , gettext_noop ( " create a pool from a set of args " ) } ,
{ " desc " , gettext_noop ( " Create a pool. " ) } ,
{ NULL , NULL }
} ;
static int
cmdPoolCreateAs ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
char * xml , * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! buildPoolXML ( cmd , & name , & xml ) )
return FALSE ;
2008-02-20 18:29:13 +03:00
2008-04-28 19:14:59 +04:00
pool = virStoragePoolCreateXML ( ctl - > conn , xml , 0 ) ;
free ( xml ) ;
2008-02-20 18:29:13 +03:00
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s created \n " ) , name ) ;
virStoragePoolFree ( pool ) ;
return TRUE ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to create pool %s " ) , name ) ;
}
return FALSE ;
}
2008-02-20 18:27:08 +03:00
2007-06-26 15:42:46 +04:00
/*
2008-02-20 18:27:08 +03:00
* " pool-define " command
2007-06-26 15:42:46 +04:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_define [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " define (but don't start) a pool from an XML file " ) } ,
{ " desc " , gettext_noop ( " Define a pool. " ) } ,
2007-06-26 15:42:46 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_define [ ] = {
2008-02-20 18:27:08 +03:00
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML pool description " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
2007-06-26 15:42:46 +04:00
static int
2008-08-01 17:51:18 +04:00
cmdPoolDefine ( vshControl * ctl , const vshCmd * cmd )
2007-06-26 15:42:46 +04:00
{
2008-02-20 18:27:08 +03:00
virStoragePoolPtr pool ;
char * from ;
int found ;
int ret = TRUE ;
char * buffer ;
2007-06-26 15:42:46 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-02-20 18:27:08 +03:00
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found )
2007-06-26 15:42:46 +04:00
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 )
return FALSE ;
2007-06-26 15:42:46 +04:00
2008-02-20 18:27:08 +03:00
pool = virStoragePoolDefineXML ( ctl - > conn , buffer , 0 ) ;
free ( buffer ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s defined from %s \n " ) ,
virStoragePoolGetName ( pool ) , from ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to define pool from %s " ) , from ) ;
ret = FALSE ;
}
return ret ;
2007-06-26 15:42:46 +04:00
}
2008-02-20 18:27:08 +03:00
2008-02-20 18:29:13 +03:00
/*
* " pool-define-as " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_define_as [ ] = {
2008-02-20 18:29:13 +03:00
{ " help " , gettext_noop ( " define a pool from a set of args " ) } ,
{ " desc " , gettext_noop ( " Define a pool. " ) } ,
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolDefineAs ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:29:13 +03:00
{
virStoragePoolPtr pool ;
2008-12-22 19:23:36 +03:00
char * xml , * name ;
2008-02-20 18:29:13 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-12-22 19:23:36 +03:00
if ( ! buildPoolXML ( cmd , & name , & xml ) )
2008-04-28 19:14:59 +04:00
return FALSE ;
pool = virStoragePoolDefineXML ( ctl - > conn , xml , 0 ) ;
free ( xml ) ;
2008-02-20 18:29:13 +03:00
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s defined \n " ) , name ) ;
virStoragePoolFree ( pool ) ;
return TRUE ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to define pool %s " ) , name ) ;
}
return FALSE ;
}
2007-06-26 15:42:46 +04:00
/*
2008-02-20 18:27:08 +03:00
* " pool-build " command
2007-01-26 14:54:29 +03:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_build [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " build a pool " ) } ,
{ " desc " , gettext_noop ( " Build a given pool. " ) } ,
2007-01-26 14:54:29 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_build [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
2007-01-26 14:54:29 +03:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolBuild ( vshControl * ctl , const vshCmd * cmd )
2007-01-26 14:54:29 +03:00
{
2008-02-20 18:27:08 +03:00
virStoragePoolPtr pool ;
int ret = TRUE ;
char * name ;
2007-01-26 14:54:29 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
2007-01-26 14:54:29 +03:00
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( virStoragePoolBuild ( pool , 0 ) = = 0 ) {
2008-12-04 17:51:57 +03:00
vshPrint ( ctl , _ ( " Pool %s built \n " ) , name ) ;
2007-01-26 14:54:29 +03:00
} else {
2008-02-20 18:27:08 +03:00
vshError ( ctl , FALSE , _ ( " Failed to build pool %s " ) , name ) ;
ret = FALSE ;
virStoragePoolFree ( pool ) ;
2007-01-26 14:54:29 +03:00
}
return ret ;
}
2008-02-20 18:27:08 +03:00
2007-07-26 12:41:16 +04:00
/*
2008-02-20 18:27:08 +03:00
* " pool-destroy " command
2007-07-26 12:41:16 +04:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_destroy [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " destroy a pool " ) } ,
{ " desc " , gettext_noop ( " Destroy a given pool. " ) } ,
2007-07-26 12:41:16 +04:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_destroy [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
2007-07-26 12:41:16 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolDestroy ( vshControl * ctl , const vshCmd * cmd )
2007-07-26 12:41:16 +04:00
{
2008-02-20 18:27:08 +03:00
virStoragePoolPtr pool ;
int ret = TRUE ;
char * name ;
2007-07-26 12:41:16 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
2007-07-26 12:41:16 +04:00
return FALSE ;
2008-02-20 18:27:08 +03:00
if ( virStoragePoolDestroy ( pool ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s destroyed \n " ) , name ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to destroy pool %s " ) , name ) ;
ret = FALSE ;
2007-07-26 12:41:16 +04:00
}
2008-05-22 00:53:30 +04:00
virStoragePoolFree ( pool ) ;
2007-07-26 12:41:16 +04:00
return ret ;
}
2008-02-20 18:27:08 +03:00
2007-05-23 19:09:19 +04:00
/*
2008-02-20 18:27:08 +03:00
* " pool-delete " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_delete [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " delete a pool " ) } ,
{ " desc " , gettext_noop ( " Delete a given pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_delete [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolDelete ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return FALSE ;
if ( virStoragePoolDelete ( pool , 0 ) = = 0 ) {
2008-03-14 18:21:15 +03:00
vshPrint ( ctl , _ ( " Pool %s deleted \n " ) , name ) ;
2008-02-20 18:27:08 +03:00
} else {
vshError ( ctl , FALSE , _ ( " Failed to delete pool %s " ) , name ) ;
ret = FALSE ;
virStoragePoolFree ( pool ) ;
}
return ret ;
}
/*
* " pool-refresh " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_refresh [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " refresh a pool " ) } ,
{ " desc " , gettext_noop ( " Refresh a given pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_refresh [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolRefresh ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return FALSE ;
if ( virStoragePoolRefresh ( pool , 0 ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s refreshed \n " ) , name ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to refresh pool %s " ) , name ) ;
ret = FALSE ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-dumpxml " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_dumpxml [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " pool information in XML " ) } ,
{ " desc " , gettext_noop ( " Output the pool information as an XML dump to stdout. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_dumpxml [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolDumpXML ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int ret = TRUE ;
char * dump ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ) )
return FALSE ;
dump = virStoragePoolGetXMLDesc ( pool , 0 ) ;
if ( dump ! = NULL ) {
printf ( " %s " , dump ) ;
free ( dump ) ;
} else {
ret = FALSE ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-list " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_list [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " list pools " ) } ,
{ " desc " , gettext_noop ( " Returns list of pools. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_list [ ] = {
2008-02-20 18:27:08 +03:00
{ " inactive " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive pools " ) } ,
{ " all " , VSH_OT_BOOL , 0 , gettext_noop ( " list inactive & active pools " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolList ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2008-02-20 18:27:08 +03:00
{
int inactive = vshCommandOptBool ( cmd , " inactive " ) ;
int all = vshCommandOptBool ( cmd , " all " ) ;
int active = ! inactive | | all ? 1 : 0 ;
int maxactive = 0 , maxinactive = 0 , i ;
char * * activeNames = NULL , * * inactiveNames = NULL ;
inactive | = all ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( active ) {
maxactive = virConnectNumOfStoragePools ( ctl - > conn ) ;
if ( maxactive < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active pools " ) ) ;
return FALSE ;
}
if ( maxactive ) {
activeNames = vshMalloc ( ctl , sizeof ( char * ) * maxactive ) ;
if ( ( maxactive = virConnectListStoragePools ( ctl - > conn , activeNames ,
maxactive ) ) < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active pools " ) ) ;
free ( activeNames ) ;
return FALSE ;
}
qsort ( & activeNames [ 0 ] , maxactive , sizeof ( char * ) , namesorter ) ;
}
}
if ( inactive ) {
maxinactive = virConnectNumOfDefinedStoragePools ( ctl - > conn ) ;
if ( maxinactive < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive pools " ) ) ;
free ( activeNames ) ;
return FALSE ;
}
if ( maxinactive ) {
inactiveNames = vshMalloc ( ctl , sizeof ( char * ) * maxinactive ) ;
if ( ( maxinactive = virConnectListDefinedStoragePools ( ctl - > conn , inactiveNames , maxinactive ) ) < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list inactive pools " ) ) ;
free ( activeNames ) ;
free ( inactiveNames ) ;
return FALSE ;
}
qsort ( & inactiveNames [ 0 ] , maxinactive , sizeof ( char * ) , namesorter ) ;
}
}
vshPrintExtra ( ctl , " %-20s %-10s %-10s \n " , _ ( " Name " ) , _ ( " State " ) , _ ( " Autostart " ) ) ;
vshPrintExtra ( ctl , " ----------------------------------------- \n " ) ;
for ( i = 0 ; i < maxactive ; i + + ) {
virStoragePoolPtr pool = virStoragePoolLookupByName ( ctl - > conn , activeNames [ i ] ) ;
const char * autostartStr ;
int autostart = 0 ;
/* this kind of work with pools is not atomic operation */
if ( ! pool ) {
free ( activeNames [ i ] ) ;
continue ;
}
if ( virStoragePoolGetAutostart ( pool , & autostart ) < 0 )
autostartStr = _ ( " no autostart " ) ;
else
autostartStr = autostart ? " yes " : " no " ;
vshPrint ( ctl , " %-20s %-10s %-10s \n " ,
virStoragePoolGetName ( pool ) ,
_ ( " active " ) ,
autostartStr ) ;
virStoragePoolFree ( pool ) ;
free ( activeNames [ i ] ) ;
}
for ( i = 0 ; i < maxinactive ; i + + ) {
virStoragePoolPtr pool = virStoragePoolLookupByName ( ctl - > conn , inactiveNames [ i ] ) ;
const char * autostartStr ;
int autostart = 0 ;
/* this kind of work with pools is not atomic operation */
if ( ! pool ) {
free ( inactiveNames [ i ] ) ;
continue ;
}
if ( virStoragePoolGetAutostart ( pool , & autostart ) < 0 )
autostartStr = _ ( " no autostart " ) ;
else
autostartStr = autostart ? " yes " : " no " ;
vshPrint ( ctl , " %-20s %-10s %-10s \n " ,
inactiveNames [ i ] ,
_ ( " inactive " ) ,
autostartStr ) ;
virStoragePoolFree ( pool ) ;
free ( inactiveNames [ i ] ) ;
}
free ( activeNames ) ;
free ( inactiveNames ) ;
return TRUE ;
}
2008-08-28 00:05:58 +04:00
/*
* " find-storage-pool-sources-as " command
*/
static const vshCmdInfo info_find_storage_pool_sources_as [ ] = {
{ " help " , gettext_noop ( " find potential storage pool sources " ) } ,
{ " desc " , gettext_noop ( " Returns XML <sources> document. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_find_storage_pool_sources_as [ ] = {
{ " type " , VSH_OT_DATA , VSH_OFLAG_REQ ,
gettext_noop ( " type of storage pool sources to find " ) } ,
{ " host " , VSH_OT_DATA , VSH_OFLAG_NONE , gettext_noop ( " optional host to query " ) } ,
{ " port " , VSH_OT_DATA , VSH_OFLAG_NONE , gettext_noop ( " optional port to query " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
cmdPoolDiscoverSourcesAs ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
char * type , * host ;
char * srcSpec = NULL ;
char * srcList ;
int found ;
type = vshCommandOptString ( cmd , " type " , & found ) ;
if ( ! found )
return FALSE ;
host = vshCommandOptString ( cmd , " host " , & found ) ;
if ( ! found )
host = NULL ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( host ) {
size_t hostlen = strlen ( host ) ;
char * port = vshCommandOptString ( cmd , " port " , & found ) ;
int ret ;
if ( ! found ) {
port = strrchr ( host , ' : ' ) ;
if ( port ) {
if ( * ( + + port ) )
hostlen = port - host - 1 ;
else
port = NULL ;
}
}
ret = port ?
2008-12-23 16:03:29 +03:00
virAsprintf ( & srcSpec ,
" <source><host name='%.*s' port='%s'/></source> " ,
( int ) hostlen , host , port ) :
virAsprintf ( & srcSpec ,
" <source><host name='%.*s'/></source> " ,
( int ) hostlen , host ) ;
2008-08-28 00:05:58 +04:00
if ( ret < 0 ) {
switch ( errno ) {
case ENOMEM :
vshError ( ctl , FALSE , " %s " , _ ( " Out of memory " ) ) ;
break ;
default :
2008-12-23 16:03:29 +03:00
vshError ( ctl , FALSE , _ ( " virAsprintf failed (errno %d) " ) , errno ) ;
2008-08-28 00:05:58 +04:00
}
return FALSE ;
}
}
srcList = virConnectFindStoragePoolSources ( ctl - > conn , type , srcSpec , 0 ) ;
free ( srcSpec ) ;
if ( srcList = = NULL ) {
vshError ( ctl , FALSE , _ ( " Failed to find any %s pool sources " ) , type ) ;
return FALSE ;
}
vshPrint ( ctl , " %s " , srcList ) ;
free ( srcList ) ;
return TRUE ;
}
/*
* " find-storage-pool-sources " command
*/
static const vshCmdInfo info_find_storage_pool_sources [ ] = {
{ " help " , gettext_noop ( " discover potential storage pool sources " ) } ,
{ " desc " , gettext_noop ( " Returns XML <sources> document. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_find_storage_pool_sources [ ] = {
{ " type " , VSH_OT_DATA , VSH_OFLAG_REQ ,
gettext_noop ( " type of storage pool sources to discover " ) } ,
{ " srcSpec " , VSH_OT_DATA , VSH_OFLAG_NONE ,
gettext_noop ( " optional file of source xml to query for pools " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
cmdPoolDiscoverSources ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
char * type , * srcSpec , * srcSpecFile , * srcList ;
int found ;
type = vshCommandOptString ( cmd , " type " , & found ) ;
if ( ! found )
return FALSE ;
srcSpecFile = vshCommandOptString ( cmd , " srcSpec " , & found ) ;
if ( ! found ) {
srcSpecFile = NULL ;
srcSpec = NULL ;
}
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( srcSpecFile & & virFileReadAll ( srcSpecFile , VIRSH_MAX_XML_FILE , & srcSpec ) < 0 )
return FALSE ;
srcList = virConnectFindStoragePoolSources ( ctl - > conn , type , srcSpec , 0 ) ;
free ( srcSpec ) ;
if ( srcList = = NULL ) {
vshError ( ctl , FALSE , _ ( " Failed to find any %s pool sources " ) , type ) ;
return FALSE ;
}
vshPrint ( ctl , " %s " , srcList ) ;
free ( srcList ) ;
return TRUE ;
}
2008-02-20 18:27:08 +03:00
static double
prettyCapacity ( unsigned long long val ,
const char * * unit ) {
if ( val < 1024 ) {
* unit = " " ;
return ( double ) val ;
} else if ( val < ( 1024.0 l * 1024.0 l ) ) {
* unit = " KB " ;
return ( ( ( double ) val / 1024.0 l ) ) ;
} else if ( val < ( 1024.0 l * 1024.0 l * 1024.0 l ) ) {
* unit = " MB " ;
return ( ( double ) val / ( 1024.0 l * 1024.0 l ) ) ;
} else if ( val < ( 1024.0 l * 1024.0 l * 1024.0 l * 1024.0 l ) ) {
* unit = " GB " ;
return ( ( double ) val / ( 1024.0 l * 1024.0 l * 1024.0 l ) ) ;
} else {
* unit = " TB " ;
return ( ( double ) val / ( 1024.0 l * 1024.0 l * 1024.0 l * 1024.0 l ) ) ;
}
}
/*
* " pool-info " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_info [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " storage pool information " ) } ,
{ " desc " , gettext_noop ( " Returns basic information about the storage pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_info [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolInfo ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolInfo info ;
virStoragePoolPtr pool ;
int ret = TRUE ;
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ) )
return FALSE ;
vshPrint ( ctl , " %-15s %s \n " , _ ( " Name: " ) , virStoragePoolGetName ( pool ) ) ;
if ( virStoragePoolGetUUIDString ( pool , & uuid [ 0 ] ) = = 0 )
vshPrint ( ctl , " %-15s %s \n " , _ ( " UUID: " ) , uuid ) ;
if ( virStoragePoolGetInfo ( pool , & info ) = = 0 ) {
double val ;
const char * unit ;
switch ( info . state ) {
case VIR_STORAGE_POOL_INACTIVE :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " inactive " ) ) ;
break ;
case VIR_STORAGE_POOL_BUILDING :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " building " ) ) ;
break ;
case VIR_STORAGE_POOL_RUNNING :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " running " ) ) ;
break ;
case VIR_STORAGE_POOL_DEGRADED :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " degraded " ) ) ;
break ;
}
if ( info . state = = VIR_STORAGE_POOL_RUNNING | |
info . state = = VIR_STORAGE_POOL_DEGRADED ) {
val = prettyCapacity ( info . capacity , & unit ) ;
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Capacity: " ) , val , unit ) ;
val = prettyCapacity ( info . allocation , & unit ) ;
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Allocation: " ) , val , unit ) ;
val = prettyCapacity ( info . available , & unit ) ;
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Available: " ) , val , unit ) ;
}
} else {
ret = FALSE ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-name " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_name [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " convert a pool UUID to pool name " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_name [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolName ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
2008-04-10 20:54:54 +04:00
VSH_BYUUID ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
vshPrint ( ctl , " %s \n " , virStoragePoolGetName ( pool ) ) ;
virStoragePoolFree ( pool ) ;
return TRUE ;
}
/*
* " pool-start " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_start [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " start a (previously defined) inactive pool " ) } ,
{ " desc " , gettext_noop ( " Start a pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_start [ ] = {
2008-12-08 16:22:44 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " name of the inactive pool " ) } ,
2008-02-20 18:27:08 +03:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolStart ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
2008-12-10 00:38:04 +03:00
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL , VSH_BYNAME ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
if ( virStoragePoolCreate ( pool , 0 ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s started \n " ) ,
virStoragePoolGetName ( pool ) ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to start pool %s " ) ,
virStoragePoolGetName ( pool ) ) ;
ret = FALSE ;
}
return ret ;
}
2008-02-20 18:29:13 +03:00
/*
* " vol-create-as " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_create_as [ ] = {
2008-03-14 18:21:15 +03:00
{ " help " , gettext_noop ( " create a volume from a set of args " ) } ,
2008-02-20 18:29:13 +03:00
{ " desc " , gettext_noop ( " Create a vol. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_create_as [ ] = {
2008-02-20 18:29:13 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name " ) } ,
2008-03-14 18:21:15 +03:00
{ " name " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " name of the volume " ) } ,
2008-02-20 18:29:13 +03:00
{ " capacity " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " size of the vol with optional k,M,G,T suffix " ) } ,
2008-12-08 16:22:44 +03:00
{ " allocation " , VSH_OT_STRING , 0 , gettext_noop ( " initial allocation size with optional k,M,G,T suffix " ) } ,
{ " format " , VSH_OT_STRING , 0 , gettext_noop ( " file format type raw,bochs,qcow,qcow2,vmdk " ) } ,
2008-02-20 18:29:13 +03:00
{ NULL , 0 , 0 , NULL }
} ;
static int cmdVolSize ( const char * data , unsigned long long * val )
{
char * end ;
if ( virStrToLong_ull ( data , & end , 10 , val ) < 0 )
return - 1 ;
if ( end & & * end ) {
2008-04-04 11:58:29 +04:00
/* Deliberate fallthrough cases here :-) */
2008-02-20 18:29:13 +03:00
switch ( * end ) {
case ' T ' :
* val * = 1024 ;
case ' G ' :
* val * = 1024 ;
case ' M ' :
* val * = 1024 ;
case ' k ' :
* val * = 1024 ;
break ;
default :
return - 1 ;
}
end + + ;
if ( * end )
return - 1 ;
}
return 0 ;
}
static int
2008-08-01 17:51:18 +04:00
cmdVolCreateAs ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:29:13 +03:00
{
virStoragePoolPtr pool ;
virStorageVolPtr vol ;
int found ;
2008-04-28 19:14:59 +04:00
char * xml ;
2008-02-20 18:29:13 +03:00
char * name , * capacityStr , * allocationStr , * format ;
unsigned long long capacity , allocation = 0 ;
2008-04-28 19:14:59 +04:00
virBuffer buf = VIR_BUFFER_INITIALIZER ;
2008-02-20 18:29:13 +03:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
VSH_BYNAME ) ) )
return FALSE ;
name = vshCommandOptString ( cmd , " name " , & found ) ;
if ( ! found )
goto cleanup ;
capacityStr = vshCommandOptString ( cmd , " capacity " , & found ) ;
if ( ! found )
goto cleanup ;
if ( cmdVolSize ( capacityStr , & capacity ) < 0 )
vshError ( ctl , FALSE , _ ( " Malformed size %s " ) , capacityStr ) ;
allocationStr = vshCommandOptString ( cmd , " allocation " , & found ) ;
if ( allocationStr & &
cmdVolSize ( allocationStr , & allocation ) < 0 )
vshError ( ctl , FALSE , _ ( " Malformed size %s " ) , allocationStr ) ;
format = vshCommandOptString ( cmd , " format " , & found ) ;
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " <volume> \n " ) ;
virBufferVSprintf ( & buf , " <name>%s</name> \n " , name ) ;
virBufferVSprintf ( & buf , " <capacity>%llu</capacity> \n " , capacity ) ;
if ( allocationStr )
virBufferVSprintf ( & buf , " <allocation>%llu</allocation> \n " , allocation ) ;
2008-02-20 18:29:13 +03:00
if ( format ) {
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " <target> \n " ) ;
2008-02-20 18:29:13 +03:00
if ( format )
2008-04-28 19:14:59 +04:00
virBufferVSprintf ( & buf , " <format type='%s'/> \n " , format ) ;
virBufferAddLit ( & buf , " </target> \n " ) ;
2008-02-20 18:29:13 +03:00
}
2008-04-28 19:14:59 +04:00
virBufferAddLit ( & buf , " </volume> \n " ) ;
2008-02-20 18:29:13 +03:00
2008-04-28 19:14:59 +04:00
if ( virBufferError ( & buf ) ) {
vshPrint ( ctl , " %s " , _ ( " Failed to allocate XML buffer " ) ) ;
return FALSE ;
}
xml = virBufferContentAndReset ( & buf ) ;
vol = virStorageVolCreateXML ( pool , xml , 0 ) ;
free ( xml ) ;
2008-02-20 18:29:13 +03:00
virStoragePoolFree ( pool ) ;
if ( vol ! = NULL ) {
vshPrint ( ctl , _ ( " Vol %s created \n " ) , name ) ;
virStorageVolFree ( vol ) ;
return TRUE ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to create vol %s " ) , name ) ;
return FALSE ;
}
cleanup :
2008-04-28 19:14:59 +04:00
free ( virBufferContentAndReset ( & buf ) ) ;
2008-02-20 18:29:13 +03:00
virStoragePoolFree ( pool ) ;
return FALSE ;
}
2008-02-20 18:27:08 +03:00
/*
* " pool-undefine " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_undefine [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " undefine an inactive pool " ) } ,
{ " desc " , gettext_noop ( " Undefine the configuration for an inactive pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_undefine [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolUndefine ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return FALSE ;
if ( virStoragePoolUndefine ( pool ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s has been undefined \n " ) , name ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to undefine pool %s " ) , name ) ;
ret = FALSE ;
}
return ret ;
}
/*
* " pool-uuid " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_pool_uuid [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " convert a pool name to pool UUID " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_pool_uuid [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdPoolUuid ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
2008-04-10 20:54:54 +04:00
VSH_BYNAME ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
if ( virStoragePoolGetUUIDString ( pool , uuid ) ! = - 1 )
vshPrint ( ctl , " %s \n " , uuid ) ;
else
vshError ( ctl , FALSE , " %s " , _ ( " failed to get pool UUID " ) ) ;
return TRUE ;
}
/*
* " vol-create " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_create [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " create a vol from an XML file " ) } ,
{ " desc " , gettext_noop ( " Create a vol. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_create [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name " ) } ,
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " file containing an XML vol description " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolCreate ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
virStorageVolPtr vol ;
char * from ;
int found ;
int ret = TRUE ;
char * buffer ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
2008-04-10 20:54:54 +04:00
VSH_BYNAME ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found ) {
virStoragePoolFree ( pool ) ;
return FALSE ;
}
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 ) {
virStoragePoolFree ( pool ) ;
return FALSE ;
}
vol = virStorageVolCreateXML ( pool , buffer , 0 ) ;
free ( buffer ) ;
virStoragePoolFree ( pool ) ;
if ( vol ! = NULL ) {
vshPrint ( ctl , _ ( " Vol %s created from %s \n " ) ,
virStorageVolGetName ( vol ) , from ) ;
virStorageVolFree ( vol ) ;
} else {
vshError ( ctl , FALSE , _ ( " Failed to create vol from %s " ) , from ) ;
ret = FALSE ;
}
return ret ;
}
/*
* " vol-delete " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_delete [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " delete a vol " ) } ,
{ " desc " , gettext_noop ( " Delete a given vol. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_delete [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_STRING , 0 , gettext_noop ( " pool name or uuid " ) } ,
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol name, key or path " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolDelete ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolPtr vol ;
int ret = TRUE ;
char * name ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVol ( ctl , cmd , " vol " , " pool " , & name ) ) ) {
return FALSE ;
}
if ( virStorageVolDelete ( vol , 0 ) = = 0 ) {
2008-03-14 18:21:15 +03:00
vshPrint ( ctl , _ ( " Vol %s deleted \n " ) , name ) ;
2008-02-20 18:27:08 +03:00
} else {
vshError ( ctl , FALSE , _ ( " Failed to delete vol %s " ) , name ) ;
ret = FALSE ;
virStorageVolFree ( vol ) ;
}
return ret ;
}
/*
* " vol-info " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_info [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " storage vol information " ) } ,
{ " desc " , gettext_noop ( " Returns basic information about the storage vol. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_info [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_STRING , 0 , gettext_noop ( " pool name or uuid " ) } ,
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol name, key or path " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolInfo ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolInfo info ;
virStorageVolPtr vol ;
int ret = TRUE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVol ( ctl , cmd , " vol " , " pool " , NULL ) ) )
return FALSE ;
vshPrint ( ctl , " %-15s %s \n " , _ ( " Name: " ) , virStorageVolGetName ( vol ) ) ;
if ( virStorageVolGetInfo ( vol , & info ) = = 0 ) {
double val ;
const char * unit ;
vshPrint ( ctl , " %-15s %s \n " , _ ( " Type: " ) ,
info . type = = VIR_STORAGE_VOL_FILE ?
_ ( " file " ) : _ ( " block " ) ) ;
val = prettyCapacity ( info . capacity , & unit ) ;
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Capacity: " ) , val , unit ) ;
val = prettyCapacity ( info . allocation , & unit ) ;
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Allocation: " ) , val , unit ) ;
} else {
ret = FALSE ;
}
virStorageVolFree ( vol ) ;
return ret ;
}
/*
* " vol-dumpxml " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_dumpxml [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " vol information in XML " ) } ,
{ " desc " , gettext_noop ( " Output the vol information as an XML dump to stdout. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_dumpxml [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_STRING , 0 , gettext_noop ( " pool name or uuid " ) } ,
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol name, key or path " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolDumpXML ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolPtr vol ;
int ret = TRUE ;
char * dump ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVol ( ctl , cmd , " vol " , " pool " , NULL ) ) )
return FALSE ;
dump = virStorageVolGetXMLDesc ( vol , 0 ) ;
if ( dump ! = NULL ) {
printf ( " %s " , dump ) ;
free ( dump ) ;
} else {
ret = FALSE ;
}
virStorageVolFree ( vol ) ;
return ret ;
}
/*
* " vol-list " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_list [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " list vols " ) } ,
{ " desc " , gettext_noop ( " Returns list of vols by pool. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_list [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolList ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2008-02-20 18:27:08 +03:00
{
virStoragePoolPtr pool ;
int maxactive = 0 , i ;
char * * activeNames = NULL ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ) )
return FALSE ;
maxactive = virStoragePoolNumOfVolumes ( pool ) ;
if ( maxactive < 0 ) {
virStoragePoolFree ( pool ) ;
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active vols " ) ) ;
return FALSE ;
}
if ( maxactive ) {
activeNames = vshMalloc ( ctl , sizeof ( char * ) * maxactive ) ;
if ( ( maxactive = virStoragePoolListVolumes ( pool , activeNames ,
maxactive ) ) < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list active vols " ) ) ;
free ( activeNames ) ;
virStoragePoolFree ( pool ) ;
return FALSE ;
}
qsort ( & activeNames [ 0 ] , maxactive , sizeof ( char * ) , namesorter ) ;
}
vshPrintExtra ( ctl , " %-20s %-40s \n " , _ ( " Name " ) , _ ( " Path " ) ) ;
vshPrintExtra ( ctl , " ----------------------------------------- \n " ) ;
for ( i = 0 ; i < maxactive ; i + + ) {
virStorageVolPtr vol = virStorageVolLookupByName ( pool , activeNames [ i ] ) ;
char * path ;
/* this kind of work with vols is not atomic operation */
if ( ! vol ) {
free ( activeNames [ i ] ) ;
continue ;
}
if ( ( path = virStorageVolGetPath ( vol ) ) = = NULL ) {
virStorageVolFree ( vol ) ;
continue ;
}
vshPrint ( ctl , " %-20s %-40s \n " ,
virStorageVolGetName ( vol ) ,
path ) ;
free ( path ) ;
virStorageVolFree ( vol ) ;
free ( activeNames [ i ] ) ;
}
free ( activeNames ) ;
virStoragePoolFree ( pool ) ;
return TRUE ;
}
/*
* " vol-name " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_name [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " convert a vol UUID to vol name " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_name [ ] = {
2008-02-20 18:27:08 +03:00
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol key or path " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolName ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolPtr vol ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVolBy ( ctl , cmd , " vol " , " pool " , NULL ,
VSH_BYUUID ) ) )
return FALSE ;
vshPrint ( ctl , " %s \n " , virStorageVolGetName ( vol ) ) ;
virStorageVolFree ( vol ) ;
return TRUE ;
}
/*
* " vol-key " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_key [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " convert a vol UUID to vol key " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_key [ ] = {
2008-02-20 18:27:08 +03:00
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolKey ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolPtr vol ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVolBy ( ctl , cmd , " vol " , NULL , NULL ,
VSH_BYUUID ) ) )
return FALSE ;
vshPrint ( ctl , " %s \n " , virStorageVolGetKey ( vol ) ) ;
virStorageVolFree ( vol ) ;
return TRUE ;
}
/*
* " vol-path " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vol_path [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " convert a vol UUID to vol path " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vol_path [ ] = {
2008-02-20 18:27:08 +03:00
{ " pool " , VSH_OT_STRING , 0 , gettext_noop ( " pool name or uuid " ) } ,
{ " vol " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " vol name or key " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVolPath ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
virStorageVolPtr vol ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( vol = vshCommandOptVolBy ( ctl , cmd , " vol " , " pool " , NULL ,
VSH_BYUUID ) ) )
return FALSE ;
vshPrint ( ctl , " %s \n " , virStorageVolGetPath ( vol ) ) ;
virStorageVolFree ( vol ) ;
return TRUE ;
}
/*
* " version " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_version [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " show version " ) } ,
{ " desc " , gettext_noop ( " Display the system version information. " ) } ,
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVersion ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2008-02-20 18:27:08 +03:00
{
unsigned long hvVersion ;
const char * hvType ;
unsigned long libVersion ;
unsigned long includeVersion ;
unsigned long apiVersion ;
int ret ;
unsigned int major ;
unsigned int minor ;
unsigned int rel ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
hvType = virConnectGetType ( ctl - > conn ) ;
if ( hvType = = NULL ) {
vshError ( ctl , FALSE , " %s " , _ ( " failed to get hypervisor type " ) ) ;
return FALSE ;
}
includeVersion = LIBVIR_VERSION_NUMBER ;
major = includeVersion / 1000000 ;
includeVersion % = 1000000 ;
minor = includeVersion / 1000 ;
rel = includeVersion % 1000 ;
vshPrint ( ctl , _ ( " Compiled against library: libvir %d.%d.%d \n " ) ,
major , minor , rel ) ;
ret = virGetVersion ( & libVersion , hvType , & apiVersion ) ;
if ( ret < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " failed to get the library version " ) ) ;
return FALSE ;
}
major = libVersion / 1000000 ;
libVersion % = 1000000 ;
minor = libVersion / 1000 ;
rel = libVersion % 1000 ;
vshPrint ( ctl , _ ( " Using library: libvir %d.%d.%d \n " ) ,
major , minor , rel ) ;
major = apiVersion / 1000000 ;
apiVersion % = 1000000 ;
minor = apiVersion / 1000 ;
rel = apiVersion % 1000 ;
vshPrint ( ctl , _ ( " Using API: %s %d.%d.%d \n " ) , hvType ,
major , minor , rel ) ;
ret = virConnectGetVersion ( ctl - > conn , & hvVersion ) ;
if ( ret < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " failed to get the hypervisor version " ) ) ;
return FALSE ;
}
if ( hvVersion = = 0 ) {
vshPrint ( ctl ,
_ ( " Cannot extract running %s hypervisor version \n " ) , hvType ) ;
} else {
major = hvVersion / 1000000 ;
hvVersion % = 1000000 ;
minor = hvVersion / 1000 ;
rel = hvVersion % 1000 ;
vshPrint ( ctl , _ ( " Running hypervisor: %s %d.%d.%d \n " ) ,
hvType , major , minor , rel ) ;
}
return TRUE ;
}
2008-11-21 15:39:48 +03:00
/*
* " nodedev-list " command
*/
static const vshCmdInfo info_node_list_devices [ ] = {
{ " help " , gettext_noop ( " enumerate devices on this host " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-11-21 15:39:48 +03:00
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_node_list_devices [ ] = {
{ " cap " , VSH_OT_STRING , VSH_OFLAG_NONE , gettext_noop ( " capability name " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
cmdNodeListDevices ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
char * cap ;
char * * devices ;
int found , num_devices , i ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
cap = vshCommandOptString ( cmd , " cap " , & found ) ;
if ( ! found )
cap = NULL ;
num_devices = virNodeNumOfDevices ( ctl - > conn , cap , 0 ) ;
if ( num_devices < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to count node devices " ) ) ;
return FALSE ;
} else if ( num_devices = = 0 ) {
return TRUE ;
}
devices = vshMalloc ( ctl , sizeof ( char * ) * num_devices ) ;
num_devices =
virNodeListDevices ( ctl - > conn , cap , devices , num_devices , 0 ) ;
if ( num_devices < 0 ) {
vshError ( ctl , FALSE , " %s " , _ ( " Failed to list node devices " ) ) ;
free ( devices ) ;
return FALSE ;
}
2008-11-21 15:46:39 +03:00
qsort ( & devices [ 0 ] , num_devices , sizeof ( char * ) , namesorter ) ;
2008-11-21 15:39:48 +03:00
for ( i = 0 ; i < num_devices ; i + + ) {
vshPrint ( ctl , " %s \n " , devices [ i ] ) ;
free ( devices [ i ] ) ;
}
free ( devices ) ;
return TRUE ;
}
/*
* " nodedev-dumpxml " command
*/
static const vshCmdInfo info_node_device_dumpxml [ ] = {
{ " help " , gettext_noop ( " node device details in XML " ) } ,
{ " desc " , gettext_noop ( " Output the node device details as an XML dump to stdout. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_node_device_dumpxml [ ] = {
{ " device " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " device key " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
cmdNodeDeviceDumpXML ( vshControl * ctl , const vshCmd * cmd )
{
const char * name ;
virNodeDevicePtr device ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
if ( ! ( name = vshCommandOptString ( cmd , " device " , NULL ) ) )
return FALSE ;
if ( ! ( device = virNodeDeviceLookupByName ( ctl - > conn , name ) ) ) {
vshError ( ctl , FALSE , " %s '%s' " , _ ( " Could not find matching device " ) , name ) ;
return FALSE ;
}
vshPrint ( ctl , " %s \n " , virNodeDeviceGetXMLDesc ( device , 0 ) ) ;
virNodeDeviceFree ( device ) ;
return TRUE ;
}
2008-02-20 18:27:08 +03:00
/*
* " hostkey " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_hostname [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " print the hypervisor hostname " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdHostname ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2008-02-20 18:27:08 +03:00
{
char * hostname ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
hostname = virConnectGetHostname ( ctl - > conn ) ;
if ( hostname = = NULL ) {
vshError ( ctl , FALSE , " %s " , _ ( " failed to get hostname " ) ) ;
return FALSE ;
}
vshPrint ( ctl , " %s \n " , hostname ) ;
free ( hostname ) ;
return TRUE ;
}
/*
* " uri " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_uri [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " print the hypervisor canonical URI " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2008-02-20 18:27:08 +03:00
{ NULL , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdURI ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2008-02-20 18:27:08 +03:00
{
char * uri ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
uri = virConnectGetURI ( ctl - > conn ) ;
if ( uri = = NULL ) {
vshError ( ctl , FALSE , " %s " , _ ( " failed to get URI " ) ) ;
return FALSE ;
}
vshPrint ( ctl , " %s \n " , uri ) ;
free ( uri ) ;
return TRUE ;
}
/*
* " vncdisplay " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_vncdisplay [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " vnc display " ) } ,
{ " desc " , gettext_noop ( " Output the IP address and port number for the VNC display. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_vncdisplay [ ] = {
2008-02-20 18:27:08 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdVNCDisplay ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
xmlDocPtr xml = NULL ;
xmlXPathObjectPtr obj = NULL ;
xmlXPathContextPtr ctxt = NULL ;
virDomainPtr dom ;
int ret = FALSE ;
int port = 0 ;
char * doc ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
doc = virDomainGetXMLDesc ( dom , 0 ) ;
if ( ! doc )
goto cleanup ;
xml = xmlReadDoc ( ( const xmlChar * ) doc , " domain.xml " , NULL ,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOWARNING ) ;
free ( doc ) ;
if ( ! xml )
goto cleanup ;
ctxt = xmlXPathNewContext ( xml ) ;
if ( ! ctxt )
goto cleanup ;
obj = xmlXPathEval ( BAD_CAST " string(/domain/devices/graphics[@type='vnc']/@port) " , ctxt ) ;
if ( ( obj = = NULL ) | | ( obj - > type ! = XPATH_STRING ) | |
( obj - > stringval = = NULL ) | | ( obj - > stringval [ 0 ] = = 0 ) ) {
goto cleanup ;
}
if ( virStrToLong_i ( ( const char * ) obj - > stringval , NULL , 10 , & port ) | | port < 0 )
goto cleanup ;
xmlXPathFreeObject ( obj ) ;
obj = xmlXPathEval ( BAD_CAST " string(/domain/devices/graphics[@type='vnc']/@listen) " , ctxt ) ;
if ( ( obj = = NULL ) | | ( obj - > type ! = XPATH_STRING ) | |
( obj - > stringval = = NULL ) | | ( obj - > stringval [ 0 ] = = 0 ) | |
2008-05-14 23:51:24 +04:00
STREQ ( ( const char * ) obj - > stringval , " 0.0.0.0 " ) ) {
2008-02-20 18:27:08 +03:00
vshPrint ( ctl , " :%d \n " , port - 5900 ) ;
} else {
vshPrint ( ctl , " %s:%d \n " , ( const char * ) obj - > stringval , port - 5900 ) ;
}
xmlXPathFreeObject ( obj ) ;
obj = NULL ;
ret = TRUE ;
cleanup :
xmlXPathFreeObject ( obj ) ;
xmlXPathFreeContext ( ctxt ) ;
if ( xml )
xmlFreeDoc ( xml ) ;
virDomainFree ( dom ) ;
return ret ;
}
/*
* " ttyconsole " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_ttyconsole [ ] = {
2008-02-20 18:27:08 +03:00
{ " help " , gettext_noop ( " tty console " ) } ,
{ " desc " , gettext_noop ( " Output the device for the TTY console. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_ttyconsole [ ] = {
2008-02-20 18:27:08 +03:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdTTYConsole ( vshControl * ctl , const vshCmd * cmd )
2008-02-20 18:27:08 +03:00
{
xmlDocPtr xml = NULL ;
xmlXPathObjectPtr obj = NULL ;
xmlXPathContextPtr ctxt = NULL ;
virDomainPtr dom ;
int ret = FALSE ;
char * doc ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2008-02-20 18:27:08 +03:00
return FALSE ;
doc = virDomainGetXMLDesc ( dom , 0 ) ;
if ( ! doc )
goto cleanup ;
xml = xmlReadDoc ( ( const xmlChar * ) doc , " domain.xml " , NULL ,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOWARNING ) ;
free ( doc ) ;
if ( ! xml )
goto cleanup ;
ctxt = xmlXPathNewContext ( xml ) ;
if ( ! ctxt )
goto cleanup ;
obj = xmlXPathEval ( BAD_CAST " string(/domain/devices/console/@tty) " , ctxt ) ;
if ( ( obj = = NULL ) | | ( obj - > type ! = XPATH_STRING ) | |
( obj - > stringval = = NULL ) | | ( obj - > stringval [ 0 ] = = 0 ) ) {
goto cleanup ;
}
vshPrint ( ctl , " %s \n " , ( const char * ) obj - > stringval ) ;
cleanup :
xmlXPathFreeObject ( obj ) ;
xmlXPathFreeContext ( ctxt ) ;
if ( xml )
xmlFreeDoc ( xml ) ;
virDomainFree ( dom ) ;
return ret ;
}
/*
* " attach-device " command
2007-05-23 19:09:19 +04:00
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_attach_device [ ] = {
2007-05-23 19:09:19 +04:00
{ " help " , gettext_noop ( " attach device from an XML file " ) } ,
{ " desc " , gettext_noop ( " Attach device from an XML <file>. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_attach_device [ ] = {
2007-05-23 19:09:19 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " XML file " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdAttachDevice ( vshControl * ctl , const vshCmd * cmd )
2007-05-23 19:09:19 +04:00
{
virDomainPtr dom ;
char * from ;
char * buffer ;
int ret = TRUE ;
int found ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-05-23 19:09:19 +04:00
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found ) {
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 16:43:01 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " attach-device: Missing <file> option " ) ) ;
2007-05-23 19:09:19 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
2008-01-30 22:58:59 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 ) {
virDomainFree ( dom ) ;
2008-01-21 18:27:14 +03:00
return FALSE ;
2008-01-30 22:58:59 +03:00
}
2007-05-23 19:09:19 +04:00
ret = virDomainAttachDevice ( dom , buffer ) ;
free ( buffer ) ;
if ( ret < 0 ) {
vshError ( ctl , FALSE , _ ( " Failed to attach device from %s " ) , from ) ;
virDomainFree ( dom ) ;
return FALSE ;
2008-09-03 16:38:28 +04:00
} else {
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Device attached successfully \n " ) ) ;
2007-05-23 19:09:19 +04:00
}
virDomainFree ( dom ) ;
return TRUE ;
}
/*
* " detach-device " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_detach_device [ ] = {
2007-05-23 19:09:19 +04:00
{ " help " , gettext_noop ( " detach device from an XML file " ) } ,
{ " desc " , gettext_noop ( " Detach device from an XML <file> " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_detach_device [ ] = {
2007-05-23 19:09:19 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " file " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " XML file " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDetachDevice ( vshControl * ctl , const vshCmd * cmd )
2007-05-23 19:09:19 +04:00
{
virDomainPtr dom ;
char * from ;
char * buffer ;
int ret = TRUE ;
int found ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
return FALSE ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-05-23 19:09:19 +04:00
return FALSE ;
from = vshCommandOptString ( cmd , " file " , & found ) ;
if ( ! found ) {
Mark many more strings for translation.
* Makefile.maint (err_func_re): Add to the list and make it readable.
* po/POTFILES.in: Add src/util.c and src/xm_internal.c, and sort.
* src/storage_backend.c: Fix comment.
* src/util.c (virFileLinkPointsTo): Mark a string.
* qemud/remote.c (remoteDispatchClientRequest): Mark strings.
(remoteDispatchOpen, CHECK_CONN, remoteDispatchGetType): Likewise.
(remoteDispatchDomainGetSchedulerType): Likewise.
(remoteDispatchDomainGetSchedulerParameters): Likewise.
(remoteDispatchDomainSetSchedulerParameters): Likewise.
(remoteDispatchDomainBlockStats): Likewise.
(remoteDispatchDomainInterfaceStats): Likewise.
(remoteDispatchDomainAttachDevice, remoteDispatchDomainCreate):
(remoteDispatchDomainDestroy, remoteDispatchDomainDetachDevice):
(remoteDispatchDomainDumpXml, remoteDispatchDomainGetAutostart):
(remoteDispatchDomainGetInfo, remoteDispatchDomainGetMaxMemory):
(remoteDispatchDomainGetMaxVcpus, remoteDispatchDomainGetOsType):
(remoteDispatchDomainGetVcpus): Likewise.
(remoteDispatchDomainMigratePerform): Likewise.
(remoteDispatchListDefinedDomains, remoteDispatchDomainPinVcpu):
(remoteDispatchDomainReboot, remoteDispatchDomainResume):
(remoteDispatchDomainSave, remoteDispatchDomainCoreDump):
(remoteDispatchDomainSetAutostart): Likewise.
(remoteDispatchDomainSetMaxMemory, remoteDispatchDomainSetMemory):
(remoteDispatchDomainSetVcpus, remoteDispatchDomainShutdown):
(remoteDispatchDomainSuspend, remoteDispatchDomainUndefine):
(remoteDispatchListDefinedNetworks, remoteDispatchListDomains):
(remoteDispatchListNetworks, remoteDispatchNetworkCreate):
(remoteDispatchNetworkDestroy, remoteDispatchNetworkDumpXml):
(remoteDispatchNetworkGetAutostart, remoteDispatchNetworkGetBridgeName):
(remoteDispatchNetworkSetAutostart, remoteDispatchNetworkUndefine):
(addrToString, remoteDispatchAuthSaslInit, remoteDispatchAuthSaslStart):
(remoteDispatchAuthSaslStep, remoteDispatchListDefinedStoragePools):
(remoteDispatchListStoragePools, remoteDispatchStoragePoolCreate):
(remoteDispatchStoragePoolBuild, remoteDispatchStoragePoolDestroy):
(remoteDispatchStoragePoolDelete, remoteDispatchStoragePoolRefresh):
(remoteDispatchStoragePoolGetInfo, remoteDispatchStoragePoolDumpXml):
(remoteDispatchStoragePoolGetAutostart): Likewise.
(remoteDispatchStoragePoolSetAutostart):
(remoteDispatchStoragePoolListVolumes):
(remoteDispatchStoragePoolNumOfVolumes):
(remoteDispatchStoragePoolUndefine, remoteDispatchStorageVolCreateXml):
(remoteDispatchStorageVolDelete, remoteDispatchStorageVolGetInfo):
(remoteDispatchStorageVolDumpXml, remoteDispatchStorageVolGetPath):
(remoteDispatchStorageVolLookupByName): Likewise.
* src/qemu_driver.c (qemudOpenMonitor, qemudStartVMDaemon):
(dhcpStartDhcpDaemon, qemudStartNetworkDaemon):
(qemudDomainSuspend, qemudDomainResume, qemudDomainShutdown):
(qemudDomainGetOSType, qemudDomainSetMaxMemory):
(qemudDomainSetMemory, qemudDomainGetInfo, qemudDomainSave):
(qemudDomainRestore, qemudDomainDumpXML, qemudDomainStart):
(qemudDomainUndefine, qemudDomainChangeCDROM):
(qemudDomainAttachDevice, qemudDomainGetAutostart):
(qemudDomainSetAutostart, qemudDomainInterfaceStats):
(qemudNetworkLookupByUUID, qemudNetworkLookupByName):
(qemudNetworkUndefine, qemudNetworkStart, qemudNetworkDestroy):
(qemudNetworkDumpXML, qemudNetworkGetAutostart):
(qemudNetworkSetAutostart): Likewise.
* src/virsh.c (cmdVcpupin, cmdAttachDevice, cmdDetachDevice): Likewise.
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu): Likewise.
2008-03-27 16:43:01 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " detach-device: Missing <file> option " ) ) ;
2007-05-23 19:09:19 +04:00
virDomainFree ( dom ) ;
return FALSE ;
}
2008-01-30 22:58:59 +03:00
if ( virFileReadAll ( from , VIRSH_MAX_XML_FILE , & buffer ) < 0 ) {
virDomainFree ( dom ) ;
2008-01-21 18:27:14 +03:00
return FALSE ;
2008-01-30 22:58:59 +03:00
}
2007-05-23 19:09:19 +04:00
ret = virDomainDetachDevice ( dom , buffer ) ;
free ( buffer ) ;
if ( ret < 0 ) {
vshError ( ctl , FALSE , _ ( " Failed to detach device from %s " ) , from ) ;
virDomainFree ( dom ) ;
return FALSE ;
2008-09-03 16:38:28 +04:00
} else {
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Device detached successfully \n " ) ) ;
2007-05-23 19:09:19 +04:00
}
virDomainFree ( dom ) ;
return TRUE ;
}
2007-01-26 14:54:29 +03:00
2007-06-19 13:12:55 +04:00
/*
* " attach-interface " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_attach_interface [ ] = {
2007-06-19 13:12:55 +04:00
{ " help " , gettext_noop ( " attach network interface " ) } ,
{ " desc " , gettext_noop ( " Attach new network interface. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_attach_interface [ ] = {
2007-06-19 13:12:55 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " type " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network interface type " ) } ,
{ " source " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " source of network interface " ) } ,
{ " target " , VSH_OT_DATA , 0 , gettext_noop ( " target network name " ) } ,
2008-03-13 12:21:41 +03:00
{ " mac " , VSH_OT_DATA , 0 , gettext_noop ( " MAC address " ) } ,
2007-06-19 13:12:55 +04:00
{ " script " , VSH_OT_DATA , 0 , gettext_noop ( " script used to bridge network interface " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdAttachInterface ( vshControl * ctl , const vshCmd * cmd )
2007-06-19 13:12:55 +04:00
{
virDomainPtr dom = NULL ;
char * mac , * target , * script , * type , * source ;
int typ , ret = FALSE ;
char * buf = NULL , * tmp = NULL ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
goto cleanup ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-06-19 13:12:55 +04:00
goto cleanup ;
if ( ! ( type = vshCommandOptString ( cmd , " type " , NULL ) ) )
goto cleanup ;
source = vshCommandOptString ( cmd , " source " , NULL ) ;
target = vshCommandOptString ( cmd , " target " , NULL ) ;
mac = vshCommandOptString ( cmd , " mac " , NULL ) ;
script = vshCommandOptString ( cmd , " script " , NULL ) ;
/* check interface type */
2008-05-14 23:51:24 +04:00
if ( STREQ ( type , " network " ) ) {
2007-06-19 13:12:55 +04:00
typ = 1 ;
2008-05-14 23:51:24 +04:00
} else if ( STREQ ( type , " bridge " ) ) {
2007-06-19 13:12:55 +04:00
typ = 2 ;
} else {
vshError ( ctl , FALSE , _ ( " No support %s in command 'attach-interface' " ) , type ) ;
goto cleanup ;
}
/* Make XML of interface */
tmp = vshMalloc ( ctl , 1 ) ;
if ( ! tmp ) goto cleanup ;
buf = vshMalloc ( ctl , strlen ( type ) + 25 ) ;
if ( ! buf ) goto cleanup ;
sprintf ( buf , " <interface type='%s'> \n " , type ) ;
tmp = vshRealloc ( ctl , tmp , strlen ( source ) + 28 ) ;
if ( ! tmp ) goto cleanup ;
if ( typ = = 1 ) {
sprintf ( tmp , " <source network='%s'/> \n " , source ) ;
} else if ( typ = = 2 ) {
sprintf ( tmp , " <source bridge='%s'/> \n " , source ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
if ( target ! = NULL ) {
tmp = vshRealloc ( ctl , tmp , strlen ( target ) + 24 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <target dev='%s'/> \n " , target ) ;
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
}
if ( mac ! = NULL ) {
tmp = vshRealloc ( ctl , tmp , strlen ( mac ) + 25 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <mac address='%s'/> \n " , mac ) ;
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
}
if ( script ! = NULL ) {
tmp = vshRealloc ( ctl , tmp , strlen ( script ) + 25 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <script path='%s'/> \n " , script ) ;
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + 19 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , " </interface> \n " ) ;
2008-09-03 16:38:28 +04:00
if ( virDomainAttachDevice ( dom , buf ) ) {
2007-06-19 13:12:55 +04:00
goto cleanup ;
2008-09-03 16:38:28 +04:00
} else {
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Interface attached successfully \n " ) ) ;
2008-09-03 16:38:28 +04:00
}
2007-06-19 13:12:55 +04:00
ret = TRUE ;
cleanup :
if ( dom )
virDomainFree ( dom ) ;
2008-01-29 20:41:07 +03:00
free ( buf ) ;
free ( tmp ) ;
2007-06-19 13:12:55 +04:00
return ret ;
}
/*
* " detach-interface " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_detach_interface [ ] = {
2007-06-19 13:12:55 +04:00
{ " help " , gettext_noop ( " detach network interface " ) } ,
{ " desc " , gettext_noop ( " Detach network interface. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_detach_interface [ ] = {
2007-06-19 13:12:55 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " type " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network interface type " ) } ,
2008-12-08 16:22:44 +03:00
{ " mac " , VSH_OT_STRING , 0 , gettext_noop ( " MAC address " ) } ,
2007-06-19 13:12:55 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDetachInterface ( vshControl * ctl , const vshCmd * cmd )
2007-06-19 13:12:55 +04:00
{
virDomainPtr dom = NULL ;
xmlDocPtr xml = NULL ;
xmlXPathObjectPtr obj = NULL ;
xmlXPathContextPtr ctxt = NULL ;
xmlNodePtr cur = NULL ;
xmlChar * tmp_mac = NULL ;
xmlBufferPtr xml_buf = NULL ;
char * doc , * mac = NULL , * type ;
char buf [ 64 ] ;
int i = 0 , diff_mac , ret = FALSE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
goto cleanup ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-06-19 13:12:55 +04:00
goto cleanup ;
if ( ! ( type = vshCommandOptString ( cmd , " type " , NULL ) ) )
goto cleanup ;
mac = vshCommandOptString ( cmd , " mac " , NULL ) ;
doc = virDomainGetXMLDesc ( dom , 0 ) ;
if ( ! doc )
goto cleanup ;
xml = xmlReadDoc ( ( const xmlChar * ) doc , " domain.xml " , NULL ,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOWARNING ) ;
free ( doc ) ;
if ( ! xml ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to get interface information " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
ctxt = xmlXPathNewContext ( xml ) ;
if ( ! ctxt ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to get interface information " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
sprintf ( buf , " /domain/devices/interface[@type='%s'] " , type ) ;
obj = xmlXPathEval ( BAD_CAST buf , ctxt ) ;
if ( ( obj = = NULL ) | | ( obj - > type ! = XPATH_NODESET ) | |
( obj - > nodesetval = = NULL ) | | ( obj - > nodesetval - > nodeNr = = 0 ) ) {
vshError ( ctl , FALSE , _ ( " No found interface whose type is %s " ) , type ) ;
goto cleanup ;
}
if ( ! mac )
goto hit ;
/* search mac */
for ( ; i < obj - > nodesetval - > nodeNr ; i + + ) {
cur = obj - > nodesetval - > nodeTab [ i ] - > children ;
while ( cur ! = NULL ) {
if ( cur - > type = = XML_ELEMENT_NODE & & xmlStrEqual ( cur - > name , BAD_CAST " mac " ) ) {
tmp_mac = xmlGetProp ( cur , BAD_CAST " address " ) ;
2008-02-27 19:14:44 +03:00
diff_mac = virMacAddrCompare ( ( char * ) tmp_mac , mac ) ;
2007-06-19 13:12:55 +04:00
xmlFree ( tmp_mac ) ;
if ( ! diff_mac ) {
goto hit ;
}
}
cur = cur - > next ;
}
}
vshError ( ctl , FALSE , _ ( " No found interface whose MAC address is %s " ) , mac ) ;
goto cleanup ;
hit :
xml_buf = xmlBufferCreate ( ) ;
if ( ! xml_buf ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to allocate memory " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
if ( xmlNodeDump ( xml_buf , xml , obj - > nodesetval - > nodeTab [ i ] , 0 , 0 ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to create XML " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
ret = virDomainDetachDevice ( dom , ( char * ) xmlBufferContent ( xml_buf ) ) ;
if ( ret ! = 0 )
ret = FALSE ;
2008-09-03 16:38:28 +04:00
else {
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Interface detached successfully \n " ) ) ;
2007-06-19 13:12:55 +04:00
ret = TRUE ;
2008-09-03 16:38:28 +04:00
}
2007-06-19 13:12:55 +04:00
cleanup :
if ( dom )
virDomainFree ( dom ) ;
2008-02-07 19:49:29 +03:00
xmlXPathFreeObject ( obj ) ;
2008-01-29 21:23:43 +03:00
xmlXPathFreeContext ( ctxt ) ;
2007-06-19 13:12:55 +04:00
if ( xml )
xmlFreeDoc ( xml ) ;
if ( xml_buf )
xmlBufferFree ( xml_buf ) ;
return ret ;
}
/*
* " attach-disk " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_attach_disk [ ] = {
2007-06-19 13:12:55 +04:00
{ " help " , gettext_noop ( " attach disk device " ) } ,
{ " desc " , gettext_noop ( " Attach new disk device. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_attach_disk [ ] = {
2007-06-19 13:12:55 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " source " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " source of disk device " ) } ,
{ " target " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " target of disk device " ) } ,
2008-12-08 16:22:44 +03:00
{ " driver " , VSH_OT_STRING , 0 , gettext_noop ( " driver of disk device " ) } ,
{ " subdriver " , VSH_OT_STRING , 0 , gettext_noop ( " subdriver of disk device " ) } ,
{ " type " , VSH_OT_STRING , 0 , gettext_noop ( " target device type " ) } ,
{ " mode " , VSH_OT_STRING , 0 , gettext_noop ( " mode of device reading and writing " ) } ,
2007-06-19 13:12:55 +04:00
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdAttachDisk ( vshControl * ctl , const vshCmd * cmd )
2007-06-19 13:12:55 +04:00
{
virDomainPtr dom = NULL ;
char * source , * target , * driver , * subdriver , * type , * mode ;
int isFile = 0 , ret = FALSE ;
char * buf = NULL , * tmp = NULL ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
goto cleanup ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-06-19 13:12:55 +04:00
goto cleanup ;
if ( ! ( source = vshCommandOptString ( cmd , " source " , NULL ) ) )
goto cleanup ;
if ( ! ( target = vshCommandOptString ( cmd , " target " , NULL ) ) )
goto cleanup ;
driver = vshCommandOptString ( cmd , " driver " , NULL ) ;
subdriver = vshCommandOptString ( cmd , " subdriver " , NULL ) ;
type = vshCommandOptString ( cmd , " type " , NULL ) ;
mode = vshCommandOptString ( cmd , " mode " , NULL ) ;
if ( type ) {
2008-05-14 23:51:24 +04:00
if ( STRNEQ ( type , " cdrom " ) & & STRNEQ ( type , " disk " ) ) {
2007-06-19 13:12:55 +04:00
vshError ( ctl , FALSE , _ ( " No support %s in command 'attach-disk' " ) , type ) ;
goto cleanup ;
}
}
if ( driver ) {
2008-05-14 23:51:24 +04:00
if ( STREQ ( driver , " file " ) | | STREQ ( driver , " tap " ) ) {
2007-06-19 13:12:55 +04:00
isFile = 1 ;
2008-05-14 23:51:24 +04:00
} else if ( STRNEQ ( driver , " phy " ) ) {
2007-06-19 13:12:55 +04:00
vshError ( ctl , FALSE , _ ( " No support %s in command 'attach-disk' " ) , driver ) ;
goto cleanup ;
}
}
if ( mode ) {
2008-05-14 23:51:24 +04:00
if ( STRNEQ ( mode , " readonly " ) & & STRNEQ ( mode , " shareable " ) ) {
2007-06-19 13:12:55 +04:00
vshError ( ctl , FALSE , _ ( " No support %s in command 'attach-disk' " ) , mode ) ;
goto cleanup ;
}
}
/* Make XML of disk */
tmp = vshMalloc ( ctl , 1 ) ;
if ( ! tmp ) goto cleanup ;
buf = vshMalloc ( ctl , 23 ) ;
if ( ! buf ) goto cleanup ;
if ( isFile ) {
sprintf ( buf , " <disk type='file' " ) ;
} else {
sprintf ( buf , " <disk type='block' " ) ;
}
if ( type ) {
tmp = vshRealloc ( ctl , tmp , strlen ( type ) + 13 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " device='%s'> \n " , type ) ;
} else {
tmp = vshRealloc ( ctl , tmp , 3 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " > \n " ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
if ( driver ) {
tmp = vshRealloc ( ctl , tmp , strlen ( driver ) + 22 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <driver name='%s' " , driver ) ;
} else {
tmp = vshRealloc ( ctl , tmp , 25 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <driver name='phy' " ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
if ( subdriver ) {
tmp = vshRealloc ( ctl , tmp , strlen ( subdriver ) + 12 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " type='%s'/> \n " , subdriver ) ;
} else {
tmp = vshRealloc ( ctl , tmp , 4 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " /> \n " ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
tmp = vshRealloc ( ctl , tmp , strlen ( source ) + 25 ) ;
if ( ! tmp ) goto cleanup ;
if ( isFile ) {
sprintf ( tmp , " <source file='%s'/> \n " , source ) ;
} else {
sprintf ( tmp , " <source dev='%s'/> \n " , source ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
tmp = vshRealloc ( ctl , tmp , strlen ( target ) + 24 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <target dev='%s'/> \n " , target ) ;
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
if ( mode ! = NULL ) {
tmp = vshRealloc ( ctl , tmp , strlen ( mode ) + 11 ) ;
if ( ! tmp ) goto cleanup ;
sprintf ( tmp , " <%s/> \n " , mode ) ;
buf = vshRealloc ( ctl , buf , strlen ( buf ) + strlen ( tmp ) + 1 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , tmp ) ;
}
buf = vshRealloc ( ctl , buf , strlen ( buf ) + 13 ) ;
if ( ! buf ) goto cleanup ;
strcat ( buf , " </disk> \n " ) ;
if ( virDomainAttachDevice ( dom , buf ) )
goto cleanup ;
2008-09-03 16:38:28 +04:00
else
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Disk attached successfully \n " ) ) ;
2007-06-19 13:12:55 +04:00
ret = TRUE ;
cleanup :
if ( dom )
virDomainFree ( dom ) ;
2008-01-29 20:41:07 +03:00
free ( buf ) ;
free ( tmp ) ;
2007-06-19 13:12:55 +04:00
return ret ;
}
/*
* " detach-disk " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_detach_disk [ ] = {
2007-06-19 13:12:55 +04:00
{ " help " , gettext_noop ( " detach disk device " ) } ,
{ " desc " , gettext_noop ( " Detach disk device. " ) } ,
{ NULL , NULL }
} ;
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef opts_detach_disk [ ] = {
2007-06-19 13:12:55 +04:00
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ " target " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " target of disk device " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
static int
2008-08-01 17:51:18 +04:00
cmdDetachDisk ( vshControl * ctl , const vshCmd * cmd )
2007-06-19 13:12:55 +04:00
{
xmlDocPtr xml = NULL ;
xmlXPathObjectPtr obj = NULL ;
xmlXPathContextPtr ctxt = NULL ;
xmlNodePtr cur = NULL ;
xmlChar * tmp_tgt = NULL ;
xmlBufferPtr xml_buf = NULL ;
virDomainPtr dom = NULL ;
char * doc , * target ;
int i = 0 , diff_tgt , ret = FALSE ;
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
goto cleanup ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
if ( ! ( dom = vshCommandOptDomain ( ctl , cmd , NULL ) ) )
2007-06-19 13:12:55 +04:00
goto cleanup ;
if ( ! ( target = vshCommandOptString ( cmd , " target " , NULL ) ) )
goto cleanup ;
doc = virDomainGetXMLDesc ( dom , 0 ) ;
if ( ! doc )
goto cleanup ;
xml = xmlReadDoc ( ( const xmlChar * ) doc , " domain.xml " , NULL ,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOWARNING ) ;
free ( doc ) ;
if ( ! xml ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to get disk information " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
ctxt = xmlXPathNewContext ( xml ) ;
if ( ! ctxt ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to get disk information " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
obj = xmlXPathEval ( BAD_CAST " /domain/devices/disk " , ctxt ) ;
if ( ( obj = = NULL ) | | ( obj - > type ! = XPATH_NODESET ) | |
( obj - > nodesetval = = NULL ) | | ( obj - > nodesetval - > nodeNr = = 0 ) ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to get disk information " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
/* search target */
for ( ; i < obj - > nodesetval - > nodeNr ; i + + ) {
cur = obj - > nodesetval - > nodeTab [ i ] - > children ;
while ( cur ! = NULL ) {
if ( cur - > type = = XML_ELEMENT_NODE & & xmlStrEqual ( cur - > name , BAD_CAST " target " ) ) {
tmp_tgt = xmlGetProp ( cur , BAD_CAST " dev " ) ;
diff_tgt = xmlStrEqual ( tmp_tgt , BAD_CAST target ) ;
xmlFree ( tmp_tgt ) ;
if ( diff_tgt ) {
goto hit ;
}
}
cur = cur - > next ;
}
}
vshError ( ctl , FALSE , _ ( " No found disk whose target is %s " ) , target ) ;
goto cleanup ;
hit :
xml_buf = xmlBufferCreate ( ) ;
if ( ! xml_buf ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to allocate memory " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
if ( xmlNodeDump ( xml_buf , xml , obj - > nodesetval - > nodeTab [ i ] , 0 , 0 ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " Failed to create XML " ) ) ;
2007-06-19 13:12:55 +04:00
goto cleanup ;
}
ret = virDomainDetachDevice ( dom , ( char * ) xmlBufferContent ( xml_buf ) ) ;
if ( ret ! = 0 )
ret = FALSE ;
2008-09-03 16:38:28 +04:00
else {
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
vshPrint ( ctl , " %s " , _ ( " Disk detached successfully \n " ) ) ;
2007-06-19 13:12:55 +04:00
ret = TRUE ;
2008-09-03 16:38:28 +04:00
}
2007-06-19 13:12:55 +04:00
cleanup :
2008-02-07 19:49:29 +03:00
xmlXPathFreeObject ( obj ) ;
2008-01-29 21:23:43 +03:00
xmlXPathFreeContext ( ctxt ) ;
2007-06-19 13:12:55 +04:00
if ( xml )
xmlFreeDoc ( xml ) ;
if ( xml_buf )
xmlBufferFree ( xml_buf ) ;
if ( dom )
virDomainFree ( dom ) ;
return ret ;
}
2008-08-01 18:30:41 +04:00
/* Common code for the edit / net-edit / pool-edit functions which follow. */
static char *
editWriteToTempFile ( vshControl * ctl , const char * doc )
{
char * ret ;
const char * tmpdir ;
int fd ;
ret = malloc ( PATH_MAX ) ;
if ( ! ret ) {
vshError ( ctl , FALSE ,
_ ( " malloc: failed to allocate temporary file name: %s " ) ,
strerror ( errno ) ) ;
return NULL ;
}
tmpdir = getenv ( " TMPDIR " ) ;
if ( ! tmpdir ) tmpdir = " /tmp " ;
snprintf ( ret , PATH_MAX , " %s/virshXXXXXX " , tmpdir ) ;
fd = mkstemp ( ret ) ;
if ( fd = = - 1 ) {
vshError ( ctl , FALSE ,
_ ( " mkstemp: failed to create temporary file: %s " ) ,
strerror ( errno ) ) ;
return NULL ;
}
if ( safewrite ( fd , doc , strlen ( doc ) ) = = - 1 ) {
vshError ( ctl , FALSE ,
_ ( " write: %s: failed to write to temporary file: %s " ) ,
ret , strerror ( errno ) ) ;
close ( fd ) ;
unlink ( ret ) ;
free ( ret ) ;
return NULL ;
}
if ( close ( fd ) = = - 1 ) {
vshError ( ctl , FALSE ,
_ ( " close: %s: failed to write or close temporary file: %s " ) ,
ret , strerror ( errno ) ) ;
unlink ( ret ) ;
free ( ret ) ;
return NULL ;
}
/* Temporary filename: caller frees. */
return ret ;
}
/* Characters permitted in $EDITOR environment variable and temp filename. */
# define ACCEPTED_CHARS \
" abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-/_.:@ "
static int
editFile ( vshControl * ctl , const char * filename )
{
const char * editor ;
char * command ;
int command_ret ;
editor = getenv ( " EDITOR " ) ;
if ( ! editor ) editor = " vi " ; /* could be cruel & default to ed(1) here */
/* Check the editor doesn't contain shell meta-characters, and if
* it does , refuse to run .
*/
if ( strspn ( editor , ACCEPTED_CHARS ) ! = strlen ( editor ) ) {
vshError ( ctl , FALSE ,
_ ( " %s: $EDITOR environment variable contains shell meta or other unacceptable characters " ) ,
editor ) ;
return - 1 ;
}
/* Same for the filename. */
if ( strspn ( filename , ACCEPTED_CHARS ) ! = strlen ( filename ) ) {
vshError ( ctl , FALSE ,
_ ( " %s: temporary filename contains shell meta or other unacceptable characters (is $TMPDIR wrong?) " ) ,
filename ) ;
return - 1 ;
}
2008-12-23 16:03:29 +03:00
if ( virAsprintf ( & command , " %s %s " , editor , filename ) = = - 1 ) {
2008-08-01 18:30:41 +04:00
vshError ( ctl , FALSE ,
2008-12-23 16:03:29 +03:00
_ ( " virAsprintf: could not create editing command: %s " ) ,
2008-08-01 18:30:41 +04:00
strerror ( errno ) ) ;
return - 1 ;
}
command_ret = system ( command ) ;
if ( command_ret = = - 1 ) {
vshError ( ctl , FALSE ,
_ ( " %s: edit command failed: %s " ) , command , strerror ( errno ) ) ;
free ( command ) ;
return - 1 ;
}
if ( command_ret ! = WEXITSTATUS ( 0 ) ) {
vshError ( ctl , FALSE ,
_ ( " %s: command exited with non-zero status " ) , command ) ;
free ( command ) ;
return - 1 ;
}
free ( command ) ;
return 0 ;
}
static char *
editReadBackFile ( vshControl * ctl , const char * filename )
{
char * ret ;
if ( virFileReadAll ( filename , VIRSH_MAX_XML_FILE , & ret ) = = - 1 ) {
vshError ( ctl , FALSE ,
_ ( " %s: failed to read temporary file: %s " ) ,
filename , strerror ( errno ) ) ;
return NULL ;
}
return ret ;
}
/*
* " edit " command
*/
static const vshCmdInfo info_edit [ ] = {
{ " help " , gettext_noop ( " edit XML configuration for a domain " ) } ,
{ " desc " , gettext_noop ( " Edit the XML configuration for a domain. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_edit [ ] = {
{ " domain " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " domain name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
/* This function also acts as a template to generate cmdNetworkEdit
* and cmdPoolEdit functions ( below ) using a sed script in the Makefile .
*/
static int
cmdEdit ( vshControl * ctl , const vshCmd * cmd )
{
int ret = FALSE ;
virDomainPtr dom = NULL ;
char * tmp = NULL ;
char * doc = NULL ;
char * doc_edited = NULL ;
char * doc_reread = NULL ;
2009-02-17 01:51:31 +03:00
int flags = VIR_DOMAIN_XML_SECURE | VIR_DOMAIN_XML_INACTIVE ;
2008-08-01 18:30:41 +04:00
if ( ! vshConnectionUsability ( ctl , ctl - > conn , TRUE ) )
goto cleanup ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
dom = vshCommandOptDomain ( ctl , cmd , NULL ) ;
2008-08-01 18:30:41 +04:00
if ( dom = = NULL )
goto cleanup ;
/* Get the XML configuration of the domain. */
2009-02-17 01:51:31 +03:00
doc = virDomainGetXMLDesc ( dom , flags ) ;
2008-08-01 18:30:41 +04:00
if ( ! doc )
goto cleanup ;
/* Create and open the temporary file. */
tmp = editWriteToTempFile ( ctl , doc ) ;
if ( ! tmp ) goto cleanup ;
/* Start the editor. */
if ( editFile ( ctl , tmp ) = = - 1 ) goto cleanup ;
/* Read back the edited file. */
doc_edited = editReadBackFile ( ctl , tmp ) ;
if ( ! doc_edited ) goto cleanup ;
unlink ( tmp ) ;
tmp = NULL ;
/* Compare original XML with edited. Has it changed at all? */
if ( STREQ ( doc , doc_edited ) ) {
vshPrint ( ctl , _ ( " Domain %s XML configuration not changed. \n " ) ,
virDomainGetName ( dom ) ) ;
ret = TRUE ;
goto cleanup ;
}
/* Now re-read the domain XML. Did someone else change it while
* it was being edited ? This also catches problems such as us
* losing a connection or the domain going away .
*/
2009-02-17 01:51:31 +03:00
doc_reread = virDomainGetXMLDesc ( dom , flags ) ;
2008-08-01 18:30:41 +04:00
if ( ! doc_reread )
goto cleanup ;
if ( STRNEQ ( doc , doc_reread ) ) {
vshError ( ctl , FALSE ,
avoid many format string warnings
Building with --disable-nls exposed many new warnings like these:
virsh.c:4952: warning: format not a string literal and no format ...
util.c:163: warning: format not a string literal and no format arguments
All but one of the following changes add a "%s" argument before
the offending _(...) argument.
This was the only manual change:
* src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
rather than %m, to avoid a warning from gcc -Wformat-security.
Add "%s" before each warned about format-string-with-no-%-directive:
* src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
(virDomainDefParseString, virDomainDefParseFile):
* src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
(__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
(virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
* src/lxc_container.c (lxcContainerChild):
* src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
(lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
(lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
(lxcVersion, lxcGetSchedulerParameters):
* src/network_conf.c (virNetworkDefParseString)
(virNetworkDefParseFile):
* src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
* src/openvz_driver.c (openvzDomainDefineCmd)
(openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
(openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
(openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
(openvzDomainSetAutostart, openvzDomainGetAutostart)
(openvzDomainSetVcpus):
* src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
* src/remote_internal.c (remoteDomainBlockPeek)
(remoteDomainMemoryPeek, remoteAuthPolkit):
* src/sexpr.c (sexpr_new, _string2sexpr):
* src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol):
* src/storage_backend_fs.c
(virStorageBackendFileSystemNetFindPoolSources):
* src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
(virStorageBackendLogicalFindPoolSources):
* src/test.c (testOpenDefault, testOpenFromFile, testOpen)
(testGetDomainInfo, testDomainRestore)
(testNodeGetCellsFreeMemory):
* src/util.c (virExec):
* src/virsh.c (cmdAttachDevice, cmdDetachDevice)
(cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
(cmdDetachDisk, cmdEdit):
* src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
(urlencode, xenDaemonDomainCreateXML)
(xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
(xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
(xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
(xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
(xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
(xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
(xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
(xenDaemonGetSchedulerParameters)
(xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
(xenDaemonFormatSxprChr, virDomainXMLDevID):
* src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
(xenXMDomainCreate, xenXMDomainDefineXML)
(xenXMDomainAttachDevice, xenXMDomainDetachDevice):
* src/xml.c (virXPathString, virXPathNumber, virXPathLong)
(virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
* src/xs_internal.c (xenStoreOpen):
2008-10-13 20:46:28 +04:00
" %s " , _ ( " ERROR: the XML configuration was changed by another user " ) ) ;
2008-08-01 18:30:41 +04:00
goto cleanup ;
}
/* Everything checks out, so redefine the domain. */
virDomainFree ( dom ) ;
dom = virDomainDefineXML ( ctl - > conn , doc_edited ) ;
if ( ! dom )
goto cleanup ;
vshPrint ( ctl , _ ( " Domain %s XML configuration edited. \n " ) ,
virDomainGetName ( dom ) ) ;
ret = TRUE ;
cleanup :
if ( dom )
virDomainFree ( dom ) ;
free ( doc ) ;
free ( doc_edited ) ;
free ( doc_reread ) ;
if ( tmp ) {
unlink ( tmp ) ;
free ( tmp ) ;
}
return ret ;
}
/*
* " net-edit " command
*/
static const vshCmdInfo info_network_edit [ ] = {
{ " help " , gettext_noop ( " edit XML configuration for a network " ) } ,
{ " desc " , gettext_noop ( " Edit the XML configuration for a network. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_network_edit [ ] = {
{ " network " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " network name, id or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
/* This is generated from this file by a sed script in the Makefile. */
# include "virsh-net-edit.c"
/*
* " pool-edit " command
*/
static const vshCmdInfo info_pool_edit [ ] = {
{ " help " , gettext_noop ( " edit XML configuration for a storage pool " ) } ,
{ " desc " , gettext_noop ( " Edit the XML configuration for a storage pool. " ) } ,
{ NULL , NULL }
} ;
static const vshCmdOptDef opts_pool_edit [ ] = {
{ " pool " , VSH_OT_DATA , VSH_OFLAG_REQ , gettext_noop ( " pool name or uuid " ) } ,
{ NULL , 0 , 0 , NULL }
} ;
/* This is generated from this file by a sed script in the Makefile. */
# include "virsh-pool-edit.c"
2005-12-08 13:23:34 +03:00
/*
* " quit " command
*/
2008-08-01 16:19:56 +04:00
static const vshCmdInfo info_quit [ ] = {
2006-09-21 19:24:37 +04:00
{ " help " , gettext_noop ( " quit this interactive terminal " ) } ,
2009-01-05 16:27:43 +03:00
{ " desc " , " " } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
static int
2008-08-01 17:51:18 +04:00
cmdQuit ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
ctl - > imode = FALSE ;
return TRUE ;
}
/*
* Commands
*/
2008-08-01 16:19:56 +04:00
static const vshCmdDef commands [ ] = {
2007-06-20 21:22:09 +04:00
{ " help " , cmdHelp , opts_help , info_help } ,
{ " attach-device " , cmdAttachDevice , opts_attach_device , info_attach_device } ,
{ " attach-disk " , cmdAttachDisk , opts_attach_disk , info_attach_disk } ,
{ " attach-interface " , cmdAttachInterface , opts_attach_interface , info_attach_interface } ,
2007-02-23 11:58:25 +03:00
{ " autostart " , cmdAutostart , opts_autostart , info_autostart } ,
2007-03-15 20:24:56 +03:00
{ " capabilities " , cmdCapabilities , NULL , info_capabilities } ,
2006-03-15 15:13:25 +03:00
{ " connect " , cmdConnect , opts_connect , info_connect } ,
2007-01-26 14:54:29 +03:00
{ " console " , cmdConsole , opts_console , info_console } ,
2006-03-30 20:08:13 +04:00
{ " create " , cmdCreate , opts_create , info_create } ,
2006-08-30 18:32:32 +04:00
{ " start " , cmdStart , opts_start , info_start } ,
2006-04-05 01:52:31 +04:00
{ " destroy " , cmdDestroy , opts_destroy , info_destroy } ,
2007-06-20 21:22:09 +04:00
{ " detach-device " , cmdDetachDevice , opts_detach_device , info_detach_device } ,
{ " detach-disk " , cmdDetachDisk , opts_detach_disk , info_detach_disk } ,
{ " detach-interface " , cmdDetachInterface , opts_detach_interface , info_detach_interface } ,
2006-08-30 18:32:32 +04:00
{ " define " , cmdDefine , opts_define , info_define } ,
2006-04-05 01:52:31 +04:00
{ " domid " , cmdDomid , opts_domid , info_domid } ,
2006-05-29 19:39:31 +04:00
{ " domuuid " , cmdDomuuid , opts_domuuid , info_domuuid } ,
2006-04-04 18:37:32 +04:00
{ " dominfo " , cmdDominfo , opts_dominfo , info_dominfo } ,
2006-04-05 01:52:31 +04:00
{ " domname " , cmdDomname , opts_domname , info_domname } ,
{ " domstate " , cmdDomstate , opts_domstate , info_domstate } ,
2007-08-21 14:08:12 +04:00
{ " domblkstat " , cmdDomblkstat , opts_domblkstat , info_domblkstat } ,
{ " domifstat " , cmdDomIfstat , opts_domifstat , info_domifstat } ,
2006-03-15 15:13:25 +03:00
{ " dumpxml " , cmdDumpXML , opts_dumpxml , info_dumpxml } ,
2008-08-01 18:30:41 +04:00
{ " edit " , cmdEdit , opts_edit , info_edit } ,
2008-08-28 00:05:58 +04:00
{ " find-storage-pool-sources " , cmdPoolDiscoverSources ,
opts_find_storage_pool_sources , info_find_storage_pool_sources } ,
{ " find-storage-pool-sources-as " , cmdPoolDiscoverSourcesAs ,
opts_find_storage_pool_sources_as , info_find_storage_pool_sources_as } ,
2007-09-28 18:28:12 +04:00
{ " freecell " , cmdFreecell , opts_freecell , info_freecell } ,
2007-06-26 15:42:46 +04:00
{ " hostname " , cmdHostname , NULL , info_hostname } ,
2006-08-30 18:32:32 +04:00
{ " list " , cmdList , opts_list , info_list } ,
2007-08-21 13:31:12 +04:00
{ " migrate " , cmdMigrate , opts_migrate , info_migrate } ,
2008-02-20 18:27:08 +03:00
2007-02-23 11:58:25 +03:00
{ " net-autostart " , cmdNetworkAutostart , opts_network_autostart , info_network_autostart } ,
2007-02-14 19:53:55 +03:00
{ " net-create " , cmdNetworkCreate , opts_network_create , info_network_create } ,
{ " net-define " , cmdNetworkDefine , opts_network_define , info_network_define } ,
{ " net-destroy " , cmdNetworkDestroy , opts_network_destroy , info_network_destroy } ,
{ " net-dumpxml " , cmdNetworkDumpXML , opts_network_dumpxml , info_network_dumpxml } ,
2008-08-01 18:30:41 +04:00
{ " net-edit " , cmdNetworkEdit , opts_network_edit , info_network_edit } ,
2007-02-14 19:53:55 +03:00
{ " net-list " , cmdNetworkList , opts_network_list , info_network_list } ,
{ " net-name " , cmdNetworkName , opts_network_name , info_network_name } ,
{ " net-start " , cmdNetworkStart , opts_network_start , info_network_start } ,
{ " net-undefine " , cmdNetworkUndefine , opts_network_undefine , info_network_undefine } ,
{ " net-uuid " , cmdNetworkUuid , opts_network_uuid , info_network_uuid } ,
2006-04-05 01:52:31 +04:00
{ " nodeinfo " , cmdNodeinfo , NULL , info_nodeinfo } ,
2008-02-20 18:27:08 +03:00
2008-11-21 15:39:48 +03:00
{ " nodedev-list " , cmdNodeListDevices , opts_node_list_devices , info_node_list_devices } ,
{ " nodedev-dumpxml " , cmdNodeDeviceDumpXML , opts_node_device_dumpxml , info_node_device_dumpxml } ,
2008-02-20 18:27:08 +03:00
{ " pool-autostart " , cmdPoolAutostart , opts_pool_autostart , info_pool_autostart } ,
{ " pool-build " , cmdPoolBuild , opts_pool_build , info_pool_build } ,
{ " pool-create " , cmdPoolCreate , opts_pool_create , info_pool_create } ,
2008-12-22 19:23:36 +03:00
{ " pool-create-as " , cmdPoolCreateAs , opts_pool_X_as , info_pool_create_as } ,
2008-02-20 18:27:08 +03:00
{ " pool-define " , cmdPoolDefine , opts_pool_define , info_pool_define } ,
2008-12-22 19:23:36 +03:00
{ " pool-define-as " , cmdPoolDefineAs , opts_pool_X_as , info_pool_define_as } ,
2008-02-20 18:27:08 +03:00
{ " pool-destroy " , cmdPoolDestroy , opts_pool_destroy , info_pool_destroy } ,
{ " pool-delete " , cmdPoolDelete , opts_pool_delete , info_pool_delete } ,
{ " pool-dumpxml " , cmdPoolDumpXML , opts_pool_dumpxml , info_pool_dumpxml } ,
2008-08-01 18:30:41 +04:00
{ " pool-edit " , cmdPoolEdit , opts_pool_edit , info_pool_edit } ,
2008-02-20 18:27:08 +03:00
{ " pool-info " , cmdPoolInfo , opts_pool_info , info_pool_info } ,
{ " pool-list " , cmdPoolList , opts_pool_list , info_pool_list } ,
{ " pool-name " , cmdPoolName , opts_pool_name , info_pool_name } ,
{ " pool-refresh " , cmdPoolRefresh , opts_pool_refresh , info_pool_refresh } ,
{ " pool-start " , cmdPoolStart , opts_pool_start , info_pool_start } ,
{ " pool-undefine " , cmdPoolUndefine , opts_pool_undefine , info_pool_undefine } ,
{ " pool-uuid " , cmdPoolUuid , opts_pool_uuid , info_pool_uuid } ,
2006-04-05 01:52:31 +04:00
{ " quit " , cmdQuit , NULL , info_quit } ,
{ " reboot " , cmdReboot , opts_reboot , info_reboot } ,
{ " restore " , cmdRestore , opts_restore , info_restore } ,
2006-03-15 15:13:25 +03:00
{ " resume " , cmdResume , opts_resume , info_resume } ,
{ " save " , cmdSave , opts_save , info_save } ,
2007-06-05 16:06:08 +04:00
{ " schedinfo " , cmdSchedinfo , opts_schedinfo , info_schedinfo } ,
2006-11-22 20:48:29 +03:00
{ " dump " , cmdDump , opts_dump , info_dump } ,
2006-03-15 15:13:25 +03:00
{ " shutdown " , cmdShutdown , opts_shutdown , info_shutdown } ,
2006-08-16 21:30:33 +04:00
{ " setmem " , cmdSetmem , opts_setmem , info_setmem } ,
{ " setmaxmem " , cmdSetmaxmem , opts_setmaxmem , info_setmaxmem } ,
{ " setvcpus " , cmdSetvcpus , opts_setvcpus , info_setvcpus } ,
2006-04-05 01:52:31 +04:00
{ " suspend " , cmdSuspend , opts_suspend , info_suspend } ,
2007-07-26 12:41:16 +04:00
{ " ttyconsole " , cmdTTYConsole , opts_ttyconsole , info_ttyconsole } ,
2006-08-30 18:32:32 +04:00
{ " undefine " , cmdUndefine , opts_undefine , info_undefine } ,
2007-06-26 15:42:46 +04:00
{ " uri " , cmdURI , NULL , info_uri } ,
2008-02-20 18:27:08 +03:00
{ " vol-create " , cmdVolCreate , opts_vol_create , info_vol_create } ,
2008-02-20 18:29:13 +03:00
{ " vol-create-as " , cmdVolCreateAs , opts_vol_create_as , info_vol_create_as } ,
2008-02-20 18:27:08 +03:00
{ " vol-delete " , cmdVolDelete , opts_vol_delete , info_vol_delete } ,
{ " vol-dumpxml " , cmdVolDumpXML , opts_vol_dumpxml , info_vol_dumpxml } ,
{ " vol-info " , cmdVolInfo , opts_vol_info , info_vol_info } ,
{ " vol-list " , cmdVolList , opts_vol_list , info_vol_list } ,
{ " vol-path " , cmdVolPath , opts_vol_path , info_vol_path } ,
{ " vol-name " , cmdVolName , opts_vol_name , info_vol_name } ,
{ " vol-key " , cmdVolKey , opts_vol_key , info_vol_key } ,
2006-08-07 18:35:20 +04:00
{ " vcpuinfo " , cmdVcpuinfo , opts_vcpuinfo , info_vcpuinfo } ,
{ " vcpupin " , cmdVcpupin , opts_vcpupin , info_vcpupin } ,
2006-03-15 15:13:25 +03:00
{ " version " , cmdVersion , NULL , info_version } ,
2007-01-26 14:54:29 +03:00
{ " vncdisplay " , cmdVNCDisplay , opts_vncdisplay , info_vncdisplay } ,
2006-03-15 15:13:25 +03:00
{ NULL , NULL , NULL , NULL }
2005-12-08 13:23:34 +03:00
} ;
/* ---------------
* Utils for work with command definition
* - - - - - - - - - - - - - - -
*/
2005-12-08 17:22:52 +03:00
static const char *
2008-08-01 16:19:56 +04:00
vshCmddefGetInfo ( const vshCmdDef * cmd , const char * name )
2006-03-15 15:13:25 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdInfo * info ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
for ( info = cmd - > info ; info & & info - > name ; info + + ) {
2008-05-14 23:51:24 +04:00
if ( STREQ ( info - > name , name ) )
2005-12-08 13:23:34 +03:00
return info - > data ;
}
return NULL ;
}
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef *
vshCmddefGetOption ( const vshCmdDef * cmd , const char * name )
2006-03-15 15:13:25 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * opt ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
for ( opt = cmd - > opts ; opt & & opt - > name ; opt + + )
2008-05-14 23:51:24 +04:00
if ( STREQ ( opt - > name , name ) )
2005-12-08 13:23:34 +03:00
return opt ;
return NULL ;
}
2008-08-01 16:19:56 +04:00
static const vshCmdOptDef *
vshCmddefGetData ( const vshCmdDef * cmd , int data_ct )
2006-03-15 15:13:25 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * opt ;
2005-12-08 13:23:34 +03:00
2006-01-25 12:46:22 +03:00
for ( opt = cmd - > opts ; opt & & opt - > name ; opt + + ) {
2006-03-15 15:13:25 +03:00
if ( opt - > type = = VSH_OT_DATA ) {
if ( data_ct = = 0 )
2006-01-25 12:46:22 +03:00
return opt ;
else
data_ct - - ;
}
}
2005-12-08 13:23:34 +03:00
return NULL ;
}
2006-01-25 12:46:22 +03:00
/*
* Checks for required options
*/
2006-03-15 15:13:25 +03:00
static int
2008-08-01 17:51:18 +04:00
vshCommandCheckOpts ( vshControl * ctl , const vshCmd * cmd )
2006-01-25 12:46:22 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdDef * def = cmd - > def ;
const vshCmdOptDef * d ;
2006-03-15 15:13:25 +03:00
int err = 0 ;
2006-01-25 12:46:22 +03:00
for ( d = def - > opts ; d & & d - > name ; d + + ) {
if ( d - > flag & VSH_OFLAG_REQ ) {
vshCmdOpt * o = cmd - > opts ;
2006-03-15 15:13:25 +03:00
int ok = 0 ;
while ( o & & ok = = 0 ) {
2006-01-25 12:46:22 +03:00
if ( o - > def = = d )
2006-03-15 15:13:25 +03:00
ok = 1 ;
2006-01-25 12:46:22 +03:00
o = o - > next ;
}
if ( ! ok ) {
2006-03-15 15:13:25 +03:00
vshError ( ctl , FALSE ,
d - > type = = VSH_OT_DATA ?
2006-09-21 19:24:37 +04:00
_ ( " command '%s' requires <%s> option " ) :
2007-02-07 16:50:18 +03:00
_ ( " command '%s' requires --%s option " ) ,
2006-03-15 15:13:25 +03:00
def - > name , d - > name ) ;
2006-01-25 12:46:22 +03:00
err = 1 ;
}
2006-03-15 15:13:25 +03:00
2006-01-25 12:46:22 +03:00
}
}
return ! err ;
}
2008-08-01 16:19:56 +04:00
static const vshCmdDef *
2006-03-15 15:13:25 +03:00
vshCmddefSearch ( const char * cmdname )
{
2008-08-01 16:19:56 +04:00
const vshCmdDef * c ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
for ( c = commands ; c - > name ; c + + )
2008-05-14 23:51:24 +04:00
if ( STREQ ( c - > name , cmdname ) )
2005-12-08 13:23:34 +03:00
return c ;
return NULL ;
}
static int
2008-12-08 16:14:48 +03:00
vshCmddefHelp ( vshControl * ctl , const char * cmdname )
2006-03-15 15:13:25 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdDef * def = vshCmddefSearch ( cmdname ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! def ) {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " command '%s' doesn't exist " ) , cmdname ) ;
2006-03-15 15:13:25 +03:00
return FALSE ;
} else {
2007-06-15 12:18:55 +04:00
const char * desc = N_ ( vshCmddefGetInfo ( def , " desc " ) ) ;
const char * help = N_ ( vshCmddefGetInfo ( def , " help " ) ) ;
2008-12-08 16:14:48 +03:00
char buf [ 256 ] ;
2005-12-08 13:23:34 +03:00
2006-09-21 19:24:37 +04:00
fputs ( _ ( " NAME \n " ) , stdout ) ;
2006-03-15 15:13:25 +03:00
fprintf ( stdout , " %s - %s \n " , def - > name , help ) ;
2008-12-08 16:14:48 +03:00
fputs ( _ ( " \n SYNOPSIS \n " ) , stdout ) ;
fprintf ( stdout , " %s " , def - > name ) ;
if ( def - > opts ) {
const vshCmdOptDef * opt ;
for ( opt = def - > opts ; opt - > name ; opt + + ) {
const char * fmt ;
if ( opt - > type = = VSH_OT_BOOL )
fmt = " [--%s] " ;
else if ( opt - > type = = VSH_OT_INT )
fmt = N_ ( " [--%s <number>] " ) ;
else if ( opt - > type = = VSH_OT_STRING )
fmt = N_ ( " [--%s <string>] " ) ;
else if ( opt - > type = = VSH_OT_DATA )
fmt = ( ( opt - > flag & VSH_OFLAG_REQ ) ? " <%s> " : " [<%s>] " ) ;
else
assert ( 0 ) ;
fputc ( ' ' , stdout ) ;
fprintf ( stdout , _ ( fmt ) , opt - > name ) ;
}
2005-12-08 13:23:34 +03:00
}
2008-12-08 16:14:48 +03:00
fputc ( ' \n ' , stdout ) ;
if ( desc [ 0 ] ) {
2009-01-05 16:27:43 +03:00
/* Print the description only if it's not empty. */
2006-09-21 19:24:37 +04:00
fputs ( _ ( " \n DESCRIPTION \n " ) , stdout ) ;
2005-12-08 13:23:34 +03:00
fprintf ( stdout , " %s \n " , desc ) ;
}
2008-12-08 16:14:48 +03:00
2005-12-08 13:23:34 +03:00
if ( def - > opts ) {
2008-12-08 16:14:48 +03:00
const vshCmdOptDef * opt ;
2006-09-21 19:24:37 +04:00
fputs ( _ ( " \n OPTIONS \n " ) , stdout ) ;
2006-03-15 15:13:25 +03:00
for ( opt = def - > opts ; opt - > name ; opt + + ) {
if ( opt - > type = = VSH_OT_BOOL )
2005-12-08 13:23:34 +03:00
snprintf ( buf , sizeof ( buf ) , " --%s " , opt - > name ) ;
2006-03-15 15:13:25 +03:00
else if ( opt - > type = = VSH_OT_INT )
2006-09-21 19:24:37 +04:00
snprintf ( buf , sizeof ( buf ) , _ ( " --%s <number> " ) , opt - > name ) ;
2006-03-15 15:13:25 +03:00
else if ( opt - > type = = VSH_OT_STRING )
2006-09-21 19:24:37 +04:00
snprintf ( buf , sizeof ( buf ) , _ ( " --%s <string> " ) , opt - > name ) ;
2006-03-15 15:13:25 +03:00
else if ( opt - > type = = VSH_OT_DATA )
2005-12-08 13:23:34 +03:00
snprintf ( buf , sizeof ( buf ) , " <%s> " , opt - > name ) ;
2006-03-15 15:13:25 +03:00
2007-06-15 12:18:55 +04:00
fprintf ( stdout , " %-15s %s \n " , buf , N_ ( opt - > help ) ) ;
2006-03-15 15:13:25 +03:00
}
2005-12-08 13:23:34 +03:00
}
fputc ( ' \n ' , stdout ) ;
}
return TRUE ;
}
/* ---------------
* Utils for work with runtime commands data
* - - - - - - - - - - - - - - -
*/
2006-03-15 15:13:25 +03:00
static void
vshCommandOptFree ( vshCmdOpt * arg )
{
2005-12-08 13:23:34 +03:00
vshCmdOpt * a = arg ;
2006-03-15 15:13:25 +03:00
while ( a ) {
2005-12-08 13:23:34 +03:00
vshCmdOpt * tmp = a ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
a = a - > next ;
2008-01-29 20:41:07 +03:00
free ( tmp - > data ) ;
2005-12-08 13:23:34 +03:00
free ( tmp ) ;
}
}
static void
2008-08-01 17:51:18 +04:00
vshCommandFree ( vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
vshCmd * c = cmd ;
2006-03-15 15:13:25 +03:00
while ( c ) {
2005-12-08 13:23:34 +03:00
vshCmd * tmp = c ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
c = c - > next ;
if ( tmp - > opts )
vshCommandOptFree ( tmp - > opts ) ;
free ( tmp ) ;
}
}
/*
* Returns option by name
*/
static vshCmdOpt *
2008-08-01 17:51:18 +04:00
vshCommandOpt ( const vshCmd * cmd , const char * name )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
vshCmdOpt * opt = cmd - > opts ;
2006-03-15 15:13:25 +03:00
while ( opt ) {
2008-05-14 23:51:24 +04:00
if ( opt - > def & & STREQ ( opt - > def - > name , name ) )
2005-12-08 13:23:34 +03:00
return opt ;
opt = opt - > next ;
}
return NULL ;
}
/*
* Returns option as INT
*/
static int
2008-08-01 17:51:18 +04:00
vshCommandOptInt ( const vshCmd * cmd , const char * name , int * found )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
vshCmdOpt * arg = vshCommandOpt ( cmd , name ) ;
2007-08-16 17:21:36 +04:00
int res = 0 , num_found = FALSE ;
char * end_p = NULL ;
2006-03-15 15:13:25 +03:00
2007-08-16 17:21:36 +04:00
if ( ( arg ! = NULL ) & & ( arg - > data ! = NULL ) ) {
res = strtol ( arg - > data , & end_p , 10 ) ;
2007-11-08 19:14:12 +03:00
if ( ( arg - > data = = end_p ) | | ( * end_p ! = 0 ) )
num_found = FALSE ;
else
num_found = TRUE ;
2007-08-16 17:21:36 +04:00
}
2005-12-08 13:23:34 +03:00
if ( found )
2007-08-16 17:21:36 +04:00
* found = num_found ;
2005-12-08 13:23:34 +03:00
return res ;
}
/*
* Returns option as STRING
*/
static char *
2008-08-01 17:51:18 +04:00
vshCommandOptString ( const vshCmd * cmd , const char * name , int * found )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
vshCmdOpt * arg = vshCommandOpt ( cmd , name ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( found )
* found = arg ? TRUE : FALSE ;
2006-01-25 12:46:22 +03:00
return arg & & arg - > data & & * arg - > data ? arg - > data : NULL ;
2005-12-08 13:23:34 +03:00
}
2008-02-20 18:29:13 +03:00
#if 0
static int
2008-08-01 17:51:18 +04:00
vshCommandOptStringList ( const vshCmd * cmd , const char * name , char * * * data )
2008-02-20 18:29:13 +03:00
{
vshCmdOpt * arg = cmd - > opts ;
char * * val = NULL ;
int nval = 0 ;
while ( arg ) {
if ( arg - > def & & STREQ ( arg - > def - > name , name ) ) {
char * * tmp = realloc ( val , sizeof ( * tmp ) * ( nval + 1 ) ) ;
if ( ! tmp ) {
free ( val ) ;
return - 1 ;
}
val = tmp ;
val [ nval + + ] = arg - > data ;
}
arg = arg - > next ;
}
* data = val ;
return nval ;
}
# endif
2005-12-08 13:23:34 +03:00
/*
* Returns TRUE / FALSE if the option exists
*/
static int
2008-08-01 17:51:18 +04:00
vshCommandOptBool ( const vshCmd * cmd , const char * name )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
return vshCommandOpt ( cmd , name ) ? TRUE : FALSE ;
}
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
/* Determine whether CMD->opts includes an option with name OPTNAME.
If not , give a diagnostic and return false .
If so , return true . */
static bool
cmd_has_option ( vshControl * ctl , const vshCmd * cmd , const char * optname )
{
/* Iterate through cmd->opts, to ensure that there is an entry
with name OPTNAME and type VSH_OT_DATA . */
bool found = false ;
const vshCmdOpt * opt ;
for ( opt = cmd - > opts ; opt ; opt = opt - > next ) {
if ( STREQ ( opt - > def - > name , optname ) & & opt - > def - > type = = VSH_OT_DATA ) {
found = true ;
break ;
}
}
if ( ! found )
vshError ( ctl , FALSE ,
_ ( " internal error: virsh %s: no %s VSH_OT_DATA option " ) ,
cmd - > def - > name , optname ) ;
return found ;
}
2006-01-25 12:46:22 +03:00
2005-12-15 20:00:43 +03:00
static virDomainPtr
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
vshCommandOptDomainBy ( vshControl * ctl , const vshCmd * cmd ,
2007-02-07 16:50:18 +03:00
char * * name , int flag )
2006-03-15 15:13:25 +03:00
{
2005-12-15 20:00:43 +03:00
virDomainPtr dom = NULL ;
2007-11-12 17:00:32 +03:00
char * n ;
2005-12-15 20:00:43 +03:00
int id ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
const char * optname = " domain " ;
if ( ! cmd_has_option ( ctl , cmd , optname ) )
return NULL ;
2006-03-15 15:13:25 +03:00
2005-12-15 20:00:43 +03:00
if ( ! ( n = vshCommandOptString ( cmd , optname , NULL ) ) ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " undefined domain name or id " ) ) ;
2006-03-15 15:13:25 +03:00
return NULL ;
2005-12-15 20:00:43 +03:00
}
2006-03-15 15:13:25 +03:00
2006-05-22 18:38:33 +04:00
vshDebug ( ctl , 5 , " %s: found option <%s>: %s \n " ,
2006-03-15 15:13:25 +03:00
cmd - > def - > name , optname , n ) ;
2005-12-15 20:00:43 +03:00
if ( name )
* name = n ;
2006-03-15 15:13:25 +03:00
2005-12-15 20:00:43 +03:00
/* try it by ID */
2007-02-14 18:44:58 +03:00
if ( flag & VSH_BYID ) {
2008-02-08 12:15:16 +03:00
if ( virStrToLong_i ( n , NULL , 10 , & id ) = = 0 & & id > = 0 ) {
2006-05-29 19:39:31 +04:00
vshDebug ( ctl , 5 , " %s: <%s> seems like domain ID \n " ,
cmd - > def - > name , optname ) ;
dom = virDomainLookupByID ( ctl - > conn , id ) ;
}
2006-01-25 12:46:22 +03:00
}
2006-05-22 18:38:33 +04:00
/* try it by UUID */
2007-02-14 18:44:58 +03:00
if ( dom = = NULL & & ( flag & VSH_BYUUID ) & & strlen ( n ) = = VIR_UUID_STRING_BUFLEN - 1 ) {
2008-04-04 11:58:29 +04:00
vshDebug ( ctl , 5 , " %s: <%s> trying as domain UUID \n " ,
2007-02-07 16:50:18 +03:00
cmd - > def - > name , optname ) ;
2006-05-29 19:39:31 +04:00
dom = virDomainLookupByUUIDString ( ctl - > conn , n ) ;
2006-05-22 18:38:33 +04:00
}
2005-12-15 20:00:43 +03:00
/* try it by NAME */
2007-02-14 18:44:58 +03:00
if ( dom = = NULL & & ( flag & VSH_BYNAME ) ) {
2008-04-04 11:58:29 +04:00
vshDebug ( ctl , 5 , " %s: <%s> trying as domain NAME \n " ,
2006-03-15 15:13:25 +03:00
cmd - > def - > name , optname ) ;
2005-12-15 20:00:43 +03:00
dom = virDomainLookupByName ( ctl - > conn , n ) ;
2006-01-25 12:46:22 +03:00
}
2006-05-22 18:38:33 +04:00
2006-03-15 15:13:25 +03:00
if ( ! dom )
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " failed to get domain '%s' " ) , n ) ;
2006-03-15 15:13:25 +03:00
2005-12-15 20:00:43 +03:00
return dom ;
}
2007-02-14 19:53:55 +03:00
static virNetworkPtr
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
vshCommandOptNetworkBy ( vshControl * ctl , const vshCmd * cmd ,
2008-04-10 20:54:54 +04:00
char * * name , int flag )
2007-02-14 19:53:55 +03:00
{
virNetworkPtr network = NULL ;
char * n ;
remove redundant optname arguments
This is the second part of the change mentioned here:
http://thread.gmane.org/gmane.comp.emulators.libvirt/10331
It removes the essentially redundant "optname" parameter
from each of the vshCommandOptNetworkBy and vshCommandOptDomainBy
functions as well as the correspond macros (without "By" suffix).
Now, instead of always passing the optname, "domain", to
vshCommandOptDomainBy, that function requires that its command
argument refer to an opts array containing a "domain" option.
This normalization makes one more help-related change:
it renames the net-start "name" argument to the more
sensible and consistent "network".
* src/virsh.c (VSH_BYNAME, vshCommandOptDomain)
(cmd_has_option): New function, used in vshCommandOptDomainBy
and vshCommandOptNetworkBy.
(vshCommandOptDomainBy, vshCommandOptNetworkBy): Remove the optname
parameter, it's always "domain" ("network"). Update all callers.
Call cmd_has_option.
(vshCommandOptNetwork, cmdAutostart, cmdConsole, cmdDomstate)
(cmdDomblkstat, cmdDomIfstat, cmdSuspend, cmdUndefine, cmdStart)
(cmdSave, cmdSchedinfo, cmdDump, cmdResume, cmdShutdown)
(cmdReboot, cmdDestroy, cmdDominfo, cmdVcpuinfo, cmdVcpupin)
(cmdSetvcpus, cmdSetmem, cmdSetmaxmem, cmdDumpXML, cmdDomname)
(cmdDomid, cmdDomuuid, cmdMigrate, cmdNetworkAutostart)
(cmdNetworkDestroy, cmdNetworkDumpXML, cmdNetworkName)
(opts_network_start, cmdNetworkStart, cmdNetworkUndefine)
(cmdNetworkUuid, cmdVNCDisplay, cmdTTYConsole, cmdAttachDevice)
(cmdDetachDevice, cmdAttachInterface, cmdDetachInterface)
(cmdAttachDisk, cmdDetachDisk, cmdEdit)
* src/Makefile.am (virsh-pool-edit.c): This code is generated
from cmdEdit, and cmdEdit uses the vshCommandOptDomain macro which
now, with the changes above, has only 3 (was 4) arguments, yet the
macro use is mapped to vshCommandOptPool, which still requires 4
arguments. So this change adjusts the sed code to reinsert the
just-removed argument -- we're not changing pool-related code right
now, because it's not as straight-forward.
2008-12-15 13:26:54 +03:00
const char * optname = " network " ;
if ( ! cmd_has_option ( ctl , cmd , optname ) )
return NULL ;
2007-02-14 19:53:55 +03:00
if ( ! ( n = vshCommandOptString ( cmd , optname , NULL ) ) ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " undefined network name " ) ) ;
2007-02-14 19:53:55 +03:00
return NULL ;
}
vshDebug ( ctl , 5 , " %s: found option <%s>: %s \n " ,
cmd - > def - > name , optname , n ) ;
if ( name )
* name = n ;
/* try it by UUID */
if ( network = = NULL & & ( flag & VSH_BYUUID ) & & strlen ( n ) = = VIR_UUID_STRING_BUFLEN - 1 ) {
2008-04-04 11:58:29 +04:00
vshDebug ( ctl , 5 , " %s: <%s> trying as network UUID \n " ,
2008-04-10 20:54:54 +04:00
cmd - > def - > name , optname ) ;
2007-02-14 19:53:55 +03:00
network = virNetworkLookupByUUIDString ( ctl - > conn , n ) ;
}
/* try it by NAME */
if ( network = = NULL & & ( flag & VSH_BYNAME ) ) {
2008-04-04 11:58:29 +04:00
vshDebug ( ctl , 5 , " %s: <%s> trying as network NAME \n " ,
2007-02-14 19:53:55 +03:00
cmd - > def - > name , optname ) ;
network = virNetworkLookupByName ( ctl - > conn , n ) ;
}
if ( ! network )
vshError ( ctl , FALSE , _ ( " failed to get network '%s' " ) , n ) ;
return network ;
}
2008-02-20 18:27:08 +03:00
static virStoragePoolPtr
2008-08-01 17:51:18 +04:00
vshCommandOptPoolBy ( vshControl * ctl , const vshCmd * cmd , const char * optname ,
2008-02-20 18:27:08 +03:00
char * * name , int flag )
{
virStoragePoolPtr pool = NULL ;
char * n ;
if ( ! ( n = vshCommandOptString ( cmd , optname , NULL ) ) ) {
vshError ( ctl , FALSE , " %s " , _ ( " undefined pool name " ) ) ;
return NULL ;
}
vshDebug ( ctl , 5 , " %s: found option <%s>: %s \n " ,
cmd - > def - > name , optname , n ) ;
if ( name )
* name = n ;
/* try it by UUID */
if ( pool = = NULL & & ( flag & VSH_BYUUID ) & & strlen ( n ) = = VIR_UUID_STRING_BUFLEN - 1 ) {
vshDebug ( ctl , 5 , " %s: <%s> trying as pool UUID \n " ,
2008-04-10 20:54:54 +04:00
cmd - > def - > name , optname ) ;
2008-02-20 18:27:08 +03:00
pool = virStoragePoolLookupByUUIDString ( ctl - > conn , n ) ;
}
/* try it by NAME */
if ( pool = = NULL & & ( flag & VSH_BYNAME ) ) {
vshDebug ( ctl , 5 , " %s: <%s> trying as pool NAME \n " ,
cmd - > def - > name , optname ) ;
pool = virStoragePoolLookupByName ( ctl - > conn , n ) ;
}
if ( ! pool )
vshError ( ctl , FALSE , _ ( " failed to get pool '%s' " ) , n ) ;
return pool ;
}
static virStorageVolPtr
2008-08-01 17:51:18 +04:00
vshCommandOptVolBy ( vshControl * ctl , const vshCmd * cmd ,
2008-02-20 18:27:08 +03:00
const char * optname ,
const char * pooloptname ,
char * * name , int flag )
{
virStorageVolPtr vol = NULL ;
virStoragePoolPtr pool = NULL ;
char * n , * p ;
int found ;
if ( ! ( n = vshCommandOptString ( cmd , optname , NULL ) ) ) {
vshError ( ctl , FALSE , " %s " , _ ( " undefined vol name " ) ) ;
return NULL ;
}
if ( ! ( p = vshCommandOptString ( cmd , pooloptname , & found ) ) & & found ) {
vshError ( ctl , FALSE , " %s " , _ ( " undefined pool name " ) ) ;
return NULL ;
}
if ( p )
pool = vshCommandOptPoolBy ( ctl , cmd , pooloptname , name , flag ) ;
vshDebug ( ctl , 5 , " %s: found option <%s>: %s \n " ,
cmd - > def - > name , optname , n ) ;
if ( name )
* name = n ;
/* try it by PATH */
if ( pool & & ( flag & VSH_BYNAME ) ) {
vshDebug ( ctl , 5 , " %s: <%s> trying as vol UUID \n " ,
cmd - > def - > name , optname ) ;
vol = virStorageVolLookupByName ( pool , n ) ;
}
if ( vol = = NULL & & ( flag & VSH_BYUUID ) ) {
vshDebug ( ctl , 5 , " %s: <%s> trying as vol key \n " ,
cmd - > def - > name , optname ) ;
vol = virStorageVolLookupByKey ( ctl - > conn , n ) ;
}
if ( vol = = NULL & & ( flag & VSH_BYUUID ) ) {
vshDebug ( ctl , 5 , " %s: <%s> trying as vol path \n " ,
cmd - > def - > name , optname ) ;
vol = virStorageVolLookupByPath ( ctl - > conn , n ) ;
}
if ( ! vol )
vshError ( ctl , FALSE , _ ( " failed to get vol '%s' " ) , n ) ;
if ( pool )
virStoragePoolFree ( pool ) ;
return vol ;
}
2005-12-08 13:23:34 +03:00
/*
* Executes command ( s ) and returns return code from last command
*/
static int
2008-08-01 17:51:18 +04:00
vshCommandRun ( vshControl * ctl , const vshCmd * cmd )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
int ret = TRUE ;
2006-03-15 15:13:25 +03:00
while ( cmd ) {
2005-12-08 13:23:34 +03:00
struct timeval before , after ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ctl - > timing )
GETTIMEOFDAY ( & before ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
ret = cmd - > def - > handler ( ctl , cmd ) ;
if ( ctl - > timing )
GETTIMEOFDAY ( & after ) ;
2006-03-15 15:13:25 +03:00
2009-02-09 17:24:06 +03:00
if ( ret = = FALSE )
virshReportError ( ctl ) ;
2008-05-14 23:51:24 +04:00
if ( STREQ ( cmd - > def - > name , " quit " ) ) /* hack ... */
2005-12-08 13:23:34 +03:00
return ret ;
if ( ctl - > timing )
2006-09-21 19:24:37 +04:00
vshPrint ( ctl , _ ( " \n (Time: %.3f ms) \n \n " ) ,
2006-03-15 15:13:25 +03:00
DIFF_MSEC ( & after , & before ) ) ;
else
2006-05-22 18:38:33 +04:00
vshPrintExtra ( ctl , " \n " ) ;
2005-12-08 13:23:34 +03:00
cmd = cmd - > next ;
}
return ret ;
}
/* ---------------
* Command string parsing
* - - - - - - - - - - - - - - -
*/
# define VSH_TK_ERROR -1
# define VSH_TK_NONE 0
# define VSH_TK_OPTION 1
# define VSH_TK_DATA 2
# define VSH_TK_END 3
2006-03-15 15:13:25 +03:00
static int
2008-08-01 17:51:18 +04:00
vshCommandGetToken ( vshControl * ctl , char * str , char * * end , char * * res )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
int tk = VSH_TK_NONE ;
int quote = FALSE ;
int sz = 0 ;
char * p = str ;
char * tkstr = NULL ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
* end = NULL ;
2006-03-15 15:13:25 +03:00
2007-07-04 13:16:23 +04:00
while ( p & & * p & & ( * p = = ' ' | | * p = = ' \t ' ) )
2005-12-08 13:23:34 +03:00
p + + ;
2006-03-15 15:13:25 +03:00
if ( p = = NULL | | * p = = ' \0 ' )
2005-12-08 13:23:34 +03:00
return VSH_TK_END ;
2006-03-15 15:13:25 +03:00
if ( * p = = ' ; ' ) {
2008-04-04 11:58:29 +04:00
* end = + + p ; /* = \0 or begin of next command */
2005-12-08 13:23:34 +03:00
return VSH_TK_END ;
}
2006-03-15 15:13:25 +03:00
while ( * p ) {
2005-12-08 13:23:34 +03:00
/* end of token is blank space or ';' */
2007-07-04 13:16:23 +04:00
if ( ( quote = = FALSE & & ( * p = = ' ' | | * p = = ' \t ' ) ) | | * p = = ' ; ' )
2005-12-08 13:23:34 +03:00
break ;
2006-03-15 15:13:25 +03:00
2006-01-25 12:46:22 +03:00
/* end of option name could be '=' */
2006-03-15 15:13:25 +03:00
if ( tk = = VSH_TK_OPTION & & * p = = ' = ' ) {
p + + ; /* skip '=' */
2006-01-25 12:46:22 +03:00
break ;
}
2006-03-15 15:13:25 +03:00
if ( tk = = VSH_TK_NONE ) {
if ( * p = = ' - ' & & * ( p + 1 ) = = ' - ' & & * ( p + 2 )
2008-05-09 17:50:14 +04:00
& & c_isalnum ( * ( p + 2 ) ) ) {
2005-12-08 13:23:34 +03:00
tk = VSH_TK_OPTION ;
2006-03-15 15:13:25 +03:00
p + = 2 ;
2005-12-08 13:23:34 +03:00
} else {
tk = VSH_TK_DATA ;
2006-03-15 15:13:25 +03:00
if ( * p = = ' " ' ) {
quote = TRUE ;
2005-12-08 13:23:34 +03:00
p + + ;
} else {
quote = FALSE ;
}
}
2006-03-15 15:13:25 +03:00
tkstr = p ; /* begin of token */
} else if ( quote & & * p = = ' " ' ) {
2005-12-08 13:23:34 +03:00
quote = FALSE ;
p + + ;
2006-03-15 15:13:25 +03:00
break ; /* end of "..." token */
2005-12-08 13:23:34 +03:00
}
p + + ;
sz + + ;
}
if ( quote ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " missing \" " ) ) ;
2005-12-08 13:23:34 +03:00
return VSH_TK_ERROR ;
}
2006-03-15 15:13:25 +03:00
if ( tkstr = = NULL | | * tkstr = = ' \0 ' | | p = = NULL )
2005-12-08 13:23:34 +03:00
return VSH_TK_END ;
2006-03-15 15:13:25 +03:00
if ( sz = = 0 )
2005-12-08 13:23:34 +03:00
return VSH_TK_END ;
2006-03-15 15:13:25 +03:00
2006-04-06 14:33:06 +04:00
* res = vshMalloc ( ctl , sz + 1 ) ;
2005-12-08 13:23:34 +03:00
memcpy ( * res , tkstr , sz ) ;
2006-03-15 15:13:25 +03:00
* ( * res + sz ) = ' \0 ' ;
2005-12-08 13:23:34 +03:00
* end = p ;
return tk ;
}
static int
2008-08-01 17:51:18 +04:00
vshCommandParse ( vshControl * ctl , char * cmdstr )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
char * str ;
char * tkdata = NULL ;
vshCmd * clast = NULL ;
vshCmdOpt * first = NULL ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ctl - > cmd ) {
vshCommandFree ( ctl - > cmd ) ;
ctl - > cmd = NULL ;
}
2006-03-15 15:13:25 +03:00
if ( cmdstr = = NULL | | * cmdstr = = ' \0 ' )
2005-12-08 13:23:34 +03:00
return FALSE ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
str = cmdstr ;
2006-03-15 15:13:25 +03:00
while ( str & & * str ) {
2005-12-08 13:23:34 +03:00
vshCmdOpt * last = NULL ;
2008-08-01 16:19:56 +04:00
const vshCmdDef * cmd = NULL ;
2005-12-08 13:23:34 +03:00
int tk = VSH_TK_NONE ;
2006-01-25 12:46:22 +03:00
int data_ct = 0 ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
first = NULL ;
2006-03-15 15:13:25 +03:00
while ( tk ! = VSH_TK_END ) {
2005-12-08 13:23:34 +03:00
char * end = NULL ;
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * opt = NULL ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
tkdata = NULL ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
/* get token */
tk = vshCommandGetToken ( ctl , str , & end , & tkdata ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
str = end ;
2006-03-15 15:13:25 +03:00
if ( tk = = VSH_TK_END )
2005-12-08 13:23:34 +03:00
break ;
2006-03-15 15:13:25 +03:00
if ( tk = = VSH_TK_ERROR )
2005-12-08 13:23:34 +03:00
goto syntaxError ;
2006-03-15 15:13:25 +03:00
if ( cmd = = NULL ) {
2005-12-08 13:23:34 +03:00
/* first token must be command name */
2006-03-15 15:13:25 +03:00
if ( tk ! = VSH_TK_DATA ) {
vshError ( ctl , FALSE ,
2006-09-21 19:24:37 +04:00
_ ( " unexpected token (command name): '%s' " ) ,
2006-03-15 15:13:25 +03:00
tkdata ) ;
2005-12-08 13:23:34 +03:00
goto syntaxError ;
}
if ( ! ( cmd = vshCmddefSearch ( tkdata ) ) ) {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " unknown command: '%s' " ) , tkdata ) ;
2006-03-15 15:13:25 +03:00
goto syntaxError ; /* ... or ignore this command only? */
2005-12-08 13:23:34 +03:00
}
free ( tkdata ) ;
2006-03-15 15:13:25 +03:00
} else if ( tk = = VSH_TK_OPTION ) {
2005-12-08 13:23:34 +03:00
if ( ! ( opt = vshCmddefGetOption ( cmd , tkdata ) ) ) {
vshError ( ctl , FALSE ,
2006-09-21 19:24:37 +04:00
_ ( " command '%s' doesn't support option --%s " ) ,
2006-03-15 15:13:25 +03:00
cmd - > name , tkdata ) ;
2005-12-08 13:23:34 +03:00
goto syntaxError ;
}
2006-03-15 15:13:25 +03:00
free ( tkdata ) ; /* option name */
2005-12-08 13:23:34 +03:00
tkdata = NULL ;
if ( opt - > type ! = VSH_OT_BOOL ) {
/* option data */
tk = vshCommandGetToken ( ctl , str , & end , & tkdata ) ;
2006-03-15 15:13:25 +03:00
str = end ;
if ( tk = = VSH_TK_ERROR )
2005-12-08 13:23:34 +03:00
goto syntaxError ;
2006-03-15 15:13:25 +03:00
if ( tk ! = VSH_TK_DATA ) {
2005-12-08 13:23:34 +03:00
vshError ( ctl , FALSE ,
2006-09-21 19:24:37 +04:00
_ ( " expected syntax: --%s <%s> " ) ,
2006-03-15 15:13:25 +03:00
opt - > name ,
opt - > type = =
2006-09-21 19:24:37 +04:00
VSH_OT_INT ? _ ( " number " ) : _ ( " string " ) ) ;
2005-12-08 13:23:34 +03:00
goto syntaxError ;
}
}
2006-03-15 15:13:25 +03:00
} else if ( tk = = VSH_TK_DATA ) {
2006-01-25 12:46:22 +03:00
if ( ! ( opt = vshCmddefGetData ( cmd , data_ct + + ) ) ) {
2006-09-21 19:24:37 +04:00
vshError ( ctl , FALSE , _ ( " unexpected data '%s' " ) , tkdata ) ;
2005-12-08 13:23:34 +03:00
goto syntaxError ;
}
}
if ( opt ) {
/* save option */
2006-04-06 14:33:06 +04:00
vshCmdOpt * arg = vshMalloc ( ctl , sizeof ( vshCmdOpt ) ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
arg - > def = opt ;
arg - > data = tkdata ;
arg - > next = NULL ;
tkdata = NULL ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! first )
first = arg ;
if ( last )
last - > next = arg ;
last = arg ;
2006-03-15 15:13:25 +03:00
2006-05-22 18:38:33 +04:00
vshDebug ( ctl , 4 , " %s: %s(%s): %s \n " ,
2006-03-15 15:13:25 +03:00
cmd - > name ,
opt - > name ,
2006-09-21 19:24:37 +04:00
tk = = VSH_TK_OPTION ? _ ( " OPTION " ) : _ ( " DATA " ) ,
2006-03-15 15:13:25 +03:00
arg - > data ) ;
2005-12-08 13:23:34 +03:00
}
if ( ! str )
break ;
}
2006-03-15 15:13:25 +03:00
2008-04-04 11:58:29 +04:00
/* command parsed -- allocate new struct for the command */
2005-12-08 13:23:34 +03:00
if ( cmd ) {
2006-04-06 14:33:06 +04:00
vshCmd * c = vshMalloc ( ctl , sizeof ( vshCmd ) ) ;
2006-03-30 16:14:40 +04:00
2005-12-08 13:23:34 +03:00
c - > opts = first ;
c - > def = cmd ;
c - > next = NULL ;
2007-05-29 17:55:19 +04:00
if ( ! vshCommandCheckOpts ( ctl , c ) ) {
2008-01-29 20:41:07 +03:00
free ( c ) ;
2006-01-25 12:46:22 +03:00
goto syntaxError ;
2007-05-29 17:55:19 +04:00
}
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! ctl - > cmd )
ctl - > cmd = c ;
if ( clast )
clast - > next = c ;
clast = c ;
}
}
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
return TRUE ;
2007-02-07 16:50:18 +03:00
syntaxError :
2005-12-08 13:23:34 +03:00
if ( ctl - > cmd )
vshCommandFree ( ctl - > cmd ) ;
if ( first )
vshCommandOptFree ( first ) ;
2008-01-29 20:41:07 +03:00
free ( tkdata ) ;
2006-03-15 15:13:25 +03:00
return FALSE ;
2005-12-08 13:23:34 +03:00
}
/* ---------------
2007-02-07 16:50:18 +03:00
* Misc utils
2005-12-08 13:23:34 +03:00
* - - - - - - - - - - - - - - -
*/
2005-12-08 17:22:52 +03:00
static const char *
2006-03-15 15:13:25 +03:00
vshDomainStateToString ( int state )
{
2005-12-08 13:23:34 +03:00
switch ( state ) {
2007-02-07 16:50:18 +03:00
case VIR_DOMAIN_RUNNING :
return gettext_noop ( " running " ) ;
case VIR_DOMAIN_BLOCKED :
2008-09-17 18:18:15 +04:00
return gettext_noop ( " idle " ) ;
2007-02-07 16:50:18 +03:00
case VIR_DOMAIN_PAUSED :
return gettext_noop ( " paused " ) ;
case VIR_DOMAIN_SHUTDOWN :
return gettext_noop ( " in shutdown " ) ;
case VIR_DOMAIN_SHUTOFF :
return gettext_noop ( " shut off " ) ;
case VIR_DOMAIN_CRASHED :
return gettext_noop ( " crashed " ) ;
default :
2007-09-29 22:16:26 +04:00
; /*FALLTHROUGH*/
2005-12-08 13:23:34 +03:00
}
2007-09-29 22:16:26 +04:00
return gettext_noop ( " no state " ) ; /* = dom0 state */
2005-12-08 13:23:34 +03:00
}
2006-08-07 18:35:20 +04:00
static const char *
vshDomainVcpuStateToString ( int state )
{
switch ( state ) {
2007-02-07 16:50:18 +03:00
case VIR_VCPU_OFFLINE :
return gettext_noop ( " offline " ) ;
case VIR_VCPU_BLOCKED :
2008-09-17 18:18:15 +04:00
return gettext_noop ( " idle " ) ;
2007-02-07 16:50:18 +03:00
case VIR_VCPU_RUNNING :
return gettext_noop ( " running " ) ;
default :
2007-09-29 22:16:26 +04:00
; /*FALLTHROUGH*/
2006-08-07 18:35:20 +04:00
}
2007-09-29 22:16:26 +04:00
return gettext_noop ( " no state " ) ;
2006-08-07 18:35:20 +04:00
}
2005-12-08 13:23:34 +03:00
static int
2008-08-01 17:51:18 +04:00
vshConnectionUsability ( vshControl * ctl , virConnectPtr conn , int showerror )
2006-03-15 15:13:25 +03:00
{
2007-02-07 16:50:18 +03:00
/* TODO: use something like virConnectionState() to
* check usability of the connection
2005-12-08 13:23:34 +03:00
*/
if ( ! conn ) {
if ( showerror )
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " no valid connection " ) ) ;
2005-12-08 13:23:34 +03:00
return FALSE ;
}
return TRUE ;
}
2006-05-22 18:38:33 +04:00
static void
2008-08-01 17:51:18 +04:00
vshDebug ( vshControl * ctl , int level , const char * format , . . . )
2006-03-15 15:13:25 +03:00
{
2006-05-22 18:38:33 +04:00
va_list ap ;
2007-06-06 16:24:31 +04:00
va_start ( ap , format ) ;
vshOutputLogFile ( ctl , VSH_ERR_DEBUG , format , ap ) ;
va_end ( ap ) ;
2006-05-22 18:38:33 +04:00
if ( level > ctl - > debug )
return ;
va_start ( ap , format ) ;
vfprintf ( stdout , format , ap ) ;
va_end ( ap ) ;
2005-12-08 13:23:34 +03:00
}
static void
2008-08-01 17:51:18 +04:00
vshPrintExtra ( vshControl * ctl , const char * format , . . . )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
va_list ap ;
2006-03-15 15:13:25 +03:00
2006-05-22 18:38:33 +04:00
if ( ctl - > quiet = = TRUE )
2005-12-08 13:23:34 +03:00
return ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
va_start ( ap , format ) ;
2006-04-06 14:33:06 +04:00
vfprintf ( stdout , format , ap ) ;
2005-12-08 13:23:34 +03:00
va_end ( ap ) ;
}
2006-05-22 18:38:33 +04:00
2005-12-08 13:23:34 +03:00
static void
2008-08-01 17:51:18 +04:00
vshError ( vshControl * ctl , int doexit , const char * format , . . . )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
va_list ap ;
2006-03-15 15:13:25 +03:00
2007-06-06 16:24:31 +04:00
va_start ( ap , format ) ;
vshOutputLogFile ( ctl , VSH_ERR_ERROR , format , ap ) ;
va_end ( ap ) ;
2005-12-08 13:23:34 +03:00
if ( doexit )
2006-09-21 19:24:37 +04:00
fprintf ( stderr , _ ( " %s: error: " ) , progname ) ;
2005-12-08 13:23:34 +03:00
else
2006-09-21 19:24:37 +04:00
fputs ( _ ( " error: " ) , stderr ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
va_start ( ap , format ) ;
vfprintf ( stderr , format , ap ) ;
va_end ( ap ) ;
fputc ( ' \n ' , stderr ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( doexit ) {
2006-04-06 14:33:06 +04:00
if ( ctl )
vshDeinit ( ctl ) ;
2005-12-08 13:23:34 +03:00
exit ( EXIT_FAILURE ) ;
}
}
2006-04-06 14:33:06 +04:00
static void *
2008-08-01 17:51:18 +04:00
_vshMalloc ( vshControl * ctl , size_t size , const char * filename , int line )
2006-04-06 14:33:06 +04:00
{
void * x ;
if ( ( x = malloc ( size ) ) )
return x ;
2006-09-21 19:24:37 +04:00
vshError ( ctl , TRUE , _ ( " %s: %d: failed to allocate %d bytes " ) ,
2007-02-07 16:50:18 +03:00
filename , line , ( int ) size ) ;
2006-04-06 14:33:06 +04:00
return NULL ;
}
static void *
2008-08-01 17:51:18 +04:00
_vshCalloc ( vshControl * ctl , size_t nmemb , size_t size , const char * filename , int line )
2006-04-06 14:33:06 +04:00
{
void * x ;
if ( ( x = calloc ( nmemb , size ) ) )
return x ;
2006-09-21 19:24:37 +04:00
vshError ( ctl , TRUE , _ ( " %s: %d: failed to allocate %d bytes " ) ,
2007-02-07 16:50:18 +03:00
filename , line , ( int ) ( size * nmemb ) ) ;
2006-04-06 14:33:06 +04:00
return NULL ;
}
2007-06-19 13:12:55 +04:00
static void *
2008-08-01 17:51:18 +04:00
_vshRealloc ( vshControl * ctl , void * ptr , size_t size , const char * filename , int line )
2007-06-19 13:12:55 +04:00
{
void * x ;
if ( ( x = realloc ( ptr , size ) ) )
return x ;
free ( ptr ) ;
vshError ( ctl , TRUE , _ ( " %s: %d: failed to allocate %d bytes " ) ,
filename , line , ( int ) size ) ;
return NULL ;
}
2006-04-06 14:33:06 +04:00
static char *
2008-08-01 17:51:18 +04:00
_vshStrdup ( vshControl * ctl , const char * s , const char * filename , int line )
2006-04-06 14:33:06 +04:00
{
char * x ;
2007-04-26 14:20:57 +04:00
if ( s = = NULL )
return ( NULL ) ;
2006-04-06 14:33:06 +04:00
if ( ( x = strdup ( s ) ) )
return x ;
2007-03-19 17:20:30 +03:00
vshError ( ctl , TRUE , _ ( " %s: %d: failed to allocate %lu bytes " ) ,
filename , line , ( unsigned long ) strlen ( s ) ) ;
2006-04-06 14:33:06 +04:00
return NULL ;
}
2005-12-08 13:23:34 +03:00
/*
2007-06-20 21:22:09 +04:00
* Initialize connection .
2005-12-08 13:23:34 +03:00
*/
static int
2008-08-01 17:51:18 +04:00
vshInit ( vshControl * ctl )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
if ( ctl - > conn )
return FALSE ;
2007-06-06 16:24:31 +04:00
vshOpenLogFile ( ctl ) ;
2006-02-28 00:34:28 +03:00
/* set up the library error handler */
virSetErrorFunc ( NULL , virshErrorHandler ) ;
2006-03-15 15:13:25 +03:00
2007-12-05 21:55:04 +03:00
ctl - > conn = virConnectOpenAuth ( ctl - > name ,
virConnectAuthPtrDefault ,
ctl - > readonly ? VIR_CONNECT_RO : 0 ) ;
2006-03-15 15:13:25 +03:00
2007-06-20 21:22:09 +04:00
/* This is not necessarily fatal. All the individual commands check
* vshConnectionUsability , except ones which don ' t need a connection
* such as " help " .
*/
2007-12-05 19:24:22 +03:00
if ( ! ctl - > conn ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to connect to the hypervisor " ) ) ;
2007-12-05 19:24:22 +03:00
return FALSE ;
}
2005-12-08 13:23:34 +03:00
return TRUE ;
}
2007-12-07 17:56:37 +03:00
# ifndef O_SYNC
# define O_SYNC 0
# endif
# define LOGFILE_FLAGS (O_WRONLY | O_APPEND | O_CREAT | O_SYNC)
2007-06-06 16:24:31 +04:00
/**
* vshOpenLogFile :
*
* Open log file .
*/
static void
vshOpenLogFile ( vshControl * ctl )
{
struct stat st ;
if ( ctl - > logfile = = NULL )
return ;
/* check log file */
if ( stat ( ctl - > logfile , & st ) = = - 1 ) {
switch ( errno ) {
case ENOENT :
break ;
default :
2008-01-16 20:13:23 +03:00
vshError ( ctl , TRUE , " %s " ,
_ ( " failed to get the log file information " ) ) ;
2007-06-06 16:24:31 +04:00
break ;
}
} else {
if ( ! S_ISREG ( st . st_mode ) ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , TRUE , " %s " , _ ( " the log path is not a file " ) ) ;
2007-06-06 16:24:31 +04:00
}
}
/* log file open */
2007-12-07 17:56:37 +03:00
if ( ( ctl - > log_fd = open ( ctl - > logfile , LOGFILE_FLAGS , FILE_MODE ) ) < 0 ) {
2008-01-16 20:13:23 +03:00
vshError ( ctl , TRUE , " %s " ,
_ ( " failed to open the log file. check the log file path " ) ) ;
2007-06-06 16:24:31 +04:00
}
}
/**
* vshOutputLogFile :
*
* Outputting an error to log file .
*/
static void
vshOutputLogFile ( vshControl * ctl , int log_level , const char * msg_format , va_list ap )
{
char msg_buf [ MSG_BUFFER ] ;
const char * lvl = " " ;
struct timeval stTimeval ;
struct tm * stTm ;
if ( ctl - > log_fd = = - 1 )
return ;
/**
* create log format
*
* [ YYYY . MM . DD HH : MM : SS SIGNATURE PID ] LOG_LEVEL message
*/
gettimeofday ( & stTimeval , NULL ) ;
stTm = localtime ( & stTimeval . tv_sec ) ;
snprintf ( msg_buf , sizeof ( msg_buf ) ,
" [%d.%02d.%02d %02d:%02d:%02d " ,
( 1900 + stTm - > tm_year ) ,
( 1 + stTm - > tm_mon ) ,
( stTm - > tm_mday ) ,
( stTm - > tm_hour ) ,
( stTm - > tm_min ) ,
( stTm - > tm_sec ) ) ;
snprintf ( msg_buf + strlen ( msg_buf ) , sizeof ( msg_buf ) - strlen ( msg_buf ) ,
" %s] " , SIGN_NAME ) ;
switch ( log_level ) {
case VSH_ERR_DEBUG :
lvl = LVL_DEBUG ;
break ;
case VSH_ERR_INFO :
lvl = LVL_INFO ;
break ;
case VSH_ERR_NOTICE :
lvl = LVL_INFO ;
break ;
case VSH_ERR_WARNING :
lvl = LVL_WARNING ;
break ;
case VSH_ERR_ERROR :
lvl = LVL_ERROR ;
break ;
default :
lvl = LVL_DEBUG ;
break ;
}
snprintf ( msg_buf + strlen ( msg_buf ) , sizeof ( msg_buf ) - strlen ( msg_buf ) ,
" %s " , lvl ) ;
vsnprintf ( msg_buf + strlen ( msg_buf ) , sizeof ( msg_buf ) - strlen ( msg_buf ) ,
msg_format , ap ) ;
if ( msg_buf [ strlen ( msg_buf ) - 1 ] ! = ' \n ' )
snprintf ( msg_buf + strlen ( msg_buf ) , sizeof ( msg_buf ) - strlen ( msg_buf ) , " \n " ) ;
/* write log */
Use safewrite in place of write, in many cases.
Also add "make syntax-check" rules to ensure no new uses sneak in.
There are many uses of write like this:
if (write (fd, xml, towrite) != towrite)
return -1;
The problem is that the syscall can succeed, yet write less than
the requested number of bytes, so the caller should retry
rather than simply failing.
This patch changes most of them to use util.c's safewrite wrapper,
which encapsulates the process. Also, there were a few cases in
which the retry loop was open-coded, and I replaced those, too.
* Makefile.maint (sc_avoid_write): New rule, to avoid recurrence.
* .x-sc_avoid_write: New file. Record two legitimate exemptions.
* qemud/qemud.c (sig_handler, qemudClientWriteBuf): Use safewrite, not write.
* src/conf.c (__virConfWriteFile): Likewise.
* src/qemu_conf.c (qemudSaveConfig, qemudSaveNetworkConfig): Likewise.
* src/qemu_driver.c (qemudWaitForMonitor, qemudStartVMDaemon)
(qemudVMData, PROC_IP_FORWARD): Likewise.
* proxy/libvirt_proxy.c: Include "util.h".
(proxyWriteClientSocket): Use safewrite.
* src/test.c (testDomainSave, testDomainCoreDump): Likewise.
* src/proxy_internal.c (virProxyWriteClientSocket): Likewise.
* src/virsh.c: Include "util-lib.h".
(vshOutputLogFile): Use safewrite.
* src/console.c: Include "util-lib.h".
(vshRunConsole): Use safewrite.
2008-02-22 18:55:04 +03:00
if ( safewrite ( ctl - > log_fd , msg_buf , strlen ( msg_buf ) ) < 0 ) {
2007-06-06 16:24:31 +04:00
vshCloseLogFile ( ctl ) ;
2008-01-16 20:13:23 +03:00
vshError ( ctl , FALSE , " %s " , _ ( " failed to write the log file " ) ) ;
2007-06-06 16:24:31 +04:00
}
}
/**
* vshCloseLogFile :
*
* Close log file .
*/
static void
vshCloseLogFile ( vshControl * ctl )
{
/* log file close */
if ( ctl - > log_fd > = 0 ) {
2007-11-28 16:22:33 +03:00
if ( close ( ctl - > log_fd ) < 0 )
2007-11-28 17:22:30 +03:00
vshError ( ctl , FALSE , _ ( " %s: failed to write log file: %s " ) ,
2007-11-28 16:22:33 +03:00
ctl - > logfile ? ctl - > logfile : " ? " , strerror ( errno ) ) ;
2007-06-06 16:24:31 +04:00
ctl - > log_fd = - 1 ;
}
if ( ctl - > logfile ) {
free ( ctl - > logfile ) ;
ctl - > logfile = NULL ;
}
}
2007-12-06 13:24:52 +03:00
# ifdef USE_READLINE
2007-12-04 21:27:52 +03:00
2005-12-08 13:23:34 +03:00
/* -----------------
* Readline stuff
* - - - - - - - - - - - - - - - - -
*/
2007-02-07 16:50:18 +03:00
/*
2005-12-08 13:23:34 +03:00
* Generator function for command completion . STATE lets us
* know whether to start from scratch ; without any state
2007-02-07 16:50:18 +03:00
* ( i . e . STATE = = 0 ) , then we start at the top of the list .
2005-12-08 13:23:34 +03:00
*/
static char *
2006-03-15 15:13:25 +03:00
vshReadlineCommandGenerator ( const char * text , int state )
{
2005-12-08 13:23:34 +03:00
static int list_index , len ;
2005-12-08 17:22:52 +03:00
const char * name ;
2005-12-08 13:23:34 +03:00
/* If this is a new word to complete, initialize now. This
* includes saving the length of TEXT for efficiency , and
2007-02-07 16:50:18 +03:00
* initializing the index variable to 0.
2005-12-08 13:23:34 +03:00
*/
if ( ! state ) {
list_index = 0 ;
2006-03-15 15:13:25 +03:00
len = strlen ( text ) ;
2005-12-08 13:23:34 +03:00
}
/* Return the next name which partially matches from the
2007-02-07 16:50:18 +03:00
* command list .
2005-12-08 13:23:34 +03:00
*/
2005-12-08 17:22:52 +03:00
while ( ( name = commands [ list_index ] . name ) ) {
2005-12-08 13:23:34 +03:00
list_index + + ;
2008-05-14 23:51:24 +04:00
if ( STREQLEN ( name , text , len ) )
2006-04-06 14:33:06 +04:00
return vshStrdup ( NULL , name ) ;
2005-12-08 13:23:34 +03:00
}
/* If no names matched, then return NULL. */
return NULL ;
}
static char *
2006-03-15 15:13:25 +03:00
vshReadlineOptionsGenerator ( const char * text , int state )
{
2005-12-08 13:23:34 +03:00
static int list_index , len ;
2008-08-01 16:19:56 +04:00
static const vshCmdDef * cmd = NULL ;
2005-12-08 17:22:52 +03:00
const char * name ;
2005-12-08 13:23:34 +03:00
if ( ! state ) {
/* determine command name */
char * p ;
char * cmdname ;
if ( ! ( p = strchr ( rl_line_buffer , ' ' ) ) )
return NULL ;
2006-04-06 14:33:06 +04:00
cmdname = vshCalloc ( NULL , ( p - rl_line_buffer ) + 1 , 1 ) ;
2006-03-15 15:13:25 +03:00
memcpy ( cmdname , rl_line_buffer , p - rl_line_buffer ) ;
2005-12-08 13:23:34 +03:00
cmd = vshCmddefSearch ( cmdname ) ;
list_index = 0 ;
2006-03-15 15:13:25 +03:00
len = strlen ( text ) ;
2005-12-08 13:23:34 +03:00
free ( cmdname ) ;
}
if ( ! cmd )
return NULL ;
2006-03-15 15:13:25 +03:00
2007-02-27 18:35:50 +03:00
if ( ! cmd - > opts )
return NULL ;
2005-12-08 17:22:52 +03:00
while ( ( name = cmd - > opts [ list_index ] . name ) ) {
2008-08-01 16:19:56 +04:00
const vshCmdOptDef * opt = & cmd - > opts [ list_index ] ;
2005-12-08 13:23:34 +03:00
char * res ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
list_index + + ;
2006-03-15 15:13:25 +03:00
2005-12-08 17:22:52 +03:00
if ( opt - > type = = VSH_OT_DATA )
2005-12-08 13:23:34 +03:00
/* ignore non --option */
continue ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( len > 2 ) {
2008-05-14 23:51:24 +04:00
if ( STRNEQLEN ( name , text + 2 , len - 2 ) )
2005-12-08 13:23:34 +03:00
continue ;
}
2006-04-06 14:33:06 +04:00
res = vshMalloc ( NULL , strlen ( name ) + 3 ) ;
2007-03-23 19:15:07 +03:00
snprintf ( res , strlen ( name ) + 3 , " --%s " , name ) ;
2005-12-08 13:23:34 +03:00
return res ;
}
/* If no names matched, then return NULL. */
return NULL ;
}
static char * *
2006-03-15 15:13:25 +03:00
vshReadlineCompletion ( const char * text , int start ,
int end ATTRIBUTE_UNUSED )
{
2005-12-08 13:23:34 +03:00
char * * matches = ( char * * ) NULL ;
2006-03-15 15:13:25 +03:00
if ( start = = 0 )
2005-12-08 13:23:34 +03:00
/* command name generator */
2006-03-15 15:13:25 +03:00
matches = rl_completion_matches ( text , vshReadlineCommandGenerator ) ;
2005-12-08 13:23:34 +03:00
else
/* commands options */
2006-03-15 15:13:25 +03:00
matches = rl_completion_matches ( text , vshReadlineOptionsGenerator ) ;
2005-12-08 13:23:34 +03:00
return matches ;
}
static void
2006-03-15 15:13:25 +03:00
vshReadlineInit ( void )
{
2005-12-08 13:23:34 +03:00
/* Allow conditional parsing of the ~/.inputrc file. */
rl_readline_name = " virsh " ;
/* Tell the completer that we want a crack first. */
rl_attempted_completion_function = vshReadlineCompletion ;
2009-02-09 13:24:27 +03:00
/* Limit the total size of the history buffer */
stifle_history ( 500 ) ;
2005-12-08 13:23:34 +03:00
}
2007-12-04 21:27:52 +03:00
static char *
vshReadline ( vshControl * ctl ATTRIBUTE_UNUSED , const char * prompt )
{
return readline ( prompt ) ;
}
2007-12-06 13:24:52 +03:00
# else /* !USE_READLINE */
2007-12-04 21:27:52 +03:00
static void
vshReadlineInit ( void )
{
/* empty */
}
static char *
vshReadline ( vshControl * ctl , const char * prompt )
{
char line [ 1024 ] ;
char * r ;
int len ;
fputs ( prompt , stdout ) ;
r = fgets ( line , sizeof line , stdin ) ;
if ( r = = NULL ) return NULL ; /* EOF */
/* Chomp trailing \n */
len = strlen ( r ) ;
if ( len > 0 & & r [ len - 1 ] = = ' \n ' )
r [ len - 1 ] = ' \0 ' ;
return vshStrdup ( ctl , r ) ;
}
2007-12-06 13:24:52 +03:00
# endif /* !USE_READLINE */
2007-12-04 21:27:52 +03:00
2005-12-08 13:23:34 +03:00
/*
2008-02-04 17:58:47 +03:00
* Deinitialize virsh
2005-12-08 13:23:34 +03:00
*/
static int
2008-08-01 17:51:18 +04:00
vshDeinit ( vshControl * ctl )
2006-03-15 15:13:25 +03:00
{
2007-06-06 16:24:31 +04:00
vshCloseLogFile ( ctl ) ;
2008-01-29 20:41:07 +03:00
free ( ctl - > name ) ;
2005-12-08 13:23:34 +03:00
if ( ctl - > conn ) {
2006-03-15 15:13:25 +03:00
if ( virConnectClose ( ctl - > conn ) ! = 0 ) {
ctl - > conn = NULL ; /* prevent recursive call from vshError() */
2008-02-04 17:58:47 +03:00
vshError ( ctl , TRUE , " %s " ,
_ ( " failed to disconnect from the hypervisor " ) ) ;
2005-12-08 13:23:34 +03:00
}
}
2007-12-01 18:45:25 +03:00
virResetLastError ( ) ;
2005-12-08 13:23:34 +03:00
return TRUE ;
}
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
/*
* Print usage
*/
static void
2008-12-08 16:14:48 +03:00
vshUsage ( void )
2006-03-15 15:13:25 +03:00
{
2008-08-01 16:19:56 +04:00
const vshCmdDef * cmd ;
2008-12-08 16:14:48 +03:00
fprintf ( stdout , _ ( " \n %s [options] [commands] \n \n "
" options: \n "
" -c | --connect <uri> hypervisor connection URI \n "
" -r | --readonly connect readonly \n "
" -d | --debug <num> debug level [0-5] \n "
" -h | --help this help \n "
" -q | --quiet quiet mode \n "
" -t | --timing print timing information \n "
" -l | --log <file> output logging to file \n "
" -v | --version program version \n \n "
" commands (non interactive mode): \n " ) , progname ) ;
for ( cmd = commands ; cmd - > name ; cmd + + )
fprintf ( stdout ,
" %-15s %s \n " , cmd - > name , N_ ( vshCmddefGetInfo ( cmd ,
" help " ) ) ) ;
fprintf ( stdout , " %s " ,
_ ( " \n (specify help <command> for details about the command) \n \n " ) ) ;
return ;
2005-12-08 13:23:34 +03:00
}
/*
* argv [ ] : virsh [ options ] [ command ]
*
*/
static int
2008-08-01 17:51:18 +04:00
vshParseArgv ( vshControl * ctl , int argc , char * * argv )
2006-03-15 15:13:25 +03:00
{
2005-12-08 13:23:34 +03:00
char * last = NULL ;
int i , end = 0 , help = 0 ;
2006-03-15 15:13:25 +03:00
int arg , idx = 0 ;
2005-12-08 13:23:34 +03:00
struct option opt [ ] = {
2006-03-15 15:13:25 +03:00
{ " debug " , 1 , 0 , ' d ' } ,
{ " help " , 0 , 0 , ' h ' } ,
{ " quiet " , 0 , 0 , ' q ' } ,
{ " timing " , 0 , 0 , ' t ' } ,
{ " version " , 0 , 0 , ' v ' } ,
2006-05-29 19:39:31 +04:00
{ " connect " , 1 , 0 , ' c ' } ,
2007-03-08 16:48:22 +03:00
{ " readonly " , 0 , 0 , ' r ' } ,
2007-06-06 16:24:31 +04:00
{ " log " , 1 , 0 , ' l ' } ,
2005-12-08 13:23:34 +03:00
{ 0 , 0 , 0 , 0 }
2006-03-15 15:13:25 +03:00
} ;
2005-12-08 13:23:34 +03:00
if ( argc < 2 )
2005-12-08 17:22:52 +03:00
return TRUE ;
2006-03-15 15:13:25 +03:00
2006-01-25 12:46:22 +03:00
/* look for begin of the command, for example:
2005-12-08 13:23:34 +03:00
* . / virsh - - debug 5 - q command - - cmdoption
* < - - - ^ - - - >
* getopt ( ) stuff | command suff
*/
2006-03-15 15:13:25 +03:00
for ( i = 1 ; i < argc ; i + + ) {
2005-12-08 13:23:34 +03:00
if ( * argv [ i ] ! = ' - ' ) {
int valid = FALSE ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
/* non "--option" argv, is it command? */
if ( last ) {
struct option * o ;
int sz = strlen ( last ) ;
2006-03-15 15:13:25 +03:00
for ( o = opt ; o - > name ; o + + ) {
2007-02-27 18:32:18 +03:00
if ( o - > has_arg = = 1 ) {
if ( sz = = 2 & & * ( last + 1 ) = = o - > val )
/* valid virsh short option */
valid = TRUE ;
2008-05-14 23:51:24 +04:00
else if ( sz > 2 & & STREQ ( o - > name , last + 2 ) )
2007-02-27 18:32:18 +03:00
/* valid virsh long option */
valid = TRUE ;
}
2005-12-08 13:23:34 +03:00
}
}
if ( ! valid ) {
end = i ;
break ;
}
}
last = argv [ i ] ;
}
2007-09-29 22:16:26 +04:00
end = end ? end : argc ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
/* standard (non-command) options */
2007-06-06 16:24:31 +04:00
while ( ( arg = getopt_long ( end , argv , " d:hqtc:vrl: " , opt , & idx ) ) ! = - 1 ) {
2006-03-15 15:13:25 +03:00
switch ( arg ) {
2007-02-07 16:50:18 +03:00
case ' d ' :
ctl - > debug = atoi ( optarg ) ;
break ;
case ' h ' :
help = 1 ;
break ;
case ' q ' :
ctl - > quiet = TRUE ;
break ;
case ' t ' :
ctl - > timing = TRUE ;
break ;
case ' c ' :
ctl - > name = vshStrdup ( ctl , optarg ) ;
break ;
case ' v ' :
fprintf ( stdout , " %s \n " , VERSION ) ;
exit ( EXIT_SUCCESS ) ;
2007-03-08 16:48:22 +03:00
case ' r ' :
ctl - > readonly = TRUE ;
break ;
2007-06-06 16:24:31 +04:00
case ' l ' :
ctl - > logfile = vshStrdup ( ctl , optarg ) ;
break ;
2007-02-07 16:50:18 +03:00
default :
vshError ( ctl , TRUE ,
_ ( " unsupported option '-%c'. See --help. " ) , arg ) ;
break ;
2005-12-08 13:23:34 +03:00
}
}
if ( help ) {
2008-12-08 16:14:48 +03:00
if ( end < argc )
vshError ( ctl , TRUE ,
_ ( " extra argument '%s'. See --help. " ) , argv [ end ] ) ;
/* list all command */
vshUsage ( ) ;
2005-12-08 13:23:34 +03:00
exit ( EXIT_SUCCESS ) ;
2006-03-15 15:13:25 +03:00
}
2005-12-08 13:23:34 +03:00
if ( argc > end ) {
/* parse command */
char * cmdstr ;
2006-03-15 15:13:25 +03:00
int sz = 0 , ret ;
2005-12-08 13:23:34 +03:00
ctl - > imode = FALSE ;
2006-03-15 15:13:25 +03:00
for ( i = end ; i < argc ; i + + )
sz + = strlen ( argv [ i ] ) + 1 ; /* +1 is for blank space between items */
2006-04-06 14:33:06 +04:00
cmdstr = vshCalloc ( ctl , sz + 1 , 1 ) ;
2006-03-15 15:13:25 +03:00
for ( i = end ; i < argc ; i + + ) {
2005-12-08 13:23:34 +03:00
strncat ( cmdstr , argv [ i ] , sz ) ;
sz - = strlen ( argv [ i ] ) ;
strncat ( cmdstr , " " , sz - - ) ;
}
2006-05-22 18:38:33 +04:00
vshDebug ( ctl , 2 , " command: \" %s \" \n " , cmdstr ) ;
2005-12-08 13:23:34 +03:00
ret = vshCommandParse ( ctl , cmdstr ) ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
free ( cmdstr ) ;
return ret ;
}
return TRUE ;
}
2006-03-15 15:13:25 +03:00
int
main ( int argc , char * * argv )
{
vshControl _ctl , * ctl = & _ctl ;
2006-08-26 02:40:33 +04:00
char * defaultConn ;
2005-12-08 13:23:34 +03:00
int ret = TRUE ;
2006-09-21 19:24:37 +04:00
if ( ! setlocale ( LC_ALL , " " ) ) {
perror ( " setlocale " ) ;
2009-01-29 14:49:33 +03:00
/* failure to setup locale is not fatal */
2006-09-21 19:24:37 +04:00
}
if ( ! bindtextdomain ( GETTEXT_PACKAGE , LOCALEBASEDIR ) ) {
perror ( " bindtextdomain " ) ;
2007-02-07 16:50:18 +03:00
return - 1 ;
2006-09-21 19:24:37 +04:00
}
if ( ! textdomain ( GETTEXT_PACKAGE ) ) {
perror ( " textdomain " ) ;
2007-02-07 16:50:18 +03:00
return - 1 ;
2006-09-21 19:24:37 +04:00
}
2006-03-15 15:13:25 +03:00
if ( ! ( progname = strrchr ( argv [ 0 ] , ' / ' ) ) )
2005-12-08 13:23:34 +03:00
progname = argv [ 0 ] ;
else
progname + + ;
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
memset ( ctl , 0 , sizeof ( vshControl ) ) ;
2006-03-15 15:13:25 +03:00
ctl - > imode = TRUE ; /* default is interactive mode */
2007-06-06 16:24:31 +04:00
ctl - > log_fd = - 1 ; /* Initialize log file descriptor */
2005-12-08 13:23:34 +03:00
2006-08-26 02:40:33 +04:00
if ( ( defaultConn = getenv ( " VIRSH_DEFAULT_CONNECT_URI " ) ) ) {
2007-02-07 16:50:18 +03:00
ctl - > name = strdup ( defaultConn ) ;
2006-08-26 02:40:33 +04:00
}
2007-12-01 18:45:25 +03:00
if ( ! vshParseArgv ( ctl , argc , argv ) ) {
vshDeinit ( ctl ) ;
2005-12-08 13:23:34 +03:00
exit ( EXIT_FAILURE ) ;
2007-12-01 18:45:25 +03:00
}
2006-03-15 15:13:25 +03:00
2007-12-01 18:45:25 +03:00
if ( ! vshInit ( ctl ) ) {
vshDeinit ( ctl ) ;
2005-12-08 13:23:34 +03:00
exit ( EXIT_FAILURE ) ;
2007-12-01 18:45:25 +03:00
}
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
if ( ! ctl - > imode ) {
2006-03-15 15:13:25 +03:00
ret = vshCommandRun ( ctl , ctl - > cmd ) ;
2005-12-01 19:35:42 +03:00
} else {
2005-12-08 13:23:34 +03:00
/* interactive mode */
if ( ! ctl - > quiet ) {
2006-05-22 18:38:33 +04:00
vshPrint ( ctl ,
2006-09-21 19:24:37 +04:00
_ ( " Welcome to %s, the virtualization interactive terminal. \n \n " ) ,
2006-03-15 15:13:25 +03:00
progname ) ;
2008-01-16 20:13:23 +03:00
vshPrint ( ctl , " %s " ,
2006-09-21 19:24:37 +04:00
_ ( " Type: 'help' for help with commands \n "
2007-02-07 16:50:18 +03:00
" 'quit' to quit \n \n " ) ) ;
2005-12-08 13:23:34 +03:00
}
2005-12-08 17:22:52 +03:00
vshReadlineInit ( ) ;
2005-12-08 13:23:34 +03:00
do {
2007-12-06 19:36:21 +03:00
const char * prompt = ctl - > readonly ? VSH_PROMPT_RO : VSH_PROMPT_RW ;
2006-03-15 15:13:25 +03:00
ctl - > cmdstr =
2007-12-06 19:36:21 +03:00
vshReadline ( ctl , prompt ) ;
2006-03-15 15:13:25 +03:00
if ( ctl - > cmdstr = = NULL )
break ; /* EOF */
2005-12-08 13:23:34 +03:00
if ( * ctl - > cmdstr ) {
2007-12-06 13:24:52 +03:00
# if USE_READLINE
2005-12-08 13:23:34 +03:00
add_history ( ctl - > cmdstr ) ;
2007-12-04 21:27:52 +03:00
# endif
2005-12-08 13:23:34 +03:00
if ( vshCommandParse ( ctl , ctl - > cmdstr ) )
vshCommandRun ( ctl , ctl - > cmd ) ;
}
free ( ctl - > cmdstr ) ;
ctl - > cmdstr = NULL ;
2006-03-15 15:13:25 +03:00
} while ( ctl - > imode ) ;
2005-12-08 13:23:34 +03:00
2006-03-15 15:13:25 +03:00
if ( ctl - > cmdstr = = NULL )
fputc ( ' \n ' , stdout ) ; /* line break after alone prompt */
2005-12-08 13:23:34 +03:00
}
2006-03-15 15:13:25 +03:00
2005-12-08 13:23:34 +03:00
vshDeinit ( ctl ) ;
exit ( ret ? EXIT_SUCCESS : EXIT_FAILURE ) ;
2005-11-10 19:12:31 +03:00
}