
DEFHEADING(Standard options:)

DEF("help", 0, QEMU_OPTION_h,
"-h or -help     display this help and exit\n", QEMU_ARCH_ALL)

DEF("version", 0, QEMU_OPTION_version,
"-version        display version information and exit\n", QEMU_ARCH_ALL)

DEF("machine", HAS_ARG, QEMU_OPTION_machine, \
"-machine [type=]name[,prop[=value][,...]]\n"
"                selects emulated machine ('-machine help' for list)\n"
"                property accel=accel1[:accel2[:...]] selects accelerator\n"
"                supported accelerators are kvm, xen, hax, hvf, whpx or tcg (default: tcg)\n"
"                kernel_irqchip=on|off|split controls accelerated irqchip support (default=off)\n"
"                vmport=on|off|auto controls emulation of vmport (default: auto)\n"
"                kvm_shadow_mem=size of KVM shadow MMU in bytes\n"
"                dump-guest-core=on|off include guest memory in a core dump (default=on)\n"
"                mem-merge=on|off controls memory merge support (default: on)\n"
"                igd-passthru=on|off controls IGD GFX passthrough support (default=off)\n"
"                aes-key-wrap=on|off controls support for AES key wrapping (default=on)\n"
"                dea-key-wrap=on|off controls support for DEA key wrapping (default=on)\n"
"                suppress-vmdesc=on|off disables self-describing migration (default=off)\n"
"                nvdimm=on|off controls NVDIMM support (default=off)\n"
"                enforce-config-section=on|off enforce configuration section migration (default=off)\n"
"                memory-encryption=@var{} memory encryption object to use (default=none)\n",
QEMU_ARCH_ALL)

DEF("M", HAS_ARG, QEMU_OPTION_M, "", QEMU_ARCH_ALL)

DEF("cpu", HAS_ARG, QEMU_OPTION_cpu,
"-cpu cpu        select CPU ('-cpu help' for list)\n", QEMU_ARCH_ALL)

DEF("accel", HAS_ARG, QEMU_OPTION_accel,
"-accel [accel=]accelerator[,thread=single|multi]\n"
"                select accelerator (kvm, xen, hax, hvf, whpx or tcg; use 'help' for a list)\n"
"                thread=single|multi (enable multi-threaded TCG)\n", QEMU_ARCH_ALL)

DEF("smp", HAS_ARG, QEMU_OPTION_smp,
"-smp [cpus=]n[,maxcpus=cpus][,cores=cores][,threads=threads][,dies=dies][,sockets=sockets]\n"
"                set the number of CPUs to 'n' [default=1]\n"
"                maxcpus= maximum number of total cpus, including\n"
"                offline CPUs for hotplug, etc\n"
"                cores= number of CPU cores on one socket (for PC, it's on one die)\n"
"                threads= number of threads on one CPU core\n"
"                dies= number of CPU dies on one socket (for PC only)\n"
"                sockets= number of discrete sockets in the system\n",
QEMU_ARCH_ALL)

DEF("numa", HAS_ARG, QEMU_OPTION_numa,
"-numa node[,mem=size][,cpus=firstcpu[-lastcpu]][,nodeid=node]\n"
"-numa node[,memdev=id][,cpus=firstcpu[-lastcpu]][,nodeid=node]\n"
"-numa dist,src=source,dst=destination,val=distance\n"
"-numa cpu,node-id=node[,socket-id=x][,core-id=y][,thread-id=z]\n",
QEMU_ARCH_ALL)

DEF("add-fd", HAS_ARG, QEMU_OPTION_add_fd,
"-add-fd fd=fd,set=set[,opaque=opaque]\n"
"                Add 'fd' to fd 'set'\n", QEMU_ARCH_ALL)

DEF("set", HAS_ARG, QEMU_OPTION_set,
"-set group.id.arg=value\n"
"                set <arg> parameter for item <id> of type <group>\n"
"                i.e. -set drive.$id.file=/path/to/image\n", QEMU_ARCH_ALL)

DEF("global", HAS_ARG, QEMU_OPTION_global,
"-global driver.property=value\n"
"-global driver=driver,property=property,value=value\n"
"                set a global default for a driver property\n",
QEMU_ARCH_ALL)

DEF("boot", HAS_ARG, QEMU_OPTION_boot,
"-boot [order=drives][,once=drives][,menu=on|off]\n"
"      [,splash=sp_name][,splash-time=sp_time][,reboot-timeout=rb_time][,strict=on|off]\n"
"                'drives': floppy (a), hard disk (c), CD-ROM (d), network (n)\n"
"                'sp_name': the file's name that would be passed to bios as logo picture, if menu=on\n"
"                'sp_time': the period that splash picture last if menu=on, unit is ms\n"
"                'rb_timeout': the timeout before guest reboot when boot failed, unit is ms\n",
QEMU_ARCH_ALL)

DEF("m", HAS_ARG, QEMU_OPTION_m,
"-m [size=]megs[,slots=n,maxmem=size]\n"
"                configure guest RAM\n"
"                size: initial amount of guest memory\n"
"                slots: number of hotplug slots (default: none)\n"
"                maxmem: maximum amount of guest memory (default: none)\n"
"NOTE: Some architectures might enforce a specific granularity\n",
QEMU_ARCH_ALL)

DEF("mem-path", HAS_ARG, QEMU_OPTION_mempath,
"-mem-path FILE  provide backing storage for guest RAM\n", QEMU_ARCH_ALL)

DEF("mem-prealloc", 0, QEMU_OPTION_mem_prealloc,
"-mem-prealloc   preallocate guest memory (use with -mem-path)\n",
QEMU_ARCH_ALL)

DEF("k", HAS_ARG, QEMU_OPTION_k,
"-k language     use keyboard layout (for example 'fr' for French)\n",
QEMU_ARCH_ALL)


DEF("audio-help", 0, QEMU_OPTION_audio_help,
"-audio-help     show -audiodev equivalent of the currently specified audio settings\n",
QEMU_ARCH_ALL)

DEF("audiodev", HAS_ARG, QEMU_OPTION_audiodev,
"-audiodev [driver=]driver,id=id[,prop[=value][,...]]\n"
"                specifies the audio backend to use\n"
"                id= identifier of the backend\n"
"                timer-period= timer period in microseconds\n"
"                in|out.mixing-engine= use mixing engine to mix streams inside QEMU\n"
"                in|out.fixed-settings= use fixed settings for host audio\n"
"                in|out.frequency= frequency to use with fixed settings\n"
"                in|out.channels= number of channels to use with fixed settings\n"
"                in|out.format= sample format to use with fixed settings\n"
"                valid values: s8, s16, s32, u8, u16, u32\n"
"                in|out.voices= number of voices to use\n"
"                in|out.buffer-length= length of buffer in microseconds\n"
"-audiodev none,id=id,[,prop[=value][,...]]\n"
"                dummy driver that discards all output\n"
#ifdef CONFIG_AUDIO_ALSA
"-audiodev alsa,id=id[,prop[=value][,...]]\n"
"                in|out.dev= name of the audio device to use\n"
"                in|out.period-length= length of period in microseconds\n"
"                in|out.try-poll= attempt to use poll mode\n"
"                threshold= threshold (in microseconds) when playback starts\n"
#endif
#ifdef CONFIG_AUDIO_COREAUDIO
"-audiodev coreaudio,id=id[,prop[=value][,...]]\n"
"                in|out.buffer-count= number of buffers\n"
#endif
#ifdef CONFIG_AUDIO_DSOUND
"-audiodev dsound,id=id[,prop[=value][,...]]\n"
"                latency= add extra latency to playback in microseconds\n"
#endif
#ifdef CONFIG_AUDIO_OSS
"-audiodev oss,id=id[,prop[=value][,...]]\n"
"                in|out.dev= path of the audio device to use\n"
"                in|out.buffer-count= number of buffers\n"
"                in|out.try-poll= attempt to use poll mode\n"
"                try-mmap= try using memory mapped access\n"
"                exclusive= open device in exclusive mode\n"
"                dsp-policy= set timing policy (0..10), -1 to use fragment mode\n"
#endif
#ifdef CONFIG_AUDIO_PA
"-audiodev pa,id=id[,prop[=value][,...]]\n"
"                server= PulseAudio server address\n"
"                in|out.name= source/sink device name\n"
"                in|out.latency= desired latency in microseconds\n"
#endif
#ifdef CONFIG_AUDIO_SDL
"-audiodev sdl,id=id[,prop[=value][,...]]\n"
#endif
#ifdef CONFIG_SPICE
"-audiodev spice,id=id[,prop[=value][,...]]\n"
#endif
"-audiodev wav,id=id[,prop[=value][,...]]\n"
"                path= path of wav file to record\n",
QEMU_ARCH_ALL)

DEF("soundhw", HAS_ARG, QEMU_OPTION_soundhw,
"-soundhw c1,... enable audio support\n"
"                and only specified sound cards (comma separated list)\n"
"                use '-soundhw help' to get the list of supported cards\n"
"                use '-soundhw all' to enable all of them\n", QEMU_ARCH_ALL)

DEF("device", HAS_ARG, QEMU_OPTION_device,
"-device driver[,prop[=value][,...]]\n"
"                add device (based on driver)\n"
"                prop=value,... sets driver properties\n"
"                use '-device help' to print all possible drivers\n"
"                use '-device driver,help' to print all possible properties\n",
QEMU_ARCH_ALL)

DEF("name", HAS_ARG, QEMU_OPTION_name,
"-name string1[,process=string2][,debug-threads=on|off]\n"
"                set the name of the guest\n"
"                string1 sets the window title and string2 the process name\n"
"                When debug-threads is enabled, individual threads are given a separate name\n"
"                NOTE: The thread names are for debugging and not a stable API.\n",
QEMU_ARCH_ALL)

DEF("uuid", HAS_ARG, QEMU_OPTION_uuid,
"-uuid %08x-%04x-%04x-%04x-%012x\n"
"                specify machine UUID\n", QEMU_ARCH_ALL)

DEFHEADING()

DEFHEADING(Block device options:)

DEF("fda", HAS_ARG, QEMU_OPTION_fda,
"-fda/-fdb file  use 'file' as floppy disk 0/1 image\n", QEMU_ARCH_ALL)
DEF("fdb", HAS_ARG, QEMU_OPTION_fdb, "", QEMU_ARCH_ALL)

DEF("hda", HAS_ARG, QEMU_OPTION_hda,
"-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n", QEMU_ARCH_ALL)
DEF("hdb", HAS_ARG, QEMU_OPTION_hdb, "", QEMU_ARCH_ALL)
DEF("hdc", HAS_ARG, QEMU_OPTION_hdc,
"-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n", QEMU_ARCH_ALL)
DEF("hdd", HAS_ARG, QEMU_OPTION_hdd, "", QEMU_ARCH_ALL)

DEF("cdrom", HAS_ARG, QEMU_OPTION_cdrom,
"-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n",
QEMU_ARCH_ALL)

DEF("blockdev", HAS_ARG, QEMU_OPTION_blockdev,
"-blockdev [driver=]driver[,node-name=N][,discard=ignore|unmap]\n"
"          [,cache.direct=on|off][,cache.no-flush=on|off]\n"
"          [,read-only=on|off][,auto-read-only=on|off]\n"
"          [,force-share=on|off][,detect-zeroes=on|off|unmap]\n"
"          [,driver specific parameters...]\n"
"                configure a block backend\n", QEMU_ARCH_ALL)

DEF("drive", HAS_ARG, QEMU_OPTION_drive,
"-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
"       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
"       [,snapshot=on|off][,rerror=ignore|stop|report]\n"
"       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
"       [,readonly=on|off][,copy-on-read=on|off]\n"
"       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
"       [[,bps=b]|[[,bps_rd=r][,bps_wr=w]]]\n"
"       [[,iops=i]|[[,iops_rd=r][,iops_wr=w]]]\n"
"       [[,bps_max=bm]|[[,bps_rd_max=rm][,bps_wr_max=wm]]]\n"
"       [[,iops_max=im]|[[,iops_rd_max=irm][,iops_wr_max=iwm]]]\n"
"       [[,iops_size=is]]\n"
"       [[,group=g]]\n"
"                use 'file' as a drive image\n", QEMU_ARCH_ALL)

DEF("mtdblock", HAS_ARG, QEMU_OPTION_mtdblock,
"-mtdblock file  use 'file' as on-board Flash memory image\n",
QEMU_ARCH_ALL)

DEF("sd", HAS_ARG, QEMU_OPTION_sd,
"-sd file        use 'file' as SecureDigital card image\n", QEMU_ARCH_ALL)

DEF("pflash", HAS_ARG, QEMU_OPTION_pflash,
"-pflash file    use 'file' as a parallel flash image\n", QEMU_ARCH_ALL)

DEF("snapshot", 0, QEMU_OPTION_snapshot,
"-snapshot       write to temporary files instead of disk image files\n",
QEMU_ARCH_ALL)

DEF("fsdev", HAS_ARG, QEMU_OPTION_fsdev,
"-fsdev local,id=id,path=path,security_model=mapped-xattr|mapped-file|passthrough|none\n"
" [,writeout=immediate][,readonly][,fmode=fmode][,dmode=dmode]\n"
" [[,throttling.bps-total=b]|[[,throttling.bps-read=r][,throttling.bps-write=w]]]\n"
" [[,throttling.iops-total=i]|[[,throttling.iops-read=r][,throttling.iops-write=w]]]\n"
" [[,throttling.bps-total-max=bm]|[[,throttling.bps-read-max=rm][,throttling.bps-write-max=wm]]]\n"
" [[,throttling.iops-total-max=im]|[[,throttling.iops-read-max=irm][,throttling.iops-write-max=iwm]]]\n"
" [[,throttling.iops-size=is]]\n"
"-fsdev proxy,id=id,socket=socket[,writeout=immediate][,readonly]\n"
"-fsdev proxy,id=id,sock_fd=sock_fd[,writeout=immediate][,readonly]\n"
"-fsdev synth,id=id\n",
QEMU_ARCH_ALL)


DEF("virtfs", HAS_ARG, QEMU_OPTION_virtfs,
"-virtfs local,path=path,mount_tag=tag,security_model=mapped-xattr|mapped-file|passthrough|none\n"
"        [,id=id][,writeout=immediate][,readonly][,fmode=fmode][,dmode=dmode][,multidevs=remap|forbid|warn]\n"
"-virtfs proxy,mount_tag=tag,socket=socket[,id=id][,writeout=immediate][,readonly]\n"
"-virtfs proxy,mount_tag=tag,sock_fd=sock_fd[,id=id][,writeout=immediate][,readonly]\n"
"-virtfs synth,mount_tag=tag[,id=id][,readonly]\n",
QEMU_ARCH_ALL)


DEF("virtfs_synth", 0, QEMU_OPTION_virtfs_synth,
"-virtfs_synth Create synthetic file system image\n",
QEMU_ARCH_ALL)

DEF("iscsi", HAS_ARG, QEMU_OPTION_iscsi,
"-iscsi [user=user][,password=password]\n"
"       [,header-digest=CRC32C|CR32C-NONE|NONE-CRC32C|NONE\n"
"       [,initiator-name=initiator-iqn][,id=target-iqn]\n"
"       [,timeout=timeout]\n"
"                iSCSI session parameters\n", QEMU_ARCH_ALL)


DEFHEADING()

DEFHEADING(USB options:)

DEF("usb", 0, QEMU_OPTION_usb,
"-usb            enable on-board USB host controller (if not enabled by default)\n",
QEMU_ARCH_ALL)

DEF("usbdevice", HAS_ARG, QEMU_OPTION_usbdevice,
"-usbdevice name add the host or guest USB device 'name'\n",
QEMU_ARCH_ALL)

DEFHEADING()

DEFHEADING(Display options:)

DEF("display", HAS_ARG, QEMU_OPTION_display,
#if defined(CONFIG_SPICE)
"-display spice-app[,gl=on|off]\n"
#endif
#if defined(CONFIG_SDL)
"-display sdl[,alt_grab=on|off][,ctrl_grab=on|off]\n"
"            [,window_close=on|off][,gl=on|core|es|off]\n"
#endif
#if defined(CONFIG_GTK)
"-display gtk[,grab_on_hover=on|off][,gl=on|off]|\n"
#endif
#if defined(CONFIG_VNC)
"-display vnc=<display>[,<optargs>]\n"
#endif
#if defined(CONFIG_CURSES)
"-display curses[,charset=<encoding>]\n"
#endif
#if defined(CONFIG_OPENGL)
"-display egl-headless[,rendernode=<file>]\n"
#endif
"-display none\n"
"                select display backend type\n"
"                The default display is equivalent to\n                "
#if defined(CONFIG_GTK)
"\"-display gtk\"\n"
#elif defined(CONFIG_SDL)
"\"-display sdl\"\n"
#elif defined(CONFIG_COCOA)
"\"-display cocoa\"\n"
#elif defined(CONFIG_VNC)
"\"-vnc localhost:0,to=99,id=default\"\n"
#else
"\"-display none\"\n"
#endif
, QEMU_ARCH_ALL)

DEF("nographic", 0, QEMU_OPTION_nographic,
"-nographic      disable graphical output and redirect serial I/Os to console\n",
QEMU_ARCH_ALL)

DEF("curses", 0, QEMU_OPTION_curses,
"-curses         shorthand for -display curses\n",
QEMU_ARCH_ALL)

DEF("alt-grab", 0, QEMU_OPTION_alt_grab,
"-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n",
QEMU_ARCH_ALL)

DEF("ctrl-grab", 0, QEMU_OPTION_ctrl_grab,
"-ctrl-grab      use Right-Ctrl to grab mouse (instead of Ctrl-Alt)\n",
QEMU_ARCH_ALL)

DEF("no-quit", 0, QEMU_OPTION_no_quit,
"-no-quit        disable SDL window close capability\n", QEMU_ARCH_ALL)

DEF("sdl", 0, QEMU_OPTION_sdl,
"-sdl            shorthand for -display sdl\n", QEMU_ARCH_ALL)

DEF("spice", HAS_ARG, QEMU_OPTION_spice,
"-spice [port=port][,tls-port=secured-port][,x509-dir=<dir>]\n"
"       [,x509-key-file=<file>][,x509-key-password=<file>]\n"
"       [,x509-cert-file=<file>][,x509-cacert-file=<file>]\n"
"       [,x509-dh-key-file=<file>][,addr=addr][,ipv4|ipv6|unix]\n"
"       [,tls-ciphers=<list>]\n"
"       [,tls-channel=[main|display|cursor|inputs|record|playback]]\n"
"       [,plaintext-channel=[main|display|cursor|inputs|record|playback]]\n"
"       [,sasl][,password=<secret>][,disable-ticketing]\n"
"       [,image-compression=[auto_glz|auto_lz|quic|glz|lz|off]]\n"
"       [,jpeg-wan-compression=[auto|never|always]]\n"
"       [,zlib-glz-wan-compression=[auto|never|always]]\n"
"       [,streaming-video=[off|all|filter]][,disable-copy-paste]\n"
"       [,disable-agent-file-xfer][,agent-mouse=[on|off]]\n"
"       [,playback-compression=[on|off]][,seamless-migration=[on|off]]\n"
"       [,gl=[on|off]][,rendernode=<file>]\n"
"   enable spice\n"
"   at least one of {port, tls-port} is mandatory\n",
QEMU_ARCH_ALL)

DEF("portrait", 0, QEMU_OPTION_portrait,
"-portrait       rotate graphical output 90 deg left (only PXA LCD)\n",
QEMU_ARCH_ALL)

DEF("rotate", HAS_ARG, QEMU_OPTION_rotate,
"-rotate <deg>   rotate graphical output some deg left (only PXA LCD)\n",
QEMU_ARCH_ALL)

DEF("vga", HAS_ARG, QEMU_OPTION_vga,
"-vga [std|cirrus|vmware|qxl|xenfb|tcx|cg3|virtio|none]\n"
"                select video card type\n", QEMU_ARCH_ALL)

DEF("full-screen", 0, QEMU_OPTION_full_screen,
"-full-screen    start in full screen\n", QEMU_ARCH_ALL)

DEF("g", 1, QEMU_OPTION_g ,
"-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n",
QEMU_ARCH_PPC | QEMU_ARCH_SPARC | QEMU_ARCH_M68K)

DEF("vnc", HAS_ARG, QEMU_OPTION_vnc ,
"-vnc <display>  shorthand for -display vnc=<display>\n", QEMU_ARCH_ALL)

ARCHHEADING(, QEMU_ARCH_I386)

ARCHHEADING(i386 target only:, QEMU_ARCH_I386)

DEF("win2k-hack", 0, QEMU_OPTION_win2k_hack,
"-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n",
QEMU_ARCH_I386)

DEF("no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk,
"-no-fd-bootchk  disable boot signature checking for floppy disks\n",
QEMU_ARCH_I386)

DEF("no-acpi", 0, QEMU_OPTION_no_acpi,
"-no-acpi        disable ACPI\n", QEMU_ARCH_I386 | QEMU_ARCH_ARM)

DEF("no-hpet", 0, QEMU_OPTION_no_hpet,
"-no-hpet        disable HPET\n", QEMU_ARCH_I386)

DEF("acpitable", HAS_ARG, QEMU_OPTION_acpitable,
"-acpitable [sig=str][,rev=n][,oem_id=str][,oem_table_id=str][,oem_rev=n][,asl_compiler_id=str][,asl_compiler_rev=n][,{data|file}=file1[:file2]...]\n"
"                ACPI table description\n", QEMU_ARCH_I386)

DEF("smbios", HAS_ARG, QEMU_OPTION_smbios,
"-smbios file=binary\n"
"                load SMBIOS entry from binary file\n"
"-smbios type=0[,vendor=str][,version=str][,date=str][,release=%d.%d]\n"
"              [,uefi=on|off]\n"
"                specify SMBIOS type 0 fields\n"
"-smbios type=1[,manufacturer=str][,product=str][,version=str][,serial=str]\n"
"              [,uuid=uuid][,sku=str][,family=str]\n"
"                specify SMBIOS type 1 fields\n"
"-smbios type=2[,manufacturer=str][,product=str][,version=str][,serial=str]\n"
"              [,asset=str][,location=str]\n"
"                specify SMBIOS type 2 fields\n"
"-smbios type=3[,manufacturer=str][,version=str][,serial=str][,asset=str]\n"
"              [,sku=str]\n"
"                specify SMBIOS type 3 fields\n"
"-smbios type=4[,sock_pfx=str][,manufacturer=str][,version=str][,serial=str]\n"
"              [,asset=str][,part=str]\n"
"                specify SMBIOS type 4 fields\n"
"-smbios type=17[,loc_pfx=str][,bank=str][,manufacturer=str][,serial=str]\n"
"               [,asset=str][,part=str][,speed=%d]\n"
"                specify SMBIOS type 17 fields\n",
QEMU_ARCH_I386 | QEMU_ARCH_ARM)

DEFHEADING()

DEFHEADING(Network options:)

DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
#ifdef CONFIG_SLIRP
"-netdev user,id=str[,ipv4[=on|off]][,net=addr[/mask]][,host=addr]\n"
"         [,ipv6[=on|off]][,ipv6-net=addr[/int]][,ipv6-host=addr]\n"
"         [,restrict=on|off][,hostname=host][,dhcpstart=addr]\n"
"         [,dns=addr][,ipv6-dns=addr][,dnssearch=domain][,domainname=domain]\n"
"         [,tftp=dir][,tftp-server-name=name][,bootfile=f][,hostfwd=rule][,guestfwd=rule]"
#ifndef _WIN32
"[,smb=dir[,smbserver=addr]]\n"
#endif
"                configure a user mode network backend with ID 'str',\n"
"                its DHCP server and optional services\n"
#endif
#ifdef _WIN32
"-netdev tap,id=str,ifname=name\n"
"                configure a host TAP network backend with ID 'str'\n"
#else
"-netdev tap,id=str[,fd=h][,fds=x:y:...:z][,ifname=name][,script=file][,downscript=dfile]\n"
"         [,br=bridge][,helper=helper][,sndbuf=nbytes][,vnet_hdr=on|off][,vhost=on|off]\n"
"         [,vhostfd=h][,vhostfds=x:y:...:z][,vhostforce=on|off][,queues=n]\n"
"         [,poll-us=n]\n"
"                configure a host TAP network backend with ID 'str'\n"
"                connected to a bridge (default=" DEFAULT_BRIDGE_INTERFACE ")\n"
"                use network scripts 'file' (default=" DEFAULT_NETWORK_SCRIPT ")\n"
"                to configure it and 'dfile' (default=" DEFAULT_NETWORK_DOWN_SCRIPT ")\n"
"                to deconfigure it\n"
"                use '[down]script=no' to disable script execution\n"
"                use network helper 'helper' (default=" DEFAULT_BRIDGE_HELPER ") to\n"
"                configure it\n"
"                use 'fd=h' to connect to an already opened TAP interface\n"
"                use 'fds=x:y:...:z' to connect to already opened multiqueue capable TAP interfaces\n"
"                use 'sndbuf=nbytes' to limit the size of the send buffer (the\n"
"                default is disabled 'sndbuf=0' to enable flow control set 'sndbuf=1048576')\n"
"                use vnet_hdr=off to avoid enabling the IFF_VNET_HDR tap flag\n"
"                use vnet_hdr=on to make the lack of IFF_VNET_HDR support an error condition\n"
"                use vhost=on to enable experimental in kernel accelerator\n"
"                    (only has effect for virtio guests which use MSIX)\n"
"                use vhostforce=on to force vhost on for non-MSIX virtio guests\n"
"                use 'vhostfd=h' to connect to an already opened vhost net device\n"
"                use 'vhostfds=x:y:...:z to connect to multiple already opened vhost net devices\n"
"                use 'queues=n' to specify the number of queues to be created for multiqueue TAP\n"
"                use 'poll-us=n' to speciy the maximum number of microseconds that could be\n"
"                spent on busy polling for vhost net\n"
"-netdev bridge,id=str[,br=bridge][,helper=helper]\n"
"                configure a host TAP network backend with ID 'str' that is\n"
"                connected to a bridge (default=" DEFAULT_BRIDGE_INTERFACE ")\n"
"                using the program 'helper (default=" DEFAULT_BRIDGE_HELPER ")\n"
#endif
#ifdef __linux__
"-netdev l2tpv3,id=str,src=srcaddr,dst=dstaddr[,srcport=srcport][,dstport=dstport]\n"
"         [,rxsession=rxsession],txsession=txsession[,ipv6=on/off][,udp=on/off]\n"
"         [,cookie64=on/off][,counter][,pincounter][,txcookie=txcookie]\n"
"         [,rxcookie=rxcookie][,offset=offset]\n"
"                configure a network backend with ID 'str' connected to\n"
"                an Ethernet over L2TPv3 pseudowire.\n"
"                Linux kernel 3.3+ as well as most routers can talk\n"
"                L2TPv3. This transport allows connecting a VM to a VM,\n"
"                VM to a router and even VM to Host. It is a nearly-universal\n"
"                standard (RFC3391). Note - this implementation uses static\n"
"                pre-configured tunnels (same as the Linux kernel).\n"
"                use 'src=' to specify source address\n"
"                use 'dst=' to specify destination address\n"
"                use 'udp=on' to specify udp encapsulation\n"
"                use 'srcport=' to specify source udp port\n"
"                use 'dstport=' to specify destination udp port\n"
"                use 'ipv6=on' to force v6\n"
"                L2TPv3 uses cookies to prevent misconfiguration as\n"
"                well as a weak security measure\n"
"                use 'rxcookie=0x012345678' to specify a rxcookie\n"
"                use 'txcookie=0x012345678' to specify a txcookie\n"
"                use 'cookie64=on' to set cookie size to 64 bit, otherwise 32\n"
"                use 'counter=off' to force a 'cut-down' L2TPv3 with no counter\n"
"                use 'pincounter=on' to work around broken counter handling in peer\n"
"                use 'offset=X' to add an extra offset between header and data\n"
#endif
"-netdev socket,id=str[,fd=h][,listen=[host]:port][,connect=host:port]\n"
"                configure a network backend to connect to another network\n"
"                using a socket connection\n"
"-netdev socket,id=str[,fd=h][,mcast=maddr:port[,localaddr=addr]]\n"
"                configure a network backend to connect to a multicast maddr and port\n"
"                use 'localaddr=addr' to specify the host address to send packets from\n"
"-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"
"                configure a network backend to connect to another network\n"
"                using an UDP tunnel\n"
#ifdef CONFIG_VDE
"-netdev vde,id=str[,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
"                configure a network backend to connect to port 'n' of a vde switch\n"
"                running on host and listening for incoming connections on 'socketpath'.\n"
"                Use group 'groupname' and mode 'octalmode' to change default\n"
"                ownership and permissions for communication port.\n"
#endif
#ifdef CONFIG_NETMAP
"-netdev netmap,id=str,ifname=name[,devname=nmname]\n"
"                attach to the existing netmap-enabled network interface 'name', or to a\n"
"                VALE port (created on the fly) called 'name' ('nmname' is name of the \n"
"                netmap device, defaults to '/dev/netmap')\n"
#endif
#ifdef CONFIG_POSIX
"-netdev vhost-user,id=str,chardev=dev[,vhostforce=on|off]\n"
"                configure a vhost-user network, backed by a chardev 'dev'\n"
#endif
"-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
"                configure a hub port on the hub with ID 'n'\n", QEMU_ARCH_ALL)
DEF("nic", HAS_ARG, QEMU_OPTION_nic,
"-nic [tap|bridge|"
#ifdef CONFIG_SLIRP
"user|"
#endif
#ifdef __linux__
"l2tpv3|"
#endif
#ifdef CONFIG_VDE
"vde|"
#endif
#ifdef CONFIG_NETMAP
"netmap|"
#endif
#ifdef CONFIG_POSIX
"vhost-user|"
#endif
"socket][,option][,...][mac=macaddr]\n"
"                initialize an on-board / default host NIC (using MAC address\n"
"                macaddr) and connect it to the given host network backend\n"
"-nic none       use it alone to have zero network devices (the default is to\n"
"                provided a 'user' network connection)\n",
QEMU_ARCH_ALL)
DEF("net", HAS_ARG, QEMU_OPTION_net,
"-net nic[,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n"
"                configure or create an on-board (or machine default) NIC and\n"
"                connect it to hub 0 (please use -nic unless you need a hub)\n"
"-net ["
#ifdef CONFIG_SLIRP
"user|"
#endif
"tap|"
"bridge|"
#ifdef CONFIG_VDE
"vde|"
#endif
#ifdef CONFIG_NETMAP
"netmap|"
#endif
"socket][,option][,option][,...]\n"
"                old way to initialize a host network interface\n"
"                (use the -netdev option if possible instead)\n", QEMU_ARCH_ALL)

DEFHEADING()

DEFHEADING(Character device options:)

DEF("chardev", HAS_ARG, QEMU_OPTION_chardev,
"-chardev help\n"
"-chardev null,id=id[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev socket,id=id[,host=host],port=port[,to=to][,ipv4][,ipv6][,nodelay][,reconnect=seconds]\n"
"         [,server][,nowait][,telnet][,websocket][,reconnect=seconds][,mux=on|off]\n"
"         [,logfile=PATH][,logappend=on|off][,tls-creds=ID][,tls-authz=ID] (tcp)\n"
"-chardev socket,id=id,path=path[,server][,nowait][,telnet][,websocket][,reconnect=seconds]\n"
"         [,mux=on|off][,logfile=PATH][,logappend=on|off] (unix)\n"
"-chardev udp,id=id[,host=host],port=port[,localaddr=localaddr]\n"
"         [,localport=localport][,ipv4][,ipv6][,mux=on|off]\n"
"         [,logfile=PATH][,logappend=on|off]\n"
"-chardev msmouse,id=id[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev vc,id=id[[,width=width][,height=height]][[,cols=cols][,rows=rows]]\n"
"         [,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev ringbuf,id=id[,size=size][,logfile=PATH][,logappend=on|off]\n"
"-chardev file,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev pipe,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
#ifdef _WIN32
"-chardev console,id=id[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev serial,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
#else
"-chardev pty,id=id[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev stdio,id=id[,mux=on|off][,signal=on|off][,logfile=PATH][,logappend=on|off]\n"
#endif
#ifdef CONFIG_BRLAPI
"-chardev braille,id=id[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
#endif
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
|| defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
"-chardev serial,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev tty,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
#endif
#if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__)
"-chardev parallel,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
"-chardev parport,id=id,path=path[,mux=on|off][,logfile=PATH][,logappend=on|off]\n"
#endif
#if defined(CONFIG_SPICE)
"-chardev spicevmc,id=id,name=name[,debug=debug][,logfile=PATH][,logappend=on|off]\n"
"-chardev spiceport,id=id,name=name[,debug=debug][,logfile=PATH][,logappend=on|off]\n"
#endif
, QEMU_ARCH_ALL
)


DEFHEADING()

DEFHEADING(Bluetooth(R) options:)

DEF("bt", HAS_ARG, QEMU_OPTION_bt, \
"-bt hci,null    dumb bluetooth HCI - doesn't respond to commands\n" \
"-bt hci,host[:id]\n" \
"                use host's HCI with the given name\n" \
"-bt hci[,vlan=n]\n" \
"                emulate a standard HCI in virtual scatternet 'n'\n" \
"-bt vhci[,vlan=n]\n" \
"                add host computer to virtual scatternet 'n' using VHCI\n" \
"-bt device:dev[,vlan=n]\n" \
"                emulate a bluetooth device 'dev' in scatternet 'n'\n",
QEMU_ARCH_ALL)

DEFHEADING()

#ifdef CONFIG_TPM
DEFHEADING(TPM device options:)

DEF("tpmdev", HAS_ARG, QEMU_OPTION_tpmdev, \
"-tpmdev passthrough,id=id[,path=path][,cancel-path=path]\n"
"                use path to provide path to a character device; default is /dev/tpm0\n"
"                use cancel-path to provide path to TPM's cancel sysfs entry; if\n"
"                not provided it will be searched for in /sys/class/misc/tpm?/device\n"
"-tpmdev emulator,id=id,chardev=dev\n"
"                configure the TPM device using chardev backend\n",
QEMU_ARCH_ALL)

DEFHEADING()

#endif

DEFHEADING(Linux/Multiboot boot specific:)

DEF("kernel", HAS_ARG, QEMU_OPTION_kernel, \
"-kernel bzImage use 'bzImage' as kernel image\n", QEMU_ARCH_ALL)

DEF("append", HAS_ARG, QEMU_OPTION_append, \
"-append cmdline use 'cmdline' as kernel command line\n", QEMU_ARCH_ALL)

DEF("initrd", HAS_ARG, QEMU_OPTION_initrd, \
"-initrd file    use 'file' as initial ram disk\n", QEMU_ARCH_ALL)

DEF("dtb", HAS_ARG, QEMU_OPTION_dtb, \
"-dtb    file    use 'file' as device tree image\n", QEMU_ARCH_ALL)

DEFHEADING()

DEFHEADING(Debug/Expert options:)

DEF("fw_cfg", HAS_ARG, QEMU_OPTION_fwcfg,
"-fw_cfg [name=]<name>,file=<file>\n"
"                add named fw_cfg entry with contents from file\n"
"-fw_cfg [name=]<name>,string=<str>\n"
"                add named fw_cfg entry with contents from string\n",
QEMU_ARCH_ALL)

DEF("serial", HAS_ARG, QEMU_OPTION_serial, \
"-serial dev     redirect the serial port to char device 'dev'\n",
QEMU_ARCH_ALL)

DEF("parallel", HAS_ARG, QEMU_OPTION_parallel, \
"-parallel dev   redirect the parallel port to char device 'dev'\n",
QEMU_ARCH_ALL)

DEF("monitor", HAS_ARG, QEMU_OPTION_monitor, \
"-monitor dev    redirect the monitor to char device 'dev'\n",
QEMU_ARCH_ALL)
DEF("qmp", HAS_ARG, QEMU_OPTION_qmp, \
"-qmp dev        like -monitor but opens in 'control' mode\n",
QEMU_ARCH_ALL)
DEF("qmp-pretty", HAS_ARG, QEMU_OPTION_qmp_pretty, \
"-qmp-pretty dev like -qmp but uses pretty JSON formatting\n",
QEMU_ARCH_ALL)

DEF("mon", HAS_ARG, QEMU_OPTION_mon, \
"-mon [chardev=]name[,mode=readline|control][,pretty[=on|off]]\n", QEMU_ARCH_ALL)

DEF("debugcon", HAS_ARG, QEMU_OPTION_debugcon, \
"-debugcon dev   redirect the debug console to char device 'dev'\n",
QEMU_ARCH_ALL)

DEF("pidfile", HAS_ARG, QEMU_OPTION_pidfile, \
"-pidfile file   write PID to 'file'\n", QEMU_ARCH_ALL)

DEF("singlestep", 0, QEMU_OPTION_singlestep, \
"-singlestep     always run in singlestep mode\n", QEMU_ARCH_ALL)

DEF("preconfig", 0, QEMU_OPTION_preconfig, \
"--preconfig     pause QEMU before machine is initialized (experimental)\n",
QEMU_ARCH_ALL)

DEF("S", 0, QEMU_OPTION_S, \
"-S              freeze CPU at startup (use 'c' to start execution)\n",
QEMU_ARCH_ALL)

DEF("realtime", HAS_ARG, QEMU_OPTION_realtime,
"-realtime [mlock=on|off]\n"
"                run qemu with realtime features\n"
"                mlock=on|off controls mlock support (default: on)\n",
QEMU_ARCH_ALL)

DEF("overcommit", HAS_ARG, QEMU_OPTION_overcommit,
"-overcommit [mem-lock=on|off][cpu-pm=on|off]\n"
"                run qemu with overcommit hints\n"
"                mem-lock=on|off controls memory lock support (default: off)\n"
"                cpu-pm=on|off controls cpu power management (default: off)\n",
QEMU_ARCH_ALL)

DEF("gdb", HAS_ARG, QEMU_OPTION_gdb, \
"-gdb dev        wait for gdb connection on 'dev'\n", QEMU_ARCH_ALL)

DEF("s", 0, QEMU_OPTION_s, \
"-s              shorthand for -gdb tcp::" DEFAULT_GDBSTUB_PORT "\n",
QEMU_ARCH_ALL)

DEF("d", HAS_ARG, QEMU_OPTION_d, \
"-d item1,...    enable logging of specified items (use '-d help' for a list of log items)\n",
QEMU_ARCH_ALL)

DEF("D", HAS_ARG, QEMU_OPTION_D, \
"-D logfile      output log to logfile (default stderr)\n",
QEMU_ARCH_ALL)

DEF("dfilter", HAS_ARG, QEMU_OPTION_DFILTER, \
"-dfilter range,..  filter debug output to range of addresses (useful for -d cpu,exec,etc..)\n",
QEMU_ARCH_ALL)

DEF("seed", HAS_ARG, QEMU_OPTION_seed, \
"-seed number       seed the pseudo-random number generator\n",
QEMU_ARCH_ALL)

DEF("L", HAS_ARG, QEMU_OPTION_L, \
"-L path         set the directory for the BIOS, VGA BIOS and keymaps\n",
QEMU_ARCH_ALL)

DEF("bios", HAS_ARG, QEMU_OPTION_bios, \
"-bios file      set the filename for the BIOS\n", QEMU_ARCH_ALL)

DEF("enable-kvm", 0, QEMU_OPTION_enable_kvm, \
"-enable-kvm     enable KVM full virtualization support\n", QEMU_ARCH_ALL)

DEF("xen-domid", HAS_ARG, QEMU_OPTION_xen_domid,
"-xen-domid id   specify xen guest domain id\n", QEMU_ARCH_ALL)
DEF("xen-attach", 0, QEMU_OPTION_xen_attach,
"-xen-attach     attach to existing xen domain\n"
"                libxl will use this when starting QEMU\n",
QEMU_ARCH_ALL)
DEF("xen-domid-restrict", 0, QEMU_OPTION_xen_domid_restrict,
"-xen-domid-restrict     restrict set of available xen operations\n"
"                        to specified domain id. (Does not affect\n"
"                        xenpv machine type).\n",
QEMU_ARCH_ALL)

DEF("no-reboot", 0, QEMU_OPTION_no_reboot, \
"-no-reboot      exit instead of rebooting\n", QEMU_ARCH_ALL)

DEF("no-shutdown", 0, QEMU_OPTION_no_shutdown, \
"-no-shutdown    stop before shutdown\n", QEMU_ARCH_ALL)

DEF("loadvm", HAS_ARG, QEMU_OPTION_loadvm, \
"-loadvm [tag|id]\n" \
"                start right away with a saved state (loadvm in monitor)\n",
QEMU_ARCH_ALL)

#ifndef _WIN32
DEF("daemonize", 0, QEMU_OPTION_daemonize, \
"-daemonize      daemonize QEMU after initializing\n", QEMU_ARCH_ALL)
#endif

DEF("option-rom", HAS_ARG, QEMU_OPTION_option_rom, \
"-option-rom rom load a file, rom, into the option ROM space\n",
QEMU_ARCH_ALL)

DEF("rtc", HAS_ARG, QEMU_OPTION_rtc, \
"-rtc [base=utc|localtime|<datetime>][,clock=host|rt|vm][,driftfix=none|slew]\n" \
"                set the RTC base and clock, enable drift fix for clock ticks (x86 only)\n",
QEMU_ARCH_ALL)


DEF("icount", HAS_ARG, QEMU_OPTION_icount, \
"-icount [shift=N|auto][,align=on|off][,sleep=on|off,rr=record|replay,rrfile=<filename>,rrsnapshot=<snapshot>]\n" \
"                enable virtual instruction counter with 2^N clock ticks per\n" \
"                instruction, enable aligning the host and virtual clocks\n" \
"                or disable real time cpu sleeping\n", QEMU_ARCH_ALL)

DEF("watchdog", HAS_ARG, QEMU_OPTION_watchdog, \
"-watchdog model\n" \
"                enable virtual hardware watchdog [default=none]\n",
QEMU_ARCH_ALL)

DEF("watchdog-action", HAS_ARG, QEMU_OPTION_watchdog_action, \
"-watchdog-action reset|shutdown|poweroff|inject-nmi|pause|debug|none\n" \
"                action when watchdog fires [default=reset]\n",
QEMU_ARCH_ALL)

DEF("echr", HAS_ARG, QEMU_OPTION_echr, \
"-echr chr       set terminal escape character instead of ctrl-a\n",
QEMU_ARCH_ALL)

DEF("show-cursor", 0, QEMU_OPTION_show_cursor, \
"-show-cursor    show cursor\n", QEMU_ARCH_ALL)

DEF("tb-size", HAS_ARG, QEMU_OPTION_tb_size, \
"-tb-size n      set TB size\n", QEMU_ARCH_ALL)

DEF("incoming", HAS_ARG, QEMU_OPTION_incoming, \
"-incoming tcp:[host]:port[,to=maxport][,ipv4][,ipv6]\n" \
"-incoming rdma:host:port[,ipv4][,ipv6]\n" \
"-incoming unix:socketpath\n" \
"                prepare for incoming migration, listen on\n" \
"                specified protocol and socket address\n" \
"-incoming fd:fd\n" \
"-incoming exec:cmdline\n" \
"                accept incoming migration on given file descriptor\n" \
"                or from given external command\n" \
"-incoming defer\n" \
"                wait for the URI to be specified via migrate_incoming\n",
QEMU_ARCH_ALL)

DEF("only-migratable", 0, QEMU_OPTION_only_migratable, \
"-only-migratable     allow only migratable devices\n", QEMU_ARCH_ALL)

DEF("nodefaults", 0, QEMU_OPTION_nodefaults, \
"-nodefaults     don't create default devices\n", QEMU_ARCH_ALL)

#ifndef _WIN32
DEF("chroot", HAS_ARG, QEMU_OPTION_chroot, \
"-chroot dir     chroot to dir just before starting the VM\n",
QEMU_ARCH_ALL)
#endif

#ifndef _WIN32
DEF("runas", HAS_ARG, QEMU_OPTION_runas, \
"-runas user     change to user id user just before starting the VM\n" \
"                user can be numeric uid:gid instead\n",
QEMU_ARCH_ALL)
#endif

DEF("prom-env", HAS_ARG, QEMU_OPTION_prom_env,
"-prom-env variable=value\n"
"                set OpenBIOS nvram variables\n",
QEMU_ARCH_PPC | QEMU_ARCH_SPARC)
DEF("semihosting", 0, QEMU_OPTION_semihosting,
"-semihosting    semihosting mode\n",
QEMU_ARCH_ARM | QEMU_ARCH_M68K | QEMU_ARCH_XTENSA | QEMU_ARCH_LM32 |
QEMU_ARCH_MIPS | QEMU_ARCH_NIOS2)
DEF("semihosting-config", HAS_ARG, QEMU_OPTION_semihosting_config,
"-semihosting-config [enable=on|off][,target=native|gdb|auto][,chardev=id][,arg=str[,...]]\n" \
"                semihosting configuration\n",
QEMU_ARCH_ARM | QEMU_ARCH_M68K | QEMU_ARCH_XTENSA | QEMU_ARCH_LM32 |
QEMU_ARCH_MIPS | QEMU_ARCH_NIOS2)
DEF("old-param", 0, QEMU_OPTION_old_param,
"-old-param      old param mode\n", QEMU_ARCH_ARM)

DEF("sandbox", HAS_ARG, QEMU_OPTION_sandbox, \
"-sandbox on[,obsolete=allow|deny][,elevateprivileges=allow|deny|children]\n" \
"          [,spawn=allow|deny][,resourcecontrol=allow|deny]\n" \
"                Enable seccomp mode 2 system call filter (default 'off').\n" \
"                use 'obsolete' to allow obsolete system calls that are provided\n" \
"                    by the kernel, but typically no longer used by modern\n" \
"                    C library implementations.\n" \
"                use 'elevateprivileges' to allow or deny QEMU process to elevate\n" \
"                    its privileges by blacklisting all set*uid|gid system calls.\n" \
"                    The value 'children' will deny set*uid|gid system calls for\n" \
"                    main QEMU process but will allow forks and execves to run unprivileged\n" \
"                use 'spawn' to avoid QEMU to spawn new threads or processes by\n" \
"                     blacklisting *fork and execve\n" \
"                use 'resourcecontrol' to disable process affinity and schedular priority\n",
QEMU_ARCH_ALL)

DEF("readconfig", HAS_ARG, QEMU_OPTION_readconfig,
"-readconfig <file>\n", QEMU_ARCH_ALL)
DEF("writeconfig", HAS_ARG, QEMU_OPTION_writeconfig,
"-writeconfig <file>\n"
"                read/write config file\n", QEMU_ARCH_ALL)

DEF("no-user-config", 0, QEMU_OPTION_nouserconfig,
"-no-user-config\n"
"                do not load default user-provided config files at startup\n",
QEMU_ARCH_ALL)

DEF("trace", HAS_ARG, QEMU_OPTION_trace,
"-trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
"                specify tracing options\n",
QEMU_ARCH_ALL)
DEF("plugin", HAS_ARG, QEMU_OPTION_plugin,
"-plugin [file=]<file>[,arg=<string>]\n"
"                load a plugin\n",
QEMU_ARCH_ALL)

DEF("qtest", HAS_ARG, QEMU_OPTION_qtest, "", QEMU_ARCH_ALL)
DEF("qtest-log", HAS_ARG, QEMU_OPTION_qtest_log, "", QEMU_ARCH_ALL)

#ifdef __linux__
DEF("enable-fips", 0, QEMU_OPTION_enablefips,
"-enable-fips    enable FIPS 140-2 compliance\n",
QEMU_ARCH_ALL)
#endif

DEF("no-kvm", 0, QEMU_OPTION_no_kvm, "", QEMU_ARCH_I386)

DEF("msg", HAS_ARG, QEMU_OPTION_msg,
"-msg timestamp[=on|off]\n"
"                change the format of messages\n"
"                on|off controls leading timestamps (default:on)\n",
QEMU_ARCH_ALL)

DEF("dump-vmstate", HAS_ARG, QEMU_OPTION_dump_vmstate,
"-dump-vmstate <file>\n"
"                Output vmstate information in JSON format to file.\n"
"                Use the scripts/vmstate-static-checker.py file to\n"
"                check for possible regressions in migration code\n"
"                by comparing two such vmstate dumps.\n",
QEMU_ARCH_ALL)

DEF("enable-sync-profile", 0, QEMU_OPTION_enable_sync_profile,
"-enable-sync-profile\n"
"                enable synchronization profiling\n",
QEMU_ARCH_ALL)

DEFHEADING()

DEFHEADING(Generic object creation:)

DEF("object", HAS_ARG, QEMU_OPTION_object,
"-object TYPENAME[,PROP1=VALUE1,...]\n"
"                create a new object of type TYPENAME setting properties\n"
"                in the order they are specified.  Note that the 'id'\n"
"                property must be set.  These objects are placed in the\n"
"                '/objects' path.\n",
QEMU_ARCH_ALL)


