qemu-system-cris - Online na nuvem

PROGRAMA:

NOME

qemu-doc - Documentação do usuário do emulador QEMU

SINOPSE

uso: qemu-system-i386 [opções] [imagem_de_disco]

DESCRIÇÃO

O emulador do sistema de PC QEMU simula os seguintes periféricos:

- Ponte PCI host i440FX e ponte PCI PIIX3 para ISA

- Placa Cirrus CLGD 5446 PCI VGA ou placa VGA falsa com extensões Bochs VESA (hardware
nível, incluindo todos os modos não padrão).

- Mouse e teclado PS / 2

- 2 interfaces PCI IDE com suporte para disco rígido e CD-ROM

- Disquete

- Adaptadores de rede PCI e ISA

- Portas seriais

- Placa de som Creative SoundBlaster 16

- Placa de som ENSONIQ AudioPCI ES1370

- Placa de som compatível com Áudio Intel 82801AA AC97

- Controlador de áudio Intel HD e codec HDA

- Adlib (OPL2) - Chip compatível com Yamaha YM3812

- Placa de som Gravis Ultrasound GF1

- Placa de som compatível com CS4231A

- Controlador PCI UHCI USB e um hub USB virtual.

SMP é compatível com até 255 CPUs.

O QEMU usa o BIOS do PC do projeto Seabios e o BIOS VGA Plex86 / Bochs LGPL.

O QEMU usa emulação YM3812 de Tatsuyuki Satoh.

QEMU usa emulação GUS (GUSEMU32http://www.deinmeister.de/gusemu/>) por Tibor "TS"
Schütz.

Observe que, por padrão, GUS compartilha IRQ(7) com portas paralelas e, portanto, QEMU deve ser informado para
não tem portas paralelas para ter GUS funcionando.

qemu-system-i386 dos.img -soundhw gus -paralelo nenhum

Alternativamente:

qemu-system-i386 dos.img -device gus, irq = 5

Ou algum outro IRQ não reclamado.

CS4231A é o chip usado nos produtos Windows Sound System e GUSMAX

OPÇÕES

imagem_de_disco é uma imagem bruta do disco rígido para o disco rígido 0. Alguns alvos não precisam de um disco
imagem.

Opções padrão:

-h Exibir ajuda e sair

-versão
Exibir informações da versão e sair

-máquina [tipo =]nome[, prop =valor[, ...]]
Selecione a máquina emulada por nome. Use "-ajuda da máquina" para listar as máquinas disponíveis.
As propriedades da máquina com suporte são:

accel =aceleração1[:aceleração2[: ...]]
Isso é usado para habilitar um acelerador. Dependendo da arquitetura de destino, kvm,
xen ou tcg podem estar disponíveis. Por padrão, tcg é usado. Se houver mais de um
acelerador especificado, o próximo é usado se o anterior falhar em
inicializar.

kernel_irqchip = on | off
Ativa o suporte irqchip no kernel para o acelerador escolhido quando disponível.

gfx_passthru = on | off
Ativa o suporte de passagem IGD GFX para a máquina escolhida, quando disponível.

vmport = on | off | auto
Ativa a emulação da porta IO VMWare, para vmmouse etc. auto diz para selecionar o
valor com base na aceleração. Para accel = xen, o padrão é desligado, caso contrário, o padrão é
em.

kvm_shadow_mem = tamanho
Define o tamanho do KVM shadow MMU.

dump-guest-core = on | off
Inclui memória de convidado em um dump de memória. O padrão é ativado.

mem-merge = on | off
Habilita ou desabilita o suporte para mesclagem de memória. Este recurso, quando suportado pelo
host, elimina a duplicação de páginas de memória idênticas entre as instâncias de VMs (habilitado por
predefinição).

iommu = on | off
Ativa ou desativa o suporte emulado Intel IOMMU (VT-d). O padrão é desligado.

aes-key-wrap = on | off
Habilita ou desabilita o suporte ao agrupamento de chave AES em hosts s390-ccw. Este recurso
controla se as chaves de empacotamento AES serão criadas para permitir a execução de AES
funções criptográficas. O padrão é ativado.

dea-key-wrap = on | off
Habilita ou desabilita o suporte para agrupamento de chave DEA em hosts s390-ccw. Este recurso
controla se as chaves de empacotamento DEA serão criadas para permitir a execução de DEA
funções criptográficas. O padrão é ativado.

-CPU modelo
Selecione o modelo de CPU ("-cpu help" para lista e seleção de recursos adicionais)

-smp [cpus =]n[, núcleos =núcleos] [, tópicos =tópicos] [, soquetes =soquetes] [, maxcpus =maxcpus]
Simule um sistema SMP com n CPUs. No destino do PC, até 255 CPUs são suportadas. Sobre
Alvo Sparc32, o Linux limita o número de CPUs utilizáveis ​​a 4. Para o alvo PC, o
número de núcleos por soquete, o número de tópicos por núcleos e o número total de
soquetes pode ser especificado. Os valores ausentes serão calculados. Se houver algum nos três valores
é fornecido, o número total de CPUs n pode ser omitida. maxcpus especifica o máximo
número de CPUs hotpluggable.

-numa nó [, mem =tamanho] [, cpus =cpu [-cpu]] [, nodeid =nó]
-numa nó [, memdev =id] [, cpus =cpu [-cpu]] [, nodeid =nó]
Simule um sistema NUMA de vários nós. Se mem, memdev e CPU são omitidos, os recursos são
dividir igualmente. Além disso, observe que -n'uma opção não aloca nenhum dos
Recursos. Ou seja, ele apenas atribui recursos existentes aos nós NUMA. Isso significa que
ainda é preciso usar o -m, -smp opções para alocar RAM e VCPUs, respectivamente, e
possivelmente -objeto para especificar o backend de memória para o memdev subopção.

mem e memdev são mutuamente exclusivos. Além disso, se um nó usa memdev, tudo de
eles têm que usá-lo.

-adicionar-fd fd =fd, set =conjunto[, opaco =opaco]
Adicione um descritor de arquivo a um conjunto fd. As opções válidas são:

fd =fd
Esta opção define o descritor de arquivo do qual uma duplicata é adicionada ao conjunto fd.
O descritor de arquivo não pode ser stdin, stdout ou stderr.

set =conjunto
Esta opção define o ID do conjunto fd ao qual adicionar o descritor de arquivo.

opaco =opaco
Esta opção define uma string de formato livre que pode ser usada para descrever fd.

Você pode abrir uma imagem usando descritores de arquivo pré-abertos de um conjunto fd:

qemu-sistema-i386
-add-fd fd = 3, set = 2, opaque = "rdwr: / caminho / para / arquivo"
-add-fd fd = 4, set = 2, opaque = "rdonly: / path / to / file"
-drive file = / dev / fdset / 2, index = 0, media = disk

-conjunto grupo.id.arg=valor
Definir parâmetro arg para item id do tipo grupo "

-global motorista.mordaça=valor
-global motorista =motorista, propriedade =propriedade, valor =valor
Definir o valor padrão de motoristapropriedade de mordaça para valor, por exemplo:

qemu-system-i386 -global ide-drive.physical_block_size = 4096 -drive file = file, if = ide, index = 0, media = disk

Em particular, você pode usar isso para definir propriedades de driver para dispositivos que são criados
automaticamente pelo modelo da máquina. Para criar um dispositivo que não foi criado
automaticamente e definir propriedades nele, use -dispositivo.

-global motorista.mordaça=valor é uma abreviatura para -global
motorista =motorista, propriedade =mordaça, valor =valor. A sintaxe extensa funciona mesmo quando motorista
contém um ponto.

-Bota
[pedido =Acionadores] [, uma vez =Acionadores] [, menu = on | off] [, splash =sp_name] [, splash-time =sp_time] [, tempo limite de reinicialização =rb_timeout] [, estrito = ligado | desligado]
Especifique a ordem de inicialização Acionadores como uma sequência de letras de unidade. Letras de unidade válidas dependem de
a arquitetura de destino. O PC x86 usa: a, b (disquete 1 e 2), c (primeiro disco rígido),
d (primeiro CD-ROM), np (Etherboot do adaptador de rede 1-4), a inicialização do disco rígido é o
predefinição. Para aplicar uma determinada ordem de inicialização apenas na primeira inicialização, especifique-a via
uma vez.

Menus / prompts de inicialização interativos podem ser ativados via menu = ligado tanto quanto firmware / BIOS
apóia-os. O padrão é inicialização não interativa.

Uma imagem inicial pode ser passada para a bios, permitindo ao usuário mostrá-la como logotipo, quando
opção splash =sp_name é fornecido e menu = on, se o firmware / BIOS os suportar. Atualmente
Seabios para sistema X86 é compatível. limitação: o arquivo inicial pode ser um arquivo jpeg
ou um arquivo BMP no formato 24 BPP (true color). A resolução deve ser apoiada pelo
Modo SVGA, portanto, o recomendado é 320x240, 640x480, 800x640.

Um tempo limite pode ser passado para a BIOS, o convidado fará uma pausa para rb_timeout ms quando inicializar
falhou e reinicie. Se rb_timeout é '-1', o convidado não reinicia, qemu passa '-1' para
BIOS por padrão. Atualmente Seabios para sistema X86 o suporta.

Faça uma inicialização estrita via estrito = em tanto quanto o firmware / BIOS o suporta. Isso só afeta
quando a prioridade de inicialização é alterada pelas opções do índice de inicialização. O padrão é inicialização não estrita.

# tente inicializar a partir da rede primeiro, depois a partir do disco rígido
qemu-system-i386 -boot order = nc
# inicialize do CD-ROM primeiro, volte para a ordem padrão após a reinicialização
qemu-system-i386 -boot once = d
# inicialize com uma imagem inicial por 5 segundos.
qemu-system-i386 -boot menu = on, splash = / root / boot.bmp, splash-time = 5000

Nota: O formato legado '-boot Acionadores'ainda é suportado, mas seu uso é desencorajado
pois pode ser removido de versões futuras.

-m [tamanho =]megas[, slots = n, maxmem = tamanho]
Define o tamanho da RAM de inicialização do convidado para megas megabytes. O padrão é 128 MiB. Opcionalmente, um
o sufixo "M" ou "G" pode ser usado para significar um valor em megabytes ou gigabytes
respectivamente. Par opcional caça-níqueis, máximo pode ser usado para definir a quantidade de hotpluggable
slots de memória e quantidade máxima de memória. Observe que máximo deve estar alinhado com o
tamanho da página.

Por exemplo, a linha de comando a seguir define o tamanho da RAM de inicialização do convidado para 1 GB,
cria 3 slots para hotplug de memória adicional e define o máximo de memória que o convidado pode
alcance até 4 GB:

qemu-system-x86_64 -m 1G,slots=3,maxmem=4G

If caça-níqueis e máximo não forem especificados, o hotplug de memória não será habilitado e o convidado
a RAM de inicialização nunca aumentará.

-caminho-mem caminho
Alocar RAM de convidado de um arquivo criado temporariamente em caminho.

-mem-prealloc
Pré-aloque a memória ao usar -mem-path.

-k língua
Usar layout de teclado língua (por exemplo, "fr" para francês). Esta opção só é necessária
onde não é fácil obter códigos-chave brutos de PC (por exemplo, em Macs, com alguns servidores X11 ou
com um display VNC). Normalmente você não precisa usá-lo em PC / Linux ou PC / Windows
anfitriões.

Os layouts disponíveis são:

ar de-ch es para fr-ca hu ja mk no pt-br sv
da en-gb et fr-ch is lt nl pl ru th
de en-us fi fr-be hr it lv nl-be pt sl tr

O padrão é "en-us".

-áudio-ajuda
Irá mostrar a ajuda do subsistema de áudio: lista de drivers, parâmetros ajustáveis.

-som cartão 1[,cartão 2, ...] or -som todos os
Habilite o áudio e o hardware de som selecionado. Use 'ajuda' para imprimir todos os sons disponíveis
hardware.

qemu-system-i386 -soundhw sb16, adlib disk.img
qemu-system-i386 -soundhw es1370 disco.img
qemu-system-i386 -soundhw ac97 disco.img
qemu-system-i386 -soundhw hda disk.img
qemu-system-i386 -soundhw todos os discos.img
qemu-system-i386 -soundhw ajuda

Observe que o módulo de kernel OSS i810_audio do Linux (para AC97) pode exigir manualmente
especificando clocking.

modprobe i810_audio clocking = 48000

-balão Nenhum
Desative o dispositivo de balão.

-balão virtio [, addr =addr]
Ativar dispositivo virtio balloon (padrão), opcionalmente com endereço PCI addr.

-Device motorista[,mordaça[=valor] [, ...]]
Adicionar dispositivo motorista. mordaça=valor define as propriedades do driver. Propriedades válidas dependem do
motorista. Para obter ajuda sobre possíveis drivers e propriedades, use "-device help" e
"-dispositivo motorista, ajuda ".

-nome nome
Define o nome do convidado. Este nome será exibido na legenda da janela SDL.
A nome também será usado para o servidor VNC. Opcionalmente, defina o topo visível
nome do processo no Linux. A nomenclatura de threads individuais também pode ser habilitada no Linux para
ajuda na depuração.

-uuid uuid
Defina o UUID do sistema.

Opções de bloqueio do dispositivo:

-fda lima
-fdb lima
Use lima como imagem de disquete 0/1.

-hda lima
-hdb lima
-hdc lima
-HDD lima
Use lima como disco rígido 0, 1, 2 ou 3 imagem.

-CD ROM lima
Use lima como imagem de CD-ROM (você não pode usar -hdc e -CD ROM ao mesmo tempo). Você pode
use o CD-ROM host usando / dev / cdrom como nome de arquivo.

-dirigir opção[,opção[,opção[, ...]]]
Defina uma nova unidade. As opções válidas são:

arquivo =lima
Esta opção define qual imagem de disco usar com esta unidade. Se o nome do arquivo
contém vírgula, você deve duplicá-la (por exemplo, "arquivo = meu ,, arquivo" para usar o arquivo
"meu arquivo").

Arquivos especiais, como dispositivos iSCSI, podem ser especificados usando URLs específicos de protocolo.
Consulte a seção "Sintaxe do URL do dispositivo" para obter mais informações.

if =interface
Esta opção define em qual tipo de interface o drive está conectado. Disponível
os tipos são: ide, scsi, sd, mtd, disquete, pflash, virtio.

bus =ônibus, unidade =unidade
Essas opções definem onde o drive está conectado, definindo o número do barramento e
o id da unidade.

índice =índice
Esta opção define onde a unidade está conectada usando um índice na lista de
conectores disponíveis de um determinado tipo de interface.

media =imprensa
Esta opção define o tipo de mídia: disco ou cdrom.

cils =c, cabeças =h, segs =s[, trans =t]
Essas opções têm a mesma definição que têm em -hdachs.

instantâneo =instantâneo
instantâneo está "ligado" ou "desligado" e controla o modo instantâneo para a unidade dada (ver
-instantâneo).

cache =esconderijo
esconderijo é "nenhum", "write-back", "inseguro", "directsync" ou "writeethrough" e
controla como o cache do host é usado para acessar os dados do bloco.

aio =aio
aio é "threads" ou "nativo" e seleciona entre I / O de disco baseado em pthread e
AIO Linux nativo.

descartar =descartar
descartar é "ignorar" (ou "desligar") ou "desmapear" (ou "ligar") e controla se
descartar (também conhecido como aparar or desmapear) as solicitações são ignoradas ou passadas para o
sistema de arquivo. Alguns tipos de máquina podem não oferecer suporte a solicitações de descarte.

formato =formato
Especifique qual disco formato será usado em vez de detectar o formato. Pode ser
usado para especificar format = raw para evitar a interpretação de um cabeçalho de formato não confiável.

serial =serial
Esta opção especifica o número de série a ser atribuído ao dispositivo.

addr =addr
Especifique o endereço PCI do controlador (if = virtio apenas).

werror =açao, rerror =açao
Especifique qual açao para assumir erros de gravação e leitura. As ações válidas são: "ignorar"
(ignore o erro e tente continuar), "pare" (pause o QEMU), "relate" (informe o
erro para o convidado), "enospc" (pausa QEMU apenas se o disco do host estiver cheio; relatório
o erro para o hóspede caso contrário). A configuração padrão é werror = enospc e
rerror = relatório.

somente leitura
Abra a unidade lima como somente leitura. As tentativas de escrita do convidado irão falhar.

cópia na leitura =cópia na leitura
cópia na leitura está "ligado" ou "desligado" e permite copiar o arquivo de leitura de apoio
setores no arquivo de imagem.

detect-zeros =detect-zeros
detect-zeros é "off", "on" ou "unmap" e permite a conversão automática de
zero simples gravações pelo sistema operacional para comandos de gravação zero otimizados específicos do driver. Vocês
pode até escolher "desmapear" se descartar é definido como "unmap" para permitir que uma gravação zero seja
convertido em uma operação UNMAP.

Por padrão, o cache = writeback modo é usado. Ele relatará as gravações de dados como concluídas
assim que os dados estiverem presentes no cache da página do host. Isso é seguro, contanto que seu
o sistema operacional convidado garante a liberação correta dos caches de disco quando necessário. Se o seu sistema operacional convidado
não lidar com caches de gravação de disco volátil corretamente e seu host trava ou perde energia,
então, o convidado pode sofrer corrupção de dados.

Para esses convidados, você deve considerar o uso de cache = writeethrough. Isso significa que o
o cache da página do host será usado para ler e gravar dados, mas a notificação de gravação será
enviado ao convidado somente após o QEMU ter certeza de liberar cada gravação no disco. Ser
ciente de que isso tem um grande impacto no desempenho.

O cache da página do host pode ser totalmente evitado com cache = nenhum. Isso tentará fazer
disco IO diretamente para a memória do convidado. QEMU ainda pode realizar uma cópia interna do
os dados. Observe que este é considerado um modo de write-back e o sistema operacional convidado deve lidar
o cache de gravação do disco corretamente para evitar a corrupção de dados em travamentos do host.

O cache da página do host pode ser evitado, enviando apenas notificações de gravação para o convidado
quando os dados foram liberados para o disco usando cache = directsync.

Caso você não se importe com a integridade dos dados em relação às falhas do host, use cache = inseguro. Este
opção diz ao QEMU que ele nunca precisa gravar nenhum dado no disco, mas pode em vez disso
manter as coisas em cache. Se algo der errado, como o host perdendo energia, o disco
armazenamento sendo desconectado acidentalmente, etc. sua imagem provavelmente será
tornado inutilizável. Ao usar o -instantâneo opção, o cache inseguro é sempre usado.

A cópia na leitura evita acessar os mesmos setores do arquivo de apoio repetidamente e é útil
quando o arquivo de backup está em uma rede lenta. Por padrão, a cópia na leitura está desativada.

Em vez de -CD ROM você pode usar:

qemu-system-i386 -drive file = file, index = 2, media = cdrom

Em vez de -hda, -hdb, -hdc, -HDD, você pode usar:

qemu-system-i386 -drive file = file, index = 0, media = disk
qemu-system-i386 -drive file = file, index = 1, media = disk
qemu-system-i386 -drive file = file, index = 2, media = disk
qemu-system-i386 -drive file = file, index = 3, media = disk

Você pode abrir uma imagem usando descritores de arquivo pré-abertos de um conjunto fd:

qemu-sistema-i386
-add-fd fd = 3, set = 2, opaque = "rdwr: / caminho / para / arquivo"
-add-fd fd = 4, set = 2, opaque = "rdonly: / path / to / file"
-drive file = / dev / fdset / 2, index = 0, media = disk

Você pode conectar um CDROM ao escravo de ide0:

qemu-system-i386 -drive file = file, if = ide, index = 1, media = cdrom

Se você não especificar o argumento "file =", definirá uma unidade vazia:

qemu-system-i386 -drive if = ide, index = 1, media = cdrom

Você pode conectar um disco SCSI com a unidade ID 6 no barramento # 0:

qemu-system-i386 -drive file = file, if = scsi, bus = 0, unit = 6

Em vez de -fda, -fdb, você pode usar:

qemu-system-i386 -drive file = file, index = 0, if = floppy
qemu-system-i386 -drive file = file, index = 1, if = floppy

Por padrão, o interface é "ide" e índice é incrementado automaticamente:

qemu-system-i386 -drive file = a -drive file = b "

é interpretado como:

qemu-system-i386 -hda a -hdb b

-mtdblock lima
Use lima como imagem da memória Flash integrada.

-SD lima
Use lima como imagem de cartão SecureDigital.

-pflash lima
Use lima como uma imagem flash paralela.

-instantâneo
Grave em arquivos temporários em vez de arquivos de imagem de disco. Neste caso, a imagem bruta do disco
você usa não é escrito de volta. No entanto, você pode forçar a gravação pressionando Ca s.

-hdachs c,h,s, [,t]
Forçar geometria física do disco rígido 0 (1 <= c <= 16383, 1 <= h <= 16, 1 <= s <= 63) e
opcionalmente, forçar o modo de tradução do BIOS (t= nenhum, lba ou automático). Normalmente o QEMU pode
adivinhe todos esses parâmetros. Esta opção é útil para imagens de disco antigas do MS-DOS.

-fsdev
driver fs, id =id, caminho =caminho, [security_model =modelo_de_segurança] [, escrever =escrever] [, somente leitura] [, soquete =soquete| sock_fd =meia_fd]
Defina um novo dispositivo de sistema de arquivos. As opções válidas são:

driver fs
Esta opção especifica o back-end do driver fs a ser usado. Atualmente "local", "identificador"
e drivers de sistema de arquivos "proxy" são suportados.

id =id
Especifica o identificador para este dispositivo

caminho =caminho
Especifica o caminho de exportação para o dispositivo do sistema de arquivos. Arquivos neste caminho irão
estar disponível para o cliente 9p no hóspede.

security_model =modelo_de_segurança
Especifica o modelo de segurança a ser usado para este caminho de exportação. Segurança com suporte
os modelos são "passthrough", "mapped-xattr", "mapped-file" e "none". No
modelo de segurança "passthrough", os arquivos são armazenados usando as mesmas credenciais que eles
são criados no convidado. Isso requer que o QEMU seja executado como root. Em "mapped-xattr"
modelo de segurança, alguns dos atributos de arquivo como uid, gid, bits de modo e link
destino são armazenados como atributos de arquivo. Para "arquivo mapeado", esses atributos são
armazenado no diretório oculto .virtfs_metadata. Diretórios exportados por este
modelo de segurança não pode interagir com outras ferramentas unix. modelo de segurança "nenhum" é
o mesmo que passthrough, exceto que o servidor não relatará falhas se não conseguir definir o arquivo
atributos como propriedade. O modelo de segurança é obrigatório apenas para fsdriver local.
Outros fsdrivers (como handle, proxy) não tomam o modelo de segurança como parâmetro.

escrever =escrever
Este é um argumento opcional. O único valor com suporte é "imediato". Isso significa
esse cache de página host será usado para ler e gravar dados, mas escrever notificação
serão enviados ao hóspede somente quando os dados forem relatados conforme escrito pelo
subsistema de armazenamento.

somente leitura
Ativa a exportação de compartilhamento 9p como uma montagem somente leitura para convidados. Por padrão, leitura e gravação
o acesso é concedido.

socket =soquete
Permite que o driver do sistema de arquivos proxy use o arquivo de soquete passado para se comunicar com
virtfs-proxy-ajudante

sock_fd =meia_fd
Permite que o driver do sistema de arquivos proxy use o descritor de soquete passado para comunicação
com virtfs-proxy-helper. Normalmente, um auxiliar como libvirt irá criar socketpair e
passe um dos fds como sock_fd

A opção -fsdev é usada junto com o driver -device "virtio-9p-pci".

-Device virtio-9p-pci, fsdev =id, mount_tag =montagem_tag
As opções para o driver virtio-9p-pci são:

fsdev =id
Especifica o valor de id especificado junto com a opção -fsdev

mount_tag =montagem_tag
Especifica o nome da tag a ser usado pelo convidado para montar este ponto de exportação

-virtfs
driver fs[, caminho =caminho], mount_tag =montagem_tag[, security_model =modelo_de_segurança] [, escrever =escrever] [, somente leitura] [, soquete =soquete| sock_fd =meia_fd]
A forma geral das opções de passagem do sistema de arquivos virtual são:

driver fs
Esta opção especifica o back-end do driver fs a ser usado. Atualmente "local", "identificador"
e drivers de sistema de arquivos "proxy" são suportados.

id =id
Especifica o identificador para este dispositivo

caminho =caminho
Especifica o caminho de exportação para o dispositivo do sistema de arquivos. Arquivos neste caminho irão
estar disponível para o cliente 9p no hóspede.

security_model =modelo_de_segurança
Especifica o modelo de segurança a ser usado para este caminho de exportação. Segurança com suporte
os modelos são "passthrough", "mapped-xattr", "mapped-file" e "none". No
modelo de segurança "passthrough", os arquivos são armazenados usando as mesmas credenciais que eles
são criados no convidado. Isso requer que o QEMU seja executado como root. Em "mapped-xattr"
modelo de segurança, alguns dos atributos de arquivo como uid, gid, bits de modo e link
destino são armazenados como atributos de arquivo. Para "arquivo mapeado", esses atributos são
armazenado no diretório oculto .virtfs_metadata. Diretórios exportados por este
modelo de segurança não pode interagir com outras ferramentas unix. modelo de segurança "nenhum" é
o mesmo que passthrough, exceto que o servidor não relatará falhas se não conseguir definir o arquivo
atributos como propriedade. O modelo de segurança é obrigatório apenas para fsdriver local.
Outros fsdrivers (como handle, proxy) não tomam o modelo de segurança como parâmetro.

escrever =escrever
Este é um argumento opcional. O único valor com suporte é "imediato". Isso significa
esse cache de página host será usado para ler e gravar dados, mas escrever notificação
serão enviados ao hóspede somente quando os dados forem relatados conforme escrito pelo
subsistema de armazenamento.

somente leitura
Ativa a exportação de compartilhamento 9p como uma montagem somente leitura para convidados. Por padrão, leitura e gravação
o acesso é concedido.

socket =soquete
Permite que o driver do sistema de arquivos proxy use o arquivo de soquete passado para se comunicar com
virtfs-proxy-helper. Normalmente, um helper como o libvirt irá criar socketpair e passar
um dos fds como sock_fd

meia_fd
Permite que o driver do sistema de arquivos proxy use 'sock_fd' passado como o descritor de socket
para interface com virtfs-proxy-helper

-virtfs_synth
Criar imagem de sistema de arquivo sintético

Opções USB:

-USB
Habilite o driver USB (será o padrão em breve)

-dispositivo USB nome do desenvolvedor
Adicione o dispositivo USB nome do desenvolvedor.

mouse
Mouse Virtual. Isso substituirá a emulação do mouse PS / 2 quando ativado.

comprimido
Dispositivo de ponteiro que usa coordenadas absolutas (como uma tela sensível ao toque). Isso significa
O QEMU é capaz de relatar a posição do mouse sem ter que agarrar o mouse. Também
substitui a emulação do mouse PS / 2 quando ativado.

disco: [formato =formato]:lima
Dispositivo de armazenamento em massa baseado em arquivo. O opcional formato argumento será usado
em vez de detectar o formato. Pode ser usado para especificar "format = raw" para evitar
interpretar um cabeçalho de formato não confiável.

host:ônibus.addr
Passe pelo dispositivo host identificado por ônibus.addr (Somente Linux).

host:ID_do_fornecedor:ID do produto
Passe pelo dispositivo host identificado por ID_do_fornecedor:ID do produto (Somente Linux).

serial: [vendorid =ID_do_fornecedor] [, id do produto =ID do produto]:dev
Conversor serial para dispositivo de caractere host dev, consulte "-serial" para os disponíveis
dispositivos.

braille
Dispositivo Braille. Isso usará BrlAPI para exibir a saída braille em um real ou
dispositivo falso.

líquido:opções
Adaptador de rede compatível com os protocolos CDC Ethernet e RNDIS.

Opções de exibição:

-exibição tipo
Selecione o tipo de monitor a ser usado. Esta opção é uma substituição para o estilo antigo
opções -sdl / -curses / .... Valores válidos para tipo e guarante que os mesmos estão

sdl Exibir saída de vídeo via SDL (geralmente em uma janela gráfica separada; consulte o SDL
documentação para outras possibilidades).

maldições
Exibir saída de vídeo por meio de curses. Para modelos de dispositivos gráficos que suportam um texto
modo, o QEMU pode exibir essa saída usando uma interface curses / ncurses. Nada é
exibido quando o dispositivo gráfico está no modo gráfico ou se o dispositivo gráfico
não suporta modo de texto. Geralmente, apenas os modelos de dispositivos VGA suportam texto
modo.

Nenhum
Não exibe a saída de vídeo. O convidado ainda verá uma placa gráfica emulada,
mas sua saída não será exibida para o usuário QEMU. Esta opção difere de
a opção -nographic porque afeta apenas o que é feito com a saída de vídeo;
-nographic também altera o destino dos dados da porta serial e paralela.

gtk Exibir a saída de vídeo em uma janela GTK. Esta interface fornece menus suspensos e
outros elementos da IU para configurar e controlar a VM durante o tempo de execução.

vnc Inicie um servidor VNC em exibição

-nográfico
Normalmente, o QEMU usa SDL para exibir a saída VGA. Com esta opção, você pode totalmente
desative a saída gráfica para que o QEMU seja um aplicativo de linha de comando simples. o
a porta serial emulada é redirecionada no console e mixada com o monitor (a menos que
redirecionado para outro lugar explicitamente). Portanto, você ainda pode usar o QEMU para depurar um Linux
kernel com um console serial. Usar Ca h para obter ajuda sobre como alternar entre o console e
monitor.

- maldições
Normalmente, o QEMU usa SDL para exibir a saída VGA. Com esta opção, o QEMU pode exibir
a saída VGA quando em modo de texto usando uma interface curses / ncurses. Nada é
exibido no modo gráfico.

-nenhum quadro
Não use decorações para janelas SDL e inicie-as usando toda a tela disponível
espaço. Isso torna o uso do QEMU em um espaço de trabalho de área de trabalho dedicado mais conveniente.

-alt-agarrar
Use Ctrl-Alt-Shift para agarrar o mouse (em vez de Ctrl-Alt). Observe que isso também afeta
as teclas especiais (para tela inteira, comutação de modo de monitor, etc).

-ctrl-agarrar
Use Right-Ctrl para agarrar o mouse (em vez de Ctrl-Alt). Observe que isso também afeta o
teclas especiais (para tela inteira, comutação de modo de monitor, etc).

-não-desistir
Desative o recurso de fechamento da janela SDL.

-sdl
Habilite SDL.

-especiaria opção[,opção[, ...]]
Ative o protocolo de área de trabalho remota do Spice. As opções válidas são

porta =
Defina a porta TCP que a especiaria está escutando para canais de texto simples.

addr =
Defina o endereço IP em que o spice está escutando. O padrão é qualquer endereço.

ipv4
ipv6
unix
Force usando a versão de IP especificada.

senha =
Defina a senha que você precisa para autenticar.

atrevido
Exigir que o cliente use SASL para autenticar com o tempero. A escolha exata
do método de autenticação usado é controlado a partir do SASL do sistema / usuário
arquivo de configuração para o serviço 'qemu'. Isso é normalmente encontrado em
/etc/sasl2/qemu.conf. Se estiver executando o QEMU como um usuário sem privilégios, um ambiente
a variável SASL_CONF_PATH pode ser usada para fazer a pesquisa de locais alternativos para o
configuração do serviço. Embora alguns métodos de autenticação SASL também possam fornecer criptografia de dados (por exemplo,
GSSAPI), é recomendado que SASL seja sempre combinado com 'tls' e 'x509'
configurações para habilitar o uso de SSL e certificados de servidor. Isso garante um dado
criptografia evitando o comprometimento das credenciais de autenticação.

desabilitar tíquetes
Permitir que o cliente se conecte sem autenticação.

desativar copiar e colar
Desative copiar e colar entre o cliente e o convidado.

desativar-agente-arquivo-xfer
Desative o arquivo xfer baseado em spice-vdagent entre o cliente e o convidado.

tls-port =
Defina a porta TCP que a especiaria está escutando para canais criptografados.

x509-dir =
Defina o diretório do arquivo x509. Espera os mesmos nomes de arquivo que -vnc $ display, x509 = $ dir

x509-key-file =
x509-chave-senha =
x509-cert-file =
x509-cacert-file =
x509-dh-key-file =
Os nomes de arquivo x509 também podem ser configurados individualmente.

tls-ciphers =
Especifique quais cifras usar.

tls-channel = [main | display | cursor | inputs | record | playback]
plaintext-channel = [main | display | cursor | inputs | record | playback]
Força canal específico a ser usado com ou sem criptografia TLS. As opções podem
ser especificado várias vezes para configurar vários canais. O nome especial
"default" pode ser usado para definir o modo padrão. Para canais que não são
explicitamente forçado a um modo, o cliente do Spice tem permissão para escolher tls / texto simples
como ele agrada.

compressão de imagem = [auto_glz | auto_lz | quic | glz | lz | off]
Configure a compressão da imagem (sem perdas). O padrão é auto_glz.

jpeg-wan-compression = [auto | nunca | sempre]
zlib-glz-wan-compression = [auto | nunca | sempre]
Configure a compactação de imagem wan (com perdas para links lentos). O padrão é automático.

streaming-video = [desligado | todos | filtro]
Configure a detecção de stream de vídeo. O padrão é filtro.

agent-mouse = [on | off]
Habilita / desabilita a passagem de eventos do mouse via vdagent. O padrão é ativado.

compressão de reprodução = [ligado | desligado]
Ativar / desativar a compressão de fluxo de áudio (usando celt 0.5.1). O padrão é ativado.

migração contínua = [ligado | desligado]
Habilite / desabilite a migração perfeita do Spice. O padrão é desativado.

-Retrato
Gire a saída gráfica 90 graus para a esquerda (somente PXA LCD).

- girar deg
Gire a saída gráfica alguns graus para a esquerda (somente PXA LCD).

-vga tipo
Selecione o tipo de placa VGA para emular. Valores válidos para tipo e guarante que os mesmos estão

cirro
Placa de vídeo Cirrus Logic GD5446. Todas as versões do Windows a partir do Windows 95
deve reconhecer e usar esta placa gráfica. Para obter um desempenho ideal, use 16 bits
profundidade de cor no sistema operacional convidado e no host. (Este é o padrão)

std Placa VGA padrão com extensões Bochs VBE. Se o seu sistema operacional convidado for compatível com VESA
Extensões 2.0 VBE (por exemplo, Windows XP) e se você quiser usar modos de alta resolução
(> = 1280x1024x16) então você deve usar esta opção.

vmware
Adaptador compatível com VMWare SVGA-II. Use-o se você tiver dados suficientemente recentes
Servidor XFree86 / XOrg ou convidado do Windows com um driver para esta placa.

qxl Placa gráfica paravirtual QXL. É compatível com VGA (incluindo VESA 2.0 VBE
Apoio, suporte). Funciona melhor com drivers convidados qxl instalados. Escolha recomendada
ao usar o protocolo de especiarias.

TCX (somente sun4m) Sun TCX framebuffer. Este é o framebuffer padrão para sun4m
máquinas e oferece profundidades de cor de 8 e 24 bits em uma resolução fixa de
1024x768.

cg3 (somente sun4m) Sun cgthree framebuffer. Este é um framebuffer simples de 8 bits para sun4m
máquinas disponíveis nas resoluções 1024x768 (OpenBIOS) e 1152x900 (OBP)
destinado a pessoas que desejam executar versões mais antigas do Solaris.

virtio
Placa Virtio VGA.

Nenhum
Desative a placa VGA.

-tela cheia
Comece em tela inteira.

-g larguraxaltura[xprofundidade]
Defina a resolução gráfica inicial e a profundidade (somente PPC, SPARC).

-vnc exibição[,opção[,opção[, ...]]]
Normalmente, o QEMU usa SDL para exibir a saída VGA. Com esta opção, você pode ter
QEMU ouvir no display VNC exibição e redirecionar a exibição VGA sobre a sessão VNC.
É muito útil habilitar o tablet usb ao usar esta opção (opção
-dispositivo USB comprimido) Ao usar o display VNC, você deve usar o -k parâmetro para definir
o layout do teclado se você não estiver usando o en-us. Sintaxe válida para o exibição is

hospedeiro:d
Conexões TCP só serão permitidas de hospedeiro na tela d. Por convenção o
A porta TCP é 5900+d. Opcionalmente, hospedeiro pode ser omitido, caso em que o servidor irá
aceitar conexões de qualquer host.

Unix:caminho
As conexões serão permitidas em soquetes de domínio UNIX onde caminho é a localização de
um soquete unix para ouvir as conexões.

Nenhum
O VNC foi inicializado, mas não foi iniciado. O comando de "mudança" do monitor pode ser usado para
mais tarde, inicie o servidor VNC.

Seguindo as exibição valor pode haver um ou mais opção sinalizadores separados por vírgulas.
As opções válidas são

reverso
Conecte-se a um cliente VNC de escuta por meio de uma conexão "reversa". O cliente é
especificado pelo exibição. Para conexões de rede reversas (hospedeiro:d, "reverso"), o
d argumento é um número de porta TCP, não um número de exibição.

soquete da web
Abre uma porta de escuta TCP adicional dedicada às conexões VNC Websocket. Por
definição, a porta Websocket é 5700+exibição. Se hospedeiro são as conexões especificadas
só será permitido a partir deste host. Como alternativa, a porta Websocket poderia
ser especificado usando "websocket" =porta. Se nenhuma credencial TLS for fornecida, o
a conexão do websocket é executada em modo não criptografado. Se as credenciais TLS forem fornecidas,
a conexão do websocket requer conexões de cliente criptografadas.

senha
Exigir que a autenticação baseada em senha seja usada para conexões de cliente.

A senha deve ser definida separadamente usando o comando "set_password" no
pcsys_monitor. A sintaxe para alterar sua senha é: "set_password
" Onde pode ser "vnc" ou "tempero".

Se você gostaria de mudar expiração de senha, você deve usar
"expire_password "onde o tempo de expiração pode ser um
das seguintes opções: agora, nunca, + segundos ou tempo de expiração do UNIX, por exemplo
+60 para fazer a senha expirar em 60 segundos, ou 1335196800 para fazer a senha expirar
em "Mon Abr 23 12:00:00 EDT 2012" (hora UNIX para esta data e hora).

Você também pode usar palavras-chave "agora" ou "nunca" para o tempo de expiração para permitir
senha para expirar imediatamente ou nunca expirar.

tls-creds =ID
Fornece o ID de um conjunto de credenciais TLS para usar para proteger o servidor VNC. Elas
se aplicará tanto ao soquete do servidor VNC normal quanto ao soquete do websocket (se
ativado). Definir as credenciais TLS fará com que o soquete do servidor VNC habilite o
Mecanismo de autenticação VeNCrypt. As credenciais deveriam ter sido criadas anteriormente
usando o -objeto tls-creds argumento.

A tls-creds parâmetro torna obsoleto o tls, x509 e x509 verificar opções, e como
portanto, não é permitido definir opções de tipo novas e antigas ao mesmo tempo.

tls Exija que o cliente use TLS ao se comunicar com o servidor VNC. Este usa
credenciais TLS anônimas, portanto, são suscetíveis a um ataque man-in-the-middle. Isto é
recomendado que esta opção seja combinada com o x509 or x509 verificar
opções.

Esta opção agora está obsoleta em favor do uso do tls-creds argumento.

x509 =/ caminho / para / certificado / dir
Válido se tls é especificado. Exigir que as credenciais x509 sejam usadas para negociar
a sessão TLS. O servidor enviará seu certificado x509 ao cliente. Isto é
recomendado que uma senha seja definida no servidor VNC para fornecer autenticação de
o cliente quando isso é usado. O caminho após esta opção especifica onde o
Os certificados x509 devem ser carregados de. Veja o vnc_security seção para detalhes
na geração de certificados.

Esta opção agora está obsoleta em favor do uso do tls-creds argumento.

x509verify =/ caminho / para / certificado / dir
Válido se tls é especificado. Exigir que as credenciais x509 sejam usadas para negociar
a sessão TLS. O servidor enviará seu certificado x509 ao cliente, e
solicitar que o cliente envie seu próprio certificado x509. O servidor irá validar
o certificado do cliente contra o certificado CA, e rejeitar clientes quando
a validação falha. Se a autoridade de certificação for confiável, isso é suficiente
mecanismo de autenticação. Você ainda pode querer definir uma senha no servidor VNC
como uma segunda camada de autenticação. O caminho após esta opção especifica onde
os certificados x509 devem ser carregados. Veja o vnc_security seção para
detalhes sobre a geração de certificados.

Esta opção agora está obsoleta em favor do uso do tls-creds argumento.

atrevido
Exigir que o cliente use SASL para se autenticar no servidor VNC. O exato
a escolha do método de autenticação usado é controlada a partir do SASL do sistema / usuário
arquivo de configuração para o serviço 'qemu'. Isso é normalmente encontrado em
/etc/sasl2/qemu.conf. Se estiver executando o QEMU como um usuário sem privilégios, um ambiente
a variável SASL_CONF_PATH pode ser usada para fazer a pesquisa de locais alternativos para o
configuração do serviço. Embora alguns métodos de autenticação SASL também possam fornecer criptografia de dados (por exemplo,
GSSAPI), é recomendado que SASL seja sempre combinado com 'tls' e 'x509'
configurações para habilitar o uso de SSL e certificados de servidor. Isso garante um dado
criptografia evitando o comprometimento das credenciais de autenticação. Veja o
vnc_security seção para obter detalhes sobre como usar a autenticação SASL.

acl Ative as listas de controle de acesso para verificação do certificado de cliente x509 e SASL
Festa. Para x509 certs, a verificação de ACL é feita em relação ao certificado
Nome Distinto. Isso é algo que parece
"C = GB, O = ACME, L = Boston, CN = bob". Para a parte SASL, a verificação ACL é feita em relação ao
nome de usuário, que dependendo do plugin SASL, pode incluir um componente de domínio, por exemplo
"bob" ou "[email protegido]". Quando o acl sinalizador está definido, a lista de acesso inicial
estará vazio, com uma política de "negação". Assim, ninguém terá permissão para usar o VNC
servidor até que as ACLs tenham sido carregadas. Isso pode ser feito usando o "acl"
comando do monitor.

lossy
Habilite métodos de compactação com perdas (gradiente, JPEG, ...). Se esta opção for definida, VNC
o cliente pode receber atualizações de buffer de frames com perdas, dependendo de suas configurações de codificação.
Habilitar essa opção pode economizar muita largura de banda em detrimento da qualidade.

não adaptativo
Desative as codificações adaptativas. As codificações adaptáveis ​​são ativadas por padrão. Um
a codificação adaptativa tentará detectar regiões de tela atualizadas com frequência e enviar
atualizações nessas regiões usando uma codificação com perdas (como JPEG). Isso pode ser realmente
útil para economizar largura de banda ao reproduzir vídeos. Desativando codificações adaptativas
restaura o comportamento estático original de codificações como Tight.

compartilhar = [permitir-exclusivo | forçar-compartilhado | ignorar]
Defina a política de compartilhamento de tela. 'permitir-exclusivo' permite que os clientes peçam exclusividade
Acesso. Conforme sugerido pela especificação rfb, isso é implementado descartando-se outros
conexões. Conectar vários clientes em paralelo requer que todos os clientes perguntem
para uma sessão compartilhada (vncviewer: -shared switch). Este é o padrão.
'force-shared' desativa o acesso exclusivo do cliente. Útil para área de trabalho compartilhada
sessões, onde você não quer que alguém se esqueça de especificar -shared desconectar
todo mundo. 'ignorar' ignora completamente a sinalização compartilhada e permite que todos
conectar incondicionalmente. Não está em conformidade com a especificação rfb, mas é QEMU tradicional
comportamento.

alvo i386 apenas:

-win2k-hackear
Use-o ao instalar o Windows 2000 para evitar um bug de disco cheio. Depois que o Windows 2000 é
instalado, você não precisa mais desta opção (esta opção retarda as transferências IDE).

-no-fd-bootchk
Desative a verificação de assinatura de inicialização para disquetes no BIOS. Pode ser necessário inicializar de
disquetes antigos.

-não-acpi
Desative o suporte para ACPI (configuração avançada e interface de energia). Use-o se o seu
sistema operacional convidado reclama sobre problemas de ACPI (apenas máquina de destino PC).

-não-hpet
Desative o suporte HPET.

-aceitável [sig =str] [, rev =n] [, oem_id =str] [, oem_table_id =str] [, oem_rev =n]
[, asl_compiler_id =str] [, asl_compiler_rev =n] [, dados =file1[:file2] ...]
Adicione a tabela ACPI com campos de cabeçalho especificados e contexto de arquivos especificados. Para
file =, obtém toda a tabela ACPI dos arquivos especificados, incluindo todos os cabeçalhos ACPI
(possível sobrescrito por outras opções). Para data =, apenas a parte de dados da tabela é
usado, todas as informações do cabeçalho são especificadas na linha de comando.

-smbios arquivo =binário
Carregue a entrada SMBIOS do arquivo binário.

-smbios tipo = 0 [, vendedor =str] [, versão =str] [data =str] [, lançamento =% d.% d] [, uefi = ligado | desligado]
Especifique campos SMBIOS tipo 0

-smbios
tipo = 1 [, fabricante =str] [, produto =str] [, versão =str] [, serial =str] [, uuid =uuid] [, sku =str] [, família =str]
Especifique campos SMBIOS tipo 1

-smbios
tipo = 2 [, fabricante =str] [, produto =str] [, versão =str] [, serial =str] [, ativo =str] [, localização =str] [, família =str]
Especifique campos SMBIOS tipo 2

-smbios tipo = 3 [, fabricante =str] [, versão =str] [, serial =str] [, ativo =str] [, sku =str]
Especifique campos SMBIOS tipo 3

-smbios
tipo = 4 [, sock_pfx =str] [, fabricante =str] [, versão =str] [, serial =str] [, ativo =str] [, parte =str]
Especifique campos SMBIOS tipo 4

-smbios
tipo = 17 [, loc_pfx =str] [, banco =str] [, fabricante =str] [, serial =str] [, ativo =str] [, parte =str] [, velocidade =%d]
Especifique campos SMBIOS tipo 17

Opções de rede:

-internet nic [, vlan =n] [, macaddr =mac] [, modelo =tipo] [, nome =nome] [, addr =addr] [, vetores =v]
Crie uma nova placa de interface de rede e conecte-a à VLAN n (n = 0 é o padrão).
O NIC é um e1000 por padrão no PC de destino. Opcionalmente, o endereço MAC pode ser
alterado para mac, o endereço do dispositivo definido para addr (Apenas placas PCI), e um nome pode ser
atribuído para uso em comandos de monitor. Opcionalmente, para placas PCI, você pode especificar o
número v de vetores MSI-X que o cartão deve ter; esta opção atualmente apenas
afeta os cartões virtio; definir v = 0 para desativar o MSI-X. Se não -internet opção é especificada, um
um único NIC é criado. QEMU pode emular vários modelos diferentes de placa de rede.
Valores válidos para tipo são "virtio", "i82551", "i82557b", "i82559er", "ne2k_pci",
"ne2k_isa", "pcnet", "rtl8139", "e1000", "smc91c111", "lance" e "mcf_fec". De jeito nenhum
dispositivos são suportados em todos os destinos. Use "-net nic, model = help" para uma lista de
dispositivos disponíveis para o seu alvo.

-netdev usuário, id =id[,opção] [,opção] [, ...]
-internet do utilizador[,opção] [,opção] [, ...]
Use a pilha de rede do modo de usuário, que não requer privilégios de administrador para ser executada.
As opções válidas são:

vlan =n
Conecte a pilha do modo de usuário à VLAN n (n = 0 é o padrão).

id =id
nome =nome
Atribua um nome simbólico para uso em comandos do monitor.

net =addr[/máscara]
Defina o endereço de rede IP que o convidado verá. Opcionalmente, especifique a máscara de rede,
na forma abcd ou como o número de bits superiores válidos. O padrão é 10.0.2.0/24.

host =addr
Especifique o endereço do host visível para o convidado. O padrão é o segundo IP no convidado
rede, iexxx2.

restringir = ligado | desligado
Se esta opção for habilitada, o convidado ficará isolado, ou seja, não será capaz de
entre em contato com o host e nenhum pacote de IP de convidado será roteado pelo host para o
lado de fora. Esta opção não afeta as regras de encaminhamento definidas explicitamente.

hostname =nome
Especifica o nome de host do cliente relatado pelo servidor DHCP integrado.

dhcpstart =addr
Especifique o primeiro dos 16 IPs que o servidor DHCP integrado pode atribuir. O padrão é
o 15º ao 31º IP na rede de hóspedes, ou seja, xxx15 a xxx31.

dns =addr
Especifique o endereço visível para o convidado do servidor de nomes virtual. O endereço deve ser
diferente do endereço do host. O padrão é o terceiro IP na rede do convidado, ou seja,
xxx3.

dnssearch =domínio
Fornece uma entrada para a lista de pesquisa de domínio enviada pelo servidor DHCP integrado.
Mais de um sufixo de domínio pode ser transmitido especificando-se esta opção múltipla
vezes. Se houver suporte, isso fará com que o convidado tente automaticamente anexar o
determinado (s) sufixo (s) de domínio, caso um nome de domínio não possa ser resolvido.

Exemplo:

usuário qemu -net, dnssearch = mgmt.example.org, dnssearch = example.org [...]

tftp =dir
Ao usar a pilha de rede do modo de usuário, ative um servidor TFTP embutido. Os arquivos
in dir será exposta como a raiz de um servidor TFTP. O cliente TFTP no convidado
deve ser configurado em modo binário (use o comando "bin" do cliente TFTP Unix).

bootfile =lima
Ao usar a pilha de rede do modo de usuário, transmita lima como o nome do arquivo BOOTP. No
Conjunção com tftp, isso pode ser usado para inicializar pela rede um convidado de um local
diretório.

Exemplo (usando pxelinux):

qemu-system-i386 -hda linux.img -boot n -net usuário, tftp = / caminho / para / tftp / arquivos, bootfile = / pxelinux.0

smb =dir[, smbserver =addr]
Ao usar a pilha de rede do modo de usuário, ative um servidor SMB integrado para que
Os sistemas operacionais Windows podem acessar os arquivos do host em dir de forma transparente. O endereço IP de
o servidor SMB pode ser configurado para addr. Por padrão, o 4º IP na rede do convidado é
usado, iexxx4.

No sistema operacional Windows convidado, a linha:

10.0.2.4 servidor smb

deve ser adicionado ao arquivo C: \ WINDOWS \ LMHOSTS (para Windows 9x / Me) ou
C: \ WINNT \ SYSTEM32 \ DRIVERS \ ETC \ LMHOSTS (Windows NT / 2000).

Então dir pode ser acessado em \ smbserver \ qemu.

Observe que um servidor SAMBA deve ser instalado no sistema operacional host. QEMU foi testado
com sucesso com as versões smbd do Red Hat 9, Fedora Core 3 e OpenSUSE 11.x.

hostfwd = [tcp | udp]: [hostaddr]:porto de acolhimento-[endereço de convidado]:Guestport
Redirecionar conexões TCP ou UDP de entrada para a porta do host porto de acolhimento para o IP do convidado
endereço endereço de convidado no porto convidado Guestport. Se endereço de convidado não é especificado, é
o valor é xxx15 (primeiro endereço padrão fornecido pelo servidor DHCP integrado). Por
especificando hostaddr, a regra pode ser vinculada a uma interface de host específica. Se não
tipo de conexão é definido, TCP é usado. Esta opção pode ser fornecida várias vezes.

Por exemplo, para redirecionar a conexão do host X11 da tela 1 para a tela do convidado 0, use
o seguinte:

# no host
usuário qemu-system-i386 -net, hostfwd = tcp: 127.0.0.1: 6001-: 6000 [...]
# este host xterm deve abrir no servidor convidado X11
xterm -display: 1

Para redirecionar as conexões telnet da porta do host 5555 para a porta telnet no convidado,
use o seguinte:

# no host
usuário qemu-system-i386 -net, hostfwd = tcp :: 5555-: 23 [...]
host local telnet 5555

Então, quando você usa no host "telnet localhost 5555", você se conecta ao convidado
servidor telnet.

guestfwd = [tcp]:servidor:porta-dev
guestfwd = [tcp]:servidor:porta-cmd: comando
Encaminhe conexões TCP de hóspedes para o endereço IP servidor no porto porta ao
dispositivo de personagem dev ou para um programa executado por cmd: comando que é gerado
para cada conexão. Esta opção pode ser fornecida várias vezes.

Você pode usar um chardev diretamente e ter aquele usado em todo o QEMU
vida, como no exemplo a seguir:

# open 10.10.1.1:4321 na inicialização, conecte 10.0.2.100:1234 a ele sempre
# o convidado acessa
usuário qemu -net, guestfwd = tcp: 10.0.2.100: 1234-tcp: 10.10.1.1: 4321 [...]

Ou você pode executar um comando em cada conexão TCP estabelecida pelo convidado, para
que QEMU se comporta de forma semelhante a um processo inetd para esse servidor virtual:

# chamar "netcat 10.10.1.1 4321" em cada conexão TCP para 10.0.2.100:1234
# e conecte o fluxo TCP ao seu stdin / stdout
usuário qemu -net ', guestfwd = tcp: 10.0.2.100: 1234-cmd: netcat 10.10.1.1 4321'

Nota: As opções autônomas legadas -tftp, -bootp, -smb e -redir ainda são processadas
e aplicado ao usuário -net. Misturá-los com a nova sintaxe de configuração dá
resultados indefinidos. Seu uso para novos aplicativos é desencorajado, pois será
removido de versões futuras.

-netdev torneira, id =id[, fd =h] [, ifname =nome] [, script =lima] [, downscript =arquivo d] [, ajudante =ajudante]
-internet
toque [, vlan =n] [, nome =nome] [, fd =h] [, ifname =nome] [, script =lima] [, downscript =arquivo d] [, ajudante =ajudante]
Conecte a interface de rede TAP do host nome para VLAN n.

Use o script de rede lima para configurá-lo e o script de rede arquivo d para
desconfigure. Se nome não for fornecido, o sistema operacional fornece um automaticamente. o
o script de configuração de rede padrão é / etc / qemu-ifup e a desconfiguração da rede padrão
script é / etc / qemu-ifdown. Usar script = não or downscript = não desabilitar o script
execução.

Se estiver executando o QEMU como um usuário sem privilégios, use o auxiliar de rede ajudante para configurar
a interface TAP. O executável auxiliar de rede padrão é
/ caminho / para / qemu-bridge-helper.

fd=h pode ser usado para especificar o identificador de uma interface TAP do host já aberta.

Exemplos:

# iniciar uma instância QEMU com o script de rede padrão
qemu-system-i386 linux.img -net nic -net tap

# iniciar uma instância QEMU com duas NICs, cada uma conectada
#para um dispositivo TAP
qemu-system-i386 linux.img\
-net nic, vlan = 0 -net tap, vlan = 0, ifname = tap0 \
-net nic, vlan = 1 -net tap, vlan = 1, ifname = tap1

# iniciar uma instância QEMU com o auxiliar de rede padrão para
#conecte um dispositivo TAP para fazer a ponte br0
qemu-system-i386 linux.img\
-net nic -net tap, "helper = / path / to / qemu-bridge-helper"

-netdev ponte, id =id[, br =ponte] [, ajudante =ajudante]
-internet ponte [, vlan =n] [, nome =nome] [, br =ponte] [, ajudante =ajudante]
Conecte uma interface de rede TAP de host a um dispositivo de ponte de host.

Use o ajudante de rede ajudante para configurar a interface TAP e anexá-la ao
Ponte. O executável auxiliar de rede padrão é / caminho / para / qemu-bridge-helper e os votos de
dispositivo de ponte padrão é br0.

Exemplos:

# iniciar uma instância QEMU com o auxiliar de rede padrão para
#conecte um dispositivo TAP para fazer a ponte br0
qemu-system-i386 linux.img -net bridge -net nic, model = virtio

# iniciar uma instância QEMU com o auxiliar de rede padrão para
#conecte um dispositivo TAP para fazer a ponte qemubr0
qemu-system-i386 linux.img -net bridge, br = qemubr0 -net nic, model = virtio

-netdev socket, id =id[, fd =h] [, ouvir = [hospedeiro]:porta] [, conectar =hospedeiro:porta]
-internet soquete [, vlan =n] [, nome =nome] [, fd =h] [, ouvir = [hospedeiro]:porta] [, conectar =hospedeiro:porta]
Conecte a VLAN n para uma VLAN remota em outra máquina virtual QEMU usando um soquete TCP
conexão. Se ouço for especificado, o QEMU espera por conexões de entrada em porta (hospedeiro
é opcional). connect é usado para se conectar a outra instância QEMU usando o ouço
opção. fd=h especifica um socket TCP já aberto.

Exemplo:

# iniciar uma primeira instância QEMU
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:56 \
soquete -net, ouvir =: 1234
# conecte a VLAN 0 desta instância à VLAN 0
# da primeira instância
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:57 \
soquete -net, conectar = 127.0.0.1: 1234

-netdev socket, id =id[, fd =h] [, mcast =madr:porta[, localaddr =addr]]
-internet soquete [, vlan =n] [, nome =nome] [, fd =h] [, mcast =madr:porta[, localaddr =addr]]
Crie uma VLAN n compartilhado com outras máquinas virtuais QEMU usando um multicast UDP
socket, efetivamente criando um barramento para cada QEMU com o mesmo endereço multicast madr e
porta. NOTAS:

1. Vários QEMU podem estar em execução em hosts diferentes e compartilhar o mesmo barramento (assumindo
configuração multicast correta para esses hosts).

2. O suporte a mcast é compatível com o modo de usuário Linux (argumento ethN= mcast), Vejo
<http://user-mode-linux.sf.net>.

3. Usar fd = h para especificar um socket multicast UDP já aberto.

Exemplo:

# iniciar uma instância QEMU
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:56 \
-net socket, mcast = 230.0.0.1: 1234
# iniciar outra instância QEMU no mesmo "barramento"
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:57 \
-net socket, mcast = 230.0.0.1: 1234
# lançar outra instância QEMU no mesmo "ônibus"
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:58 \
-net socket, mcast = 230.0.0.1: 1234

Exemplo (modo de usuário compatível com Linux):

# iniciar instância QEMU (observe o endereço mcast selecionado
# é o padrão da UML)
qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:56 \
-net socket, mcast = 239.192.168.1: 1102
# lançar UML
/ caminho / para / linux ubd0 = / caminho / para / root_fs eth0 = mcast

Exemplo (enviar pacotes do host 1.2.3.4):

qemu-system-i386 linux.img\
-net nic,macaddr=52:54:00:12:34:56 \
-net socket, mcast = 239.192.168.1: 1102, localaddr = 1.2.3.4

-netdev
l2tpv3, id =id, src =srcddr, dst =dstaddr[, srcport =relatório de origem] [, dstport =dstport], txsession =sessão de txsessão[, rxsession =rxsessão] [, ipv6] [, udp] [, cookie64] [, contador] [, pincounter] [, txcookie =txcookie] [, rxcookie =rxcookie] [, deslocamento =compensar]
-internet
l2tpv3 [, vlan =n] [, nome =nome], src =srcddr, dst =dstaddr[, srcport =relatório de origem] [, dstport =dstport], txsession =sessão de txsessão[, rxsession =rxsessão] [, ipv6] [, udp] [, cookie64] [, contador] [, pincounter] [, txcookie =txcookie] [, rxcookie =rxcookie] [, deslocamento =compensar]
Conectar VLAN n para L2TPv3 pseudowire. L2TPv3 (RFC3391) é um protocolo popular para
transportar quadros de dados Ethernet (e outra camada 2) entre dois sistemas. Está presente
em roteadores, firewalls e kernel do Linux (da versão 3.3 em diante).

Este transporte permite que uma VM se comunique com outra VM, roteador ou firewall diretamente.

src =srcddr
endereço de origem (obrigatório)

dst =dstaddr
endereço de destino (obrigatório)

udp selecione o encapsulamento udp (o padrão é ip).

srcport =relatório de origem
porta udp de origem.

dstport =dstport
porta udp de destino.

ipv6
forçar v6, caso contrário, o padrão é v4.

rxcookie =rxcookie
txcookie =txcookie
Os cookies são uma forma fraca de segurança na especificação l2tpv3. A função deles é
principalmente para evitar configurações incorretas. Por padrão, eles são de 32 bits.

cookie64
Defina o tamanho do cookie para 64 bits em vez do padrão de 32

counter = off
Forçar um 'corte' L2TPv3 sem contador como em
rascunho-mkonstan-l2tpext-keyed-ipv6-tunnel-00

pincounter = on
Contorne o controle do contador quebrado no par. Isso também pode ajudar em redes que têm
reordenar pacotes.

deslocamento =compensar
Adicione um deslocamento extra entre o cabeçalho e os dados

Por exemplo, para anexar uma VM em execução no host 4.3.2.1 via L2TPv3 à ponte br-lan
o host Linux remoto 1.2.3.4:

# Configure o túnel no host linux usando ip bruto como encapsulamento
# em 1.2.3.4
ip l2tp adicionar túnel remoto 4.3.2.1 local 1.2.3.4 tunnel_id 1 peer_tunnel_id 1 \
encap udp udp_sport 16384 udp_dport 16384
ip l2tp adicionar sessão tunnel_id 1 nome vmtunnel0 session_id \
0xFFFFFFFF peer_session_id 0xFFFFFFFF
ifconfig vmtunnel0 mtu 1500
ifconfig vmtunnel0 ativo
brctl addif br-lan vmtunnel0

# em 4.3.2.1
# iniciar a instância QEMU - se sua rede tiver reordenado ou estiver com muitas perdas, adicione um contador

qemu-system-i386 linux.img -net nic -net l2tpv3, src = 4.2.3.1, dst = 1.2.3.4, udp, srcport = 16384, dstport = 16384, rxsession = 0xffffffff, txsession = 0xffffffff, contador

-netdev vde, id =id[, meia =caminho do soquete] [, porta =n] [, grupo =nome do grupo] [, modo =octalmodo]
-internet vde [, vlan =n] [, nome =nome] [, meia =caminho do soquete]
[, porta =n] [, grupo =nome do grupo] [, modo =octalmodo]
Conectar VLAN n para PORT n de um switch vde rodando no host e ouvindo a entrada
conexões em caminho do soquete. Use o GRUPO nome do grupo e MODE octalmodo mudar o padrão
propriedade e permissões para porta de comunicação. Esta opção só está disponível se
QEMU foi compilado com suporte a vde habilitado.

Exemplo:

# iniciar switch vde
vde_switch -F -sock / tmp / myswitch
# iniciar instância QEMU
qemu-system-i386 linux.img -net nic -net vde, sock = / tmp / myswitch

-netdev hubport, id =id, hubid =hubid
Crie uma porta de hub no QEMU "vlan" hubid.

O hubport netdev permite conectar um NIC a um QEMU "vlan" em vez de um único netdev.
"-net" e "-device" com parâmetro vlan crie o hub necessário automaticamente.

-netdev vhost-user, chardev =id[, vhostforce = on | off] [, filas = n]
Estabelecer um netdev vhost-user, apoiado por um chardev id. O chardev deve ser um unix
soquete de domínio apoiado um. O usuário vhost usa um protocolo especificamente definido para passar
Mensagens de substituição de vhost ioctl para um aplicativo na outra extremidade do soquete. Sobre
convidados não MSIX, o recurso pode ser forçado com vhostforce. Use 'filas =n' especificar
o número de filas a serem criadas para vhost-user multiqueue.

Exemplo:

qemu -m 512 -object memory-backend-file, id = mem, size = 512M, mem-path = / hugetlbfs, share = on \
-numa node, memdev = mem \
-chardev socket, path = / path / to / socket \
-netdev type = vhost-user, id = net0, chardev = chr0 \
-dispositivo virtio-net-pci, netdev = net0

-internet despejar [, vlan =n] [, arquivo =lima] [, len =len]
Despejar o tráfego de rede na VLAN n arquivar lima (qemu-vlan0.pcap por padrão). No máximo len
bytes (64k por padrão) por pacote são armazenados. O formato do arquivo é libpcap, então pode ser
analisado com ferramentas como tcpdump ou Wireshark. Nota: Para dispositivos criados com
'-netdev', use '-object filter-dump, ...' em vez disso.

-internet Nenhum
Indique que nenhum dispositivo de rede deve ser configurado. É usado para substituir o
configuração padrão (-internet nic -internet usuário) que é ativado se não -internet opções são
forneceu.

Opções de dispositivo de personagem:

A forma geral de uma opção de dispositivo de caractere é:

-chardev backend , id =id [, mux = ligado | desligado] [,opções]
O back-end é um dos seguintes: nulo, soquete, udp, msmouse, vc, Ringbuf, lima, tubo, consolá,
serial, pty, stdio, braille, tty, paralelo, estacionamento, Spicevmc. Spiceport. O
back-end específico determinará as opções aplicáveis.

Todos os dispositivos devem ter um id, que pode ser qualquer string de até 127 caracteres. Isto é
usado para identificar exclusivamente este dispositivo em outras diretivas de linha de comando.

Um dispositivo de caractere pode ser usado no modo de multiplexação por vários front-ends. A chave
sequência de Controle-a e c irá girar o foco de entrada entre front-ends anexados.
Especificar mux = on para habilitar este modo.

As opções para cada back-end são descritas abaixo.

-chardev nulo , id =id
Um dispositivo vazio. Este dispositivo não emitirá nenhum dado e descartará todos os dados que receber.
O back-end nulo não tem opções.

-chardev soquete , id =id [TCP opções or unix opções] [,servidor] [, agora mesmo] [telnet]
[, reconectar =segundo]
Crie um soquete de fluxo bidirecional, que pode ser um soquete TCP ou Unix. Um unix
socket será criado se caminho é especificado. O comportamento é indefinido se as opções de TCP forem
especificado para um soquete Unix.

servidor especifica que o soquete deve ser um soquete de escuta.

nowait especifica que o QEMU não deve bloquear a espera de um cliente para se conectar a um
tomada de escuta.

telnet especifica que o tráfego no soquete deve interpretar as sequências de escape telnet.

reconectar define o tempo limite para reconexão em soquetes não-servidor quando o fim remoto
vai embora. qemu irá atrasar esses vários segundos e, em seguida, tentará se reconectar. Zero
desativa a reconexão e é o padrão.

As opções de soquete TCP e Unix são fornecidas abaixo:

TCP opções: porta =porta [, host =hospedeiro] [, para =para] [, ipv4] [, ipv6] [, nodelay]
hospedeiro para um soquete de escuta especifica o endereço local a ser vinculado. Para
conectar espécies de soquete o host remoto para se conectar. hospedeiro é opcional para
tomadas de escuta. Se não for especificado, o padrão é 0.0.0.0.

porta para um soquete de escuta especifica a porta local a ser ligada. Para uma conexão
socket especifica a porta no host remoto para se conectar. porta pode ser dado como
um número de porta ou um nome de serviço. porta É necessário.

para só é relevante para soquetes de escuta. Se for especificado, e porta não pode ser
vinculado, o QEMU tentará se vincular às portas subsequentes até e incluindo para até
é bem-sucedido. para deve ser especificado como um número de porta.

ipv4 e ipv6 especifique que deve ser usado IPv4 ou IPv6. Se nenhum dos dois for
especificado, o soquete pode usar qualquer um dos protocolos.

atraso de nó desativa o algoritmo de Nagle.

unix opções: caminho =caminho
caminho especifica o caminho local do socket unix. caminho É necessário.

-chardev udp , id =id [, host =hospedeiro] , porta =porta [, localaddr =endereço local] [, localport =porto local]
[, ipv4] [, ipv6]
Envia todo o tráfego do convidado para um host remoto por UDP.

hospedeiro especifica o host remoto ao qual se conectar. Se não for especificado, o padrão é
"localhost".

porta especifica a porta no host remoto para se conectar. porta É necessário.

endereço local especifica o endereço local ao qual se associar. Se não for especificado, o padrão é
0.0.0.0.

porto local especifica a porta local à qual se conectar. Se não for especificado nenhum local disponível
porta será usada.

ipv4 e ipv6 especifique que deve ser usado IPv4 ou IPv6. Se nenhum for especificado
o dispositivo pode usar qualquer um dos protocolos.

-chardev msmouse , id =id
Encaminhe eventos msmouse emulados do QEMU para o convidado. msmouse não leva nenhum
opções.

-chardev vc , id =id [[, largura =largura] [altura =altura]] [[, cols =cols] [, linhas =linhas]]
Conecte-se a um console de texto QEMU. vc pode opcionalmente ter um tamanho específico.

largura e altura especifique a largura e a altura respectivamente do console, em pixels.

cols e linhas especificar que o console seja dimensionado para caber em um console de texto com o dado
dimensões.

-chardev Ringbuf , id =id [, tamanho =tamanho]
Crie um buffer de anel com tamanho fixo tamanho. tamanho deve ser uma potência de dois, e os padrões
para "64K").

-chardev lima , id =id , caminho =caminho
Registre todo o tráfego recebido do convidado em um arquivo.

caminho especifica o caminho do arquivo a ser aberto. Este arquivo será criado se isso acontecer
ainda não existe e sobrescrito, se existir. caminho É necessário.

-chardev tubo , id =id , caminho =caminho
Crie uma conexão bidirecional com o convidado. O comportamento difere ligeiramente entre
Hosts Windows e outros hosts:

No Windows, um único tubo duplex será criado em \.tubo\caminho.

Em outros hosts, 2 canais serão criados chamados caminho. No e caminho.Fora. Dados gravados em
caminho. No será recebido pelo hóspede. Os dados gravados pelo convidado podem ser lidos de
caminho.Fora. O QEMU não criará esses fifos e exige que eles estejam presentes.

caminho faz parte do trajeto do tubo conforme descrito acima. caminho É necessário.

-chardev consolá , id =id
Envie o tráfego do convidado para a saída padrão do QEMU. consolá não leva nenhum
opções.

consolá só está disponível em hosts Windows.

-chardev serial , id =id , caminho = caminho
Envie o tráfego do convidado para um dispositivo serial no host.

Em hosts Unix, o serial realmente aceita qualquer dispositivo tty, não apenas linhas seriais.

caminho especifica o nome do dispositivo serial a ser aberto.

-chardev pty , id =id
Crie um novo pseudo-terminal no host e conecte-se a ele. pty não leva nenhum
opções.

pty não está disponível em hosts Windows.

-chardev stdio , id =id [, sinal = ligado | desligado]
Conecte a entrada e saída padrão do processo QEMU.

sinal controla se os sinais estão habilitados no terminal, que inclui a saída do QEMU
com a sequência chave Controle-c. Esta opção é habilitada por padrão, use sinal = desligado para
desative-o.

stdio não está disponível em hosts Windows.

-chardev braille , id =id
Conecte-se a um servidor BrlAPI local. braille não leva nenhuma opção.

-chardev tty , id =id , caminho =caminho
tty está disponível apenas em hosts Linux, Sun, FreeBSD, NetBSD, OpenBSD e DragonFlyBSD.
É um apelido para serial.

caminho especifica o caminho para o tty. caminho É necessário.

-chardev paralelo , id =id , caminho =caminho
-chardev estacionamento , id =id , caminho =caminho
paralelo está disponível apenas em hosts Linux, FreeBSD e DragonFlyBSD.

Conecte-se a uma porta paralela local.

caminho especifica o caminho para o dispositivo de porta paralela. caminho É necessário.

-chardev Spicevmc , id =id , debug =depurar, nome =nome
Spicevmc só está disponível quando o suporte a especiarias está integrado.

depurar nível de depuração para spicevmc

nome nome do canal de especiarias para se conectar

Conecte-se a um canal de máquina virtual Spice, como vdiport.

-chardev Spiceport , id =id , debug =depurar, nome =nome
Spiceport só está disponível quando o suporte a especiarias está integrado.

depurar nível de depuração para spicevmc

nome nome da porta do Spice para se conectar

Conecte-se a uma porta Spice, permitindo que um cliente Spice controle o tráfego identificado por um
nome (de preferência um fqdn).

Sintaxe do URL do dispositivo:

Além de usar imagens de arquivo normais para os dispositivos de armazenamento emulados, o QEMU também pode
usar recursos de rede, como dispositivos iSCSI. Eles são especificados usando um URL especial
sintaxe.

iSCSI
O suporte iSCSI permite que o QEMU acesse recursos iSCSI diretamente e use como imagens para o
armazenamento de hóspedes. Imagens de disco e cdrom são suportadas.

A sintaxe para especificar iSCSI LUNs é "iscsi: // [: ] / / "

Por padrão, o qemu usará o nome de iniciador iSCSI 'iqn.2008-11.org.linux-kvm [: ] '
mas isso também pode ser definido na linha de comando ou em um arquivo de configuração.

Desde a versão Qemu 2.4, é possível especificar um tempo limite de solicitação iSCSI para detectar
pedidos paralisados ​​e forçar o restabelecimento da sessão. O tempo limite é especificado
em segundos. O padrão é 0, o que significa que não há tempo limite. Libiscsi 1.15.0 ou superior é
necessário para este recurso.

Exemplo (sem autenticação):

qemu-sistema-i386 -iscsi nome-do-iniciador = iqn.2001-04.com.exemplo: meu-iniciador \
-cdrom iscsi: //192.0.2.1/iqn.2001-04.com.example/2 \
-drive file = iscsi: //192.0.2.1/iqn.2001-04.com.example/1

Exemplo (nome de usuário / senha CHAP via URL):

qemu-system-i386 -drive file = iscsi: // user%[email protegido]/iqn.2001-04.com.example/1

Exemplo (nome de usuário / senha CHAP por meio de variáveis ​​de ambiente):

LIBISCSI_CHAP_USERNAME = "usuário" \
LIBISCSI_CHAP_PASSWORD = "senha" \
qemu-system-i386 -drive file=iscsi://192.0.2.1/iqn.2001-04.com.example/1

O suporte iSCSI é um recurso opcional do QEMU e só está disponível quando compilado e
vinculado ao libiscsi.

Os parâmetros iSCSI, como nome de usuário e senha, também podem ser especificados por meio de um
arquivo de configuração. Consulte qemu-doc para obter mais informações e exemplos.

NBD QEMU oferece suporte a NBD (dispositivos de bloco de rede), tanto usando o protocolo TCP quanto o Unix
Sockets de domínio.

Sintaxe para especificar um dispositivo NBD usando TCP
"nbd: : [: exportname = ] "

Sintaxe para especificar um dispositivo NBD usando Unix Domain Sockets
"nbd: unix: [: exportname = ] "

Exemplo para TCP

qemu-system-i386 --drive file = nbd: 192.0.2.1: 30000

Exemplo para Sockets de Domínio Unix

qemu-system-i386 --drive file = nbd: unix: / tmp / nbd-socket

SSH O QEMU oferece suporte ao acesso SSH (Secure Shell) a discos remotos.

Exemplos:

qemu-system-i386 -drive file = ssh: //user@host/path/to/disk.img
qemu-system-i386 -drive file.driver = ssh, file.user = user, file.host = host, file.port = 22, file.path = / path / to / disk.img

Atualmente, a autenticação deve ser feita usando o agente ssh. Outros métodos de autenticação
pode ser suportado no futuro.

Cão de guarda
Sheepdog é um sistema de armazenamento distribuído para QEMU. O QEMU suporta o uso de
dispositivos sheepdog ou dispositivos remotos em rede.

Sintaxe para especificar um dispositivo cão pastor

cão pastor [+ tcp | + unix]: // [host: porta] / vdiname [? socket = path] [#snapid | #tag]

Exemplo

qemu-system-i386 --drive file = sheepdog: //192.0.2.1: 30000 / MyVirtualMachine

Veja tambémhttp://http: //www.osrg.net/sheepdog/>.

GlusterFS
GlusterFS é um sistema de arquivos distribuído no espaço do usuário. QEMU suporta o uso de
Volumes GlusterFS para hospedar imagens de disco VM usando TCP, Unix Domain Sockets e RDMA
protocolos de transporte.

A sintaxe para especificar uma imagem de disco VM no volume GlusterFS é

gluster [+ transporte]: // [servidor [: porta]] / nome do volume / imagem [? socket = ...]

Exemplo

qemu-system-x86_64 --drive file = gluster: //192.0.2.1/testvol/a.img

Veja tambémhttp://www.gluster.org>.

HTTP / HTTPS / FTP / FTPS / TFTP
O QEMU suporta acesso somente leitura a arquivos acessados ​​por http (s), ftp (s) e tftp.

Sintaxe usando um único nome de arquivo:

: // [ [: ] @] /

em que:

protocolo
'http', 'https', 'ftp', 'ftps' ou 'tftp'.

nome de usuário
Nome de usuário opcional para autenticação no servidor remoto.

senha
Senha opcional para autenticação no servidor remoto.

hospedeiro
Endereço do servidor remoto.

caminho
Caminho no servidor remoto, incluindo qualquer string de consulta.

As seguintes opções também são suportadas:

url O URL completo ao passar opções para o driver explicitamente.

Leia adiante
A quantidade de dados a serem lidos adiante com cada solicitação de intervalo para o servidor remoto.
Este valor pode opcionalmente ter o sufixo 'T', 'G', 'M', 'K', 'k' ou 'b'. Se isso
não tiver um sufixo, será considerado em bytes. O valor deve ser um
múltiplo de 512 bytes. O padrão é 256k.

verificar
Se deve verificar o certificado do servidor remoto ao conectar-se por SSL. Pode
têm o valor 'on' ou 'off'. O padrão é 'ligado'.

biscoito
Envie este cookie (também pode ser uma lista de cookies separados por ';') com cada
solicitação de saída. Suportado apenas ao usar protocolos como HTTP que suportam
cookies, caso contrário, ignorados.

tempo limite
Defina o tempo limite em segundos da conexão CURL. Este tempo limite é o tempo que
CURL espera por uma resposta do servidor remoto para obter o tamanho da imagem para
ser baixado. Se não for definido, o tempo limite padrão de 5 segundos será usado.

Observe que ao passar opções para qemu explicitamente, motorista é o valor de .

Exemplo: inicialize a partir de uma imagem ISO live Fedora 20 remota

qemu-system-x86_64 --drive media = cdrom, file =http://dl.fedoraproject.org/pub/fedora/linux/releases/20/Live/x86_64/Fedora-Live-Desktop-x86_64-20-1.iso,somente leitura

qemu-system-x86_64 --drive media = cdrom, file.driver = http, file.url =http://dl.fedoraproject.org/pub/fedora/linux/releases/20/Live/x86_64/Fedora-Live-Desktop-x86_64-20-1.iso,somente leitura

Exemplo: inicialize de uma imagem de nuvem remota do Fedora 20 usando uma sobreposição local para gravações,
cópia na leitura e uma leitura à frente de 64k

qemu-img create -f qcow2 -o backing_file = 'json: {"file.driver": "http" ,, "file.url": "https://dl.fedoraproject.org/pub/fedora/linux/releases /20/Images/x86_64/Fedora-x86_64-20-20131211.1-sda.qcow2 ",," file.readahead ":" 64k "} '/tmp/Fedora-x86_64-20-20131211.1-sda.qcow2

qemu-system-x86_64 -drive file=/tmp/Fedora-x86_64-20-20131211.1-sda.qcow2,copy-on-read=on

Exemplo: inicialize a partir de uma imagem armazenada em um servidor VMware vSphere com um autoassinado
certificado usando uma sobreposição local para gravações, uma leitura à frente de 64k e um tempo limite de 10
segundos.

qemu-img create -f qcow2 -o backing_file = 'json: {"file.driver": "https" ,, "file.url": "https: // usuário:[email protegido]/folder/test/test-flat.vmdk?dcPath=Datacenter&dsName=datastore1 ",," file.sslverify ":" off ",," file.readahead ":" 64k ",," file.timeout ": 10} ' /tmp/test.qcow2

qemu-system-x86_64 -drive file = / tmp / test.qcow2

Opções de Bluetooth (R):

-bt hci [...]
Define a função do Bluetooth HCI correspondente. -bt opções são combinadas com
os HCIs presentes no tipo de máquina escolhido. Por exemplo, ao emular uma máquina
com apenas um HCI integrado, apenas a primeira opção "-bt hci" é [...] válida e
define a lógica do HCI. A camada de transporte é decidida pelo tipo de máquina.
Atualmente as máquinas "n800" e "n810" possuem um HCI e todas as outras máquinas possuem
Nenhum.

Os três tipos a seguir são reconhecidos:

-bt hci, null
(padrão) O Bluetooth HCI correspondente não assume nenhuma lógica interna e não irá
responder a quaisquer comandos HCI ou emitir eventos.

-bt hci, host [:id]
("bluez" apenas) O HCI correspondente passa comandos / eventos de / para o
HCI físico identificado pelo nome id (padrão: "hci0") no computador em execução
QEMU. Disponível apenas em sistemas compatíveis com "bluez" como Linux.

-bt hci [, vlan =n]
Adicione um HCI padrão virtual que participará da scatternet Bluetooth n
(padrão 0). similarmente a -internet VLANs, dispositivos dentro de uma rede bluetooth n pode
comunicar-se apenas com outros dispositivos na mesma rede (scatternet).

-bt vhci [, vlan =n]
(Linux-host apenas) Crie um HCI na scatternet n (padrão 0) anexado ao host
pilha bluetooth em vez de para o alvo emulado. Isso permite que o host e o destino
máquinas para participar de uma scatternet comum e se comunicar. Requer o Linux
Driver "vhci" instalado. Pode ser usado da seguinte forma:

qemu-system-i386 [... OPÇÕES ...] -bt hci, vlan = 5 -bt vhci, vlan = 5

-bt dispositivo:dev[, vlan =n]
Emular um dispositivo bluetooth dev e colocá-lo na rede n (padrão 0). QEMU só pode
emular um tipo de dispositivo bluetooth atualmente:

teclado
Teclado sem fio virtual implementando o perfil bluetooth HIDP.

Opções de dispositivo TPM:

A forma geral de uma opção de dispositivo TPM é:

-tpmdev backend , id =id [,opções]
O tipo de back-end deve ser: atravessar.

O tipo de back-end específico determinará as opções aplicáveis. A opção "-tpmdev"
cria o back-end TPM e requer uma opção "-device" que especifica o TPM
modelo de interface de frontend.

As opções para cada back-end são descritas abaixo.

Use 'ajuda' para imprimir todos os tipos de back-end TPM disponíveis.

qemu -tpmdev ajuda

-tpmdev atravessar, id =id, caminho =caminho, cancel-path =cancelar caminho
(Linux-host apenas) Habilite o acesso ao TPM do host usando o driver de passagem.

caminho especifica o caminho para o dispositivo TPM do host, ou seja, em um host Linux, isso seria
"/ dev / tpm0". caminho é opcional e por padrão "/ dev / tpm0" é usado.

cancelar caminho especifica o caminho para a entrada sysfs do dispositivo TPM host, permitindo
cancelamento de um comando TPM em andamento. cancelar caminho é opcional e por padrão QEMU
irá procurar a entrada sysfs para usar.

Algumas notas sobre o uso do TPM do host com o driver de passagem:

O dispositivo TPM acessado pelo driver de passagem não deve ser usado por qualquer outro
aplicativo no host.

Como o firmware do host (BIOS / UEFI) já inicializou o TPM, o VM
firmware (BIOS / UEFI) não será capaz de inicializar o TPM novamente e pode, portanto,
não mostrar um menu específico do TPM que, de outra forma, permitiria ao usuário configurar o TPM,
por exemplo, permitir que o usuário ative / desative ou ative / desative o TPM. Além disso, se
A propriedade do TPM é liberada de dentro de uma VM, então o TPM do host será desabilitado e
desativado. Para habilitar e ativar o TPM novamente depois, o host deve ser
reiniciado e o usuário é obrigado a entrar no menu do firmware para habilitar e ativar
o TPM. Se o TPM for deixado desabilitado e / ou desativado, a maioria dos comandos do TPM falhará.

Para criar um TPM de passagem, use as duas opções a seguir:

-tpmdev passthrough, id = tpm0 -device tpm-tis, tpmdev = tpm0

Observe que o id "-tpmdev" é "tpm0" e é referenciado por "tpmdev = tpm0" no dispositivo
opção.

Específico para inicialização do Linux / Multiboot:

Ao usar essas opções, você pode usar um determinado kernel Linux ou Multiboot sem instalar
na imagem do disco. Pode ser útil para testar mais facilmente vários kernels.

-núcleo bzImagem
Use bzImagem como imagem do kernel. O kernel pode ser um kernel Linux ou em inicialização múltipla
formato.

-acrescentar cmdline
Use cmdline como linha de comando do kernel

-initrd lima
Use lima como disco ram inicial.

-initrd "file1 arg = foo,file2"
Esta sintaxe está disponível apenas com inicialização múltipla.

Use file1 e file2 como módulos e passe arg = foo como parâmetro para o primeiro módulo.

-dtb lima
Use lima como uma imagem binária da árvore de dispositivos (dtb) e passá-la para o kernel na inicialização.

Opções de depuração / especialista:

-fw_cfg [nome =]nome, arquivo =lima
Adicione a entrada fw_cfg nomeada do arquivo. nome determina o nome da entrada no fw_cfg
diretório de arquivo exposto ao convidado.

-fw_cfg [nome =]nome, string =str
Adicione a entrada fw_cfg nomeada da string.

-serial dev
Redirecione a porta serial virtual para hospedar o dispositivo de caractere dev. O dispositivo padrão é
"vc" no modo gráfico e "stdio" no modo não gráfico.

Esta opção pode ser usada várias vezes para simular até 4 portas seriais.

Use "-serial none" para desabilitar todas as portas seriais.

Os dispositivos de caracteres disponíveis são:

vc [:WxH]
Console virtual. Opcionalmente, uma largura e altura podem ser fornecidas em pixel com

vc: 800x600

Também é possível especificar a largura ou altura em caracteres:

vc: 80Cx24C

pty [Linux apenas] Pseudo TTY (um novo PTY é alocado automaticamente)

Nenhum
Nenhum dispositivo está alocado.

nulo
dispositivo vazio

Chardev:id
Use um dispositivo de caractere nomeado definido com a opção "-chardev".

/ dev / XXX
[Somente Linux] Use host tty, por exemplo / dev / ttyS0. Os parâmetros da porta serial do host são
definido de acordo com os emulados.

/ dev / parportN
[Linux apenas, porta paralela apenas] Use a porta paralela do host N. Atualmente SPP e EPP
os recursos da porta paralela podem ser usados.

arquivo:nome do arquivo
Grave a saída para nome do arquivo. Nenhum personagem pode ser lido.

stdio
[Unix apenas] entrada / saída padrão

tubo:nome do arquivo
tubo de nome nome do arquivo

COMn
[Somente Windows] Use a porta serial do host n

udp: [hospedeiro remoto]:porta_remoto[@ [src_ip]:porta_src]
Isso implementa o console de rede UDP. Quando hospedeiro remoto or src_ip não são especificados
o padrão é 0.0.0.0. Quando não estiver usando um especificado porta_src uma porta aleatória é
escolhido automaticamente.

Se você quiser apenas um console simples de leitura, pode usar "netcat" ou "nc", por
iniciando o QEMU com: "-serial udp :: 4555" e nc como: "nc -u -l -p 4555". A qualquer momento
O QEMU grava algo nessa porta que aparecerá na sessão do netconsole.

Se você planeja enviar personagens de volta via netconsole ou deseja parar e começar
QEMU muitas vezes, você deve fazer com que o QEMU use a mesma porta de origem todas as vezes até
usando algo como "-serial udp :: 4555 @ 4556" para QEMU. Outra abordagem é usar
uma versão corrigida do netcat que pode escutar uma porta TCP e enviar e receber
personagens via udp. Se você tiver uma versão corrigida do netcat que ativa
telnet remote echo e single char transfer, então você pode usar o seguinte
opções para intensificar um redirecionador netcat para permitir telnet na porta 5555 para acessar o
Porta QEMU.

"Opções QEMU:"
-serial udp :: 4555 @ 4556

"opções do netcat:"
-u -P 4555 -L 0.0.0.0:4556 -t -p 5555 -I -T

"opções telnet:"
localhost 5555

tcp: [hospedeiro]:porta[,servidor] [, nowait] [, nodelay] [, reconectar =segundo]
O console TCP Net possui dois modos de operação. Ele pode enviar o I / O serial para um
local ou aguarde uma conexão de um local. Por padrão, o console TCP Net
é enviado para hospedeiro no porta. Se você usar o servidor opção QEMU irá esperar por um
aplicativo de soquete do cliente para se conectar à porta antes de continuar, a menos que o
A opção "nowait" foi especificada. A opção "nodelay" desativa o buffer de Nagle
algoritmo. A opção "reconectar" só se aplica se servidor não está definido, se o
a conexão cair, ele tentará se reconectar no intervalo determinado. Se hospedeiro
é omitido, 0.0.0.0 é assumido. Apenas uma conexão TCP por vez é aceita. Vocês
pode usar "telnet" para se conectar ao dispositivo de caractere correspondente.

"Exemplo para enviar console tcp para porta 192.168.0.2 4444"
-serial tcp: 192.168.0.2: 4444

"Exemplo para ouvir e esperar na porta 4444 para conexão"
-serial tcp :: 4444, servidor

"Exemplo para não esperar e escutar no ip 192.168.0.100 porta 4444"
-serial tcp: 192.168.0.100: 4444, servidor, nowait

Telnet:hospedeiro:porta[, servidor] [, nowait] [, nodelay]
O protocolo telnet é usado em vez de soquetes tcp brutos. As opções funcionam da mesma maneira
como se você tivesse especificado "-serial tcp". A diferença é que o porto funciona como
um servidor ou cliente telnet usando a negociação de opção telnet. Isso também permitirá
você deve enviar a sequência MAGIC_SYSRQ se você usar um telnet que suporte o envio de
seqüência de pausa. Normalmente em telnet unix você faz isso com Control-] e, em seguida, digite
"enviar pausa" seguido de pressionar a tecla Enter.

Unix:caminho[, servidor] [, nowait] [, reconectar =segundo]
Um soquete de domínio unix é usado em vez de um soquete tcp. A opção funciona da mesma maneira
como se você tivesse especificado "-serial tcp" exceto o soquete de domínio unix caminho é usado
para conexões.

seg:dev_string
Esta é uma opção especial para permitir que o monitor seja multiplexado em outro
porta serial. O monitor é acessado com a sequência de teclas de Controle-a e depois
premente c. dev_string deve ser qualquer um dos dispositivos seriais especificados acima.
Um exemplo para multiplexar o monitor em um servidor telnet ouvindo na porta 4444
seria:

"-serial mon: telnet :: 4444, server, nowait"

Quando o monitor é multiplexado para stdio desta forma, Ctrl + C não termina
QEMU mais, mas será passado para o convidado.

braille
Dispositivo Braille. Isso usará BrlAPI para exibir a saída braille em um real ou
dispositivo falso.

msmouse
Mouse serial de três botões. Configure o convidado para usar o protocolo Microsoft.

-paralelo dev
Redirecione a porta paralela virtual para o dispositivo host dev (mesmos dispositivos que o serial
porta). Em hosts Linux, / dev / parportN pode ser usado para usar dispositivos de hardware conectados em
a porta paralela do host correspondente.

Esta opção pode ser usada várias vezes para simular até 3 portas paralelas.

Use "-parallel none" para desabilitar todas as portas paralelas.

-monitor dev
Redirecione o monitor para o dispositivo host dev (mesmos dispositivos da porta serial). o
o dispositivo padrão é "vc" no modo gráfico e "stdio" no modo não gráfico. Usar
"-monitor none" para desativar o monitor padrão.

-qmp dev
Como -monitor, mas abre no modo 'controle'.

-qmp-bonita dev
Como -qmp, mas usa uma formatação bastante JSON.

-seg [chardev =] nome [, modo = readline | controle] [, padrão]
Configurar monitor no chardev nome.

-debugcon dev
Redirecione o console de depuração para o dispositivo host dev (mesmos dispositivos da porta serial). o
o console de depuração é uma porta de E / S que normalmente é a porta 0xe9; escrevendo para essa porta de E / S
envia saída para este dispositivo. O dispositivo padrão é "vc" no modo gráfico e "stdio"
em modo não gráfico.

-pidfile lima
Armazene o PID do processo QEMU em lima. É útil se você iniciar o QEMU a partir de um script.

-único passo
Execute a emulação no modo de passo único.

-S Não inicie a CPU na inicialização (você deve digitar 'c' no monitor).

-tempo real mlock = on | off
Execute o qemu com recursos em tempo real. mlocking qemu e memória de convidado podem ser habilitados via
mlock = on (habilitado por padrão).

-gdb dev
Aguarde a conexão gdb no dispositivo dev. As conexões típicas provavelmente serão baseadas em TCP,
mas também UDP, pseudo TTY ou mesmo stdio são casos de uso razoáveis. O último é
permitindo iniciar o QEMU de dentro do gdb e estabelecer a conexão por meio de um tubo:

(gdb) alvo remoto | exec qemu-system-i386 -gdb stdio ...

-s Abreviação de -gdb tcp :: 1234, ou seja, abra um gdbserver na porta TCP 1234.

-d item1[, ...]
Habilite o registro de itens especificados. Use '-d help' para obter uma lista de itens de log.

-D arquivo de log
Log de saída arquivo de log em vez de stderr

-L caminho
Defina o diretório para o BIOS, BIOS VGA e mapas de teclado.

-BIOS lima
Defina o nome do arquivo para o BIOS.

-ativar-kvm
Habilite o suporte de virtualização total de KVM. Esta opção só está disponível se o suporte KVM
é habilitado durante a compilação.

-xen-domid id
Especifique o domínio de convidado xen id (Apenas XEN).

-xen-criar
Crie um domínio usando hipercalls xen, ignorando xend. Aviso: não deve ser usado quando
xend está em uso (apenas XEN).

-xen-anexar
Anexe ao domínio xen existente. O xend usará isso ao iniciar o QEMU (apenas XEN).

-não reinicializar
Saia em vez de reinicializar.

-não-desligamento
Não saia do QEMU no encerramento do convidado, mas apenas pare a emulação. Isso permite
por exemplo, alternar para o monitor para confirmar as alterações na imagem do disco.

-loadvm lima
Comece imediatamente com um estado salvo ("loadvm" no monitor)

-daemonizar
Daemonize o processo QEMU após a inicialização. QEMU não se separa do padrão
IO até que esteja pronto para receber conexões em qualquer um de seus dispositivos. Esta opção é uma
maneira útil para programas externos iniciarem o QEMU sem ter que lidar com
condições de corrida de inicialização.

-opção-rom lima
Carregue o conteúdo de lima como uma opção ROM. Esta opção é útil para carregar coisas como
EtherBoot.

-rtc [base = utc | localtime |dados] [, clock = host | vm] [, driftfix = none | slew]
Especificar base como "utc" ou "localtime" para permitir que o RTC comece no UTC atual ou local
tempo, respectivamente. "localtime" é necessário para a data correta no MS-DOS ou no Windows. Para
começar em um ponto específico no tempo, fornecer dados no formato "2006-06-17T16: 01: 21" ou
"2006-06-17". A base padrão é UTC.

Por padrão, o RTC é orientado pela hora do sistema host. Isso permite o uso do RTC como
relógio de referência preciso dentro do convidado, especificamente se o horário do host estiver tranquilo
seguindo um relógio de referência externo preciso, por exemplo, via NTP. Se você quiser isolar
o tempo do convidado do anfitrião, você pode definir relógio para "rt" em vez disso. Até para prevenir
de progredir durante a suspensão, você pode defini-lo como "vm".

permitir correção de desvio (alvos i386 apenas) se você tiver problemas de desvio de tempo,
especificamente com ACPI HAL do Windows. Esta opção tentará descobrir quantos cronômetros
as interrupções não foram processadas pelo convidado do Windows e irão reinjetá-las.

-eu conto [shift =N| auto] [, rr = registro | replay, rrfile =nome do arquivo]
Habilite o contador de instrução virtual. A cpu virtual irá executar uma instrução
a cada 2 ^N ns de tempo virtual. Se "auto" for especificado, a velocidade da cpu virtual
ser ajustado automaticamente para manter o tempo virtual dentro de alguns segundos do tempo real.

Quando a cpu virtual está hibernando, o tempo virtual avançará na velocidade padrão
a menos que sono = não é especificado. Com sono = não, o tempo virtual irá pular para o próximo
prazo do temporizador instantaneamente sempre que a CPU virtual entra no modo de hibernação e não
avançar se nenhum cronômetro estiver habilitado. Este comportamento fornece tempos de execução determinísticos de
o ponto de vista do hóspede.

Observe que embora esta opção possa fornecer um comportamento determinístico, ela não fornece um ciclo
emulação precisa. CPUs modernas contêm núcleos superescalares fora de ordem com complexos
hierarquias de cache. O número de instruções executadas muitas vezes tem pouco ou nenhum
correlação com o desempenho real.

alinhar = em irá ativar o algoritmo de atraso que tentará sincronizar o host
relógio e o relógio virtual. O objetivo é ter um convidado rodando na frequência real
impostas pela opção de deslocamento. Sempre que o relógio do convidado está atrasado em relação ao relógio do host e se
alinhar = em for especificado, então imprimimos uma mensagem ao usuário para informar sobre o atraso.
Atualmente esta opção não funciona quando mudança é "automático". Nota: o algoritmo de sincronização
funcionará para aqueles valores de deslocamento para os quais o relógio do convidado é executado antes do host
relógio. Normalmente, isso acontece quando o valor do deslocamento é alto (o quão alto depende do
máquina host).

Quando rr opção é especificada registro / reprodução determinística está habilitado. Registro de repetição é
escrito em nome do arquivo arquivo no modo de gravação e leia a partir desse arquivo no modo de reprodução.

- cão de guarda modelo
Crie um dispositivo watchdog de hardware virtual. Uma vez ativado (por uma ação de convidado), o
watchdog deve ser periodicamente sondado por um agente dentro do convidado ou então o convidado
será reiniciado. Escolha um modelo para o qual seu convidado tenha drivers.

A modelo é o modelo de watchdog de hardware a ser emulado. Use "-watchdog help" para listar
modelos de hardware disponíveis. Apenas um watchdog pode ser habilitado para um convidado.

Os seguintes modelos podem estar disponíveis:

ib700
O iBASE 700 é um watchdog ISA muito simples com um único temporizador.

i6300esb
O hub do controlador de E / S Intel 6300ESB é um temporizador duplo baseado em PCI com muito mais recursos
cão de guarda.

diag288
Um watchdog virtual para s390x apoiado pela hiperchamada diagnose 288 (atualmente KVM
só).

-ação de cão de guarda açao
A açao controla o que o QEMU fará quando o cronômetro do watchdog expirar. O padrão é
"redefinir" (redefinir o convidado com força). Outras ações possíveis são: "desligar" (tentativa
para desligar o convidado normalmente), "desligar" (desligar o convidado à força), "pausar"
(pause o convidado), "depure" (imprima uma mensagem de depuração e continue) ou "nenhum" (faça
nada).

Observe que a ação "desligar" requer que o convidado responda aos sinais ACPI,
o que pode não ser capaz de fazer no tipo de situações em que o cão de guarda teria
expirou e, portanto, "-watchdog-action shutdown" não é recomendado para uso em produção.

Exemplos:

"-watchdog i6300esb -watchdog-action pause"
"-watchdog ib700"
-chr valor_ascii_numérico
Altere o caractere de escape usado para alternar para o monitor ao usar o monitor e
compartilhamento serial. O padrão é 0x01 ao usar a opção "-nographic". 0x01 é
igual a pressionar "Control-a". Você pode selecionar um personagem diferente do ascii
teclas de controle onde 1 a 26 mapeiam para Control-a a Control-z. Por exemplo você
poderia usar um dos seguintes para alterar o caractere de escape para Control-t.

"-echr 0x14"
"-echr 20"
-virtioconsole c
Defina o console virtio.

Esta opção é mantida para compatibilidade com versões anteriores.

Use "-device virtconsole" para a nova forma de invocação.

-mostrar-cursor
Mostrar cursor.

-tb-tamanho n
Defina o tamanho do TB.

-entrada tcp: [hospedeiro]:porta[, para =porta máxima] [, ipv4] [, ipv6]
-entrada Rdma:hospedeiro:porta[, ipv4] [, ipv6]
Prepare-se para a migração de entrada, ouça em uma determinada porta tcp.

-entrada Unix:caminho do soquete
Prepare-se para a migração de entrada, ouça em um determinado soquete Unix.

-entrada fd:fd
Aceite a migração de entrada de um determinado filedescriptor.

-entrada executivo:cmdline
Aceita a migração de entrada como uma saída do comando externo especificado.

-entrada adiar
Aguarde até que o URI seja especificado por meio de migrate_incoming. O monitor pode ser usado para
alterar as configurações (como parâmetros de migração) antes de emitir o migrate_incoming
para permitir o início da migração.

-nodefaults
Não crie dispositivos padrão. Normalmente, QEMU define os dispositivos padrão como serial
porta, porta paralela, console virtual, dispositivo de monitor, adaptador VGA, disquete e CD-ROM
dirigir e outros. A opção "-nodefaults" irá desabilitar todos os dispositivos padrão.

-chroot dir
Imediatamente antes de iniciar a execução do convidado, execute o chroot no diretório especificado.
Especialmente útil em combinação com -runas.

-correr como usuário
Imediatamente antes de iniciar a execução do convidado, elimine os privilégios de root, mudando para o
usuário especificado.

-prom-env variável=valor
Definir nvram OpenBIOS variável dar valor (PPC, SPARC apenas).

-semi-hospedagem
Ative o modo de semi-hospedagem (apenas ARM, M68K, Xtensa, MIPS).

-semihosting-config [enable = on | off] [, target = native | gdb | auto] [, arg = str [, ...]]
Habilite e configure o semihosting (apenas ARM, M68K, Xtensa, MIPS).

target = "nativo | gdb | auto"
Define onde as chamadas de semihosting serão endereçadas, para QEMU ("nativo") ou para
GDB ("gdb"). O padrão é "auto", que significa "gdb" durante as sessões de depuração e
caso contrário, "nativo".

arg =str1, arg =str2, ...
Permite que o usuário passe argumentos de entrada e pode ser usado várias vezes para construir
uma lista. O método antigo "-kernel" / "- append" de passar uma linha de comando é
ainda com suporte para compatibilidade com versões anteriores. Se ambos os "--semihosting-config arg"
e o "-kernel" / "- append" são especificados, o primeiro é passado para semihosting como
sempre tem precedência.

-old-param
Modo de parâmetro antigo (apenas ARM).

-caixa de areia arg
Habilite o filtro de chamada de sistema do modo 2 do Seccomp. 'on' irá habilitar a filtragem de syscall e 'off'
irá desativá-lo. O padrão é 'desligado'.

-readconfig lima
Leia a configuração do dispositivo de lima. Esta abordagem é útil quando você deseja gerar
Processo QEMU com muitas opções de linha de comando, mas você não quer exceder o comando
limite de caracteres de linha.

-writeconfig lima
Grave a configuração do dispositivo para lima. O lima pode ser qualquer nome de arquivo para salvar o comando
configuração de linha e dispositivo em arquivo ou traço "-") caractere para imprimir a saída para
stdout. Isso pode ser usado posteriormente como arquivo de entrada para a opção "-readconfig".

-nodefconfig
Normalmente o QEMU carrega arquivos de configuração de sysconfdir e diretório de dados na inicialização. o
A opção "-nodefconfig" impedirá o QEMU de carregar qualquer um desses arquivos de configuração.

-no-user-config
A opção "-no-user-config" faz com que o QEMU não carregue nenhum dos arquivos de configuração fornecidos pelo usuário
on sysconfdir, mas não fará com que pule os arquivos de configuração fornecidos pelo QEMU de diretório de dados.

-vestígio [eventos =lima] [, arquivo =lima]
Especifique as opções de rastreamento.

eventos =lima
Ative imediatamente os eventos listados em lima. O arquivo deve conter um nome de evento
(conforme listado no eventos de rastreamento arquivo) por linha. Esta opção só está disponível se
QEMU foi compilado com qualquer simples or stderr rastreando back-end.

arquivo =lima
Log de rastreios de saída para lima.

Esta opção está disponível apenas se QEMU foi compilado com o simples rastreamento
Processo interno.

-enable-fips
Ative o modo de conformidade FIPS 140-2.

- mensagem carimbo de data / hora [= ligado | desligado]
acrescente um carimbo de data / hora a cada mensagem de registro. (padrão: ativado)

-dump-vmstate lima
Despeje informações de vmstate codificadas em json para o tipo de máquina atual para arquivar lima Generic
criação de objeto

-objeto Digite o nome[,prop1=value1, ...]
Crie um novo objeto do tipo Digite o nome definir propriedades na ordem em que estão
Especificadas. Observe que a propriedade 'id' deve ser definida. Esses objetos são colocados no
caminho '/ objetos'.

-objeto arquivo de backend de memória, id =id, tamanho =tamanho, mem-path =dir, compartilhar =ligado | desligado
Cria um objeto de back-end de arquivo de memória, que pode ser usado para apoiar a RAM convidada com
páginas enormes. o id parâmetro é um ID único que será usado para fazer referência a este
região de memória ao configurar o -numa argumento. O tamanho opção fornece o
tamanho da região de memória e aceita sufixos comuns, por exemplo 500M. O caminho de mem
fornece o caminho para uma memória compartilhada ou uma montagem de sistema de arquivos de página enorme. o
share A opção booleana determina se a região da memória está marcada como privada para
QEMU ou compartilhado. Este último permite um processo externo de cooperação para acessar o
Região de memória QEMU.

-objeto rng-random, id =id, nome do arquivo =/ dev / random
Cria um gerador de números aleatórios que obtém entropia de um dispositivo em
O hospedeiro. o id parâmetro é um ID único que será usado para fazer referência a este
entropia backend do virtio-rng dispositivo. o nome do arquivo parâmetro especifica qual
arquivo para obter entropia e, se omitido, o padrão é / dev / random.

-objeto rng-egd, id =id, chardev =Chardevid
Cria um gerador de números aleatórios que obtém entropia de um gerador externo
daemon em execução no host. o id parâmetro é um ID único que será usado para
referenciar este backend de entropia do virtio-rng dispositivo. o Chardev parâmetro
é o ID único de um back-end de dispositivo de caractere que fornece a conexão com o
Daemon RNG.

-objeto
tls-creds-anon, id =id, endpoint =Ponto final, dir =/ caminho / para / cred / dir, verificar-par =ligado | desligado
Cria um objeto de credenciais anônimas TLS, que pode ser usado para fornecer TLS
suporte em back-ends de rede. o id parâmetro é um ID único que rede
back-ends usarão para acessar as credenciais. o Ponto final é também servidor or
cliente dependendo se o back-end da rede QEMU que usa as credenciais
estará atuando como um cliente ou como um servidor. Se verificar par está habilitado (o padrão)
então, uma vez que o handshake for concluído, as credenciais do par serão verificadas,
embora este seja um ambiente autônomo para credenciais anônimas.

A dir parâmetro informa ao QEMU onde encontrar os arquivos de credencial. Para servidor
endpoints, este diretório pode conter um arquivo dh-params.pem fornecendo diffie-
Parâmetros hellman a serem usados ​​para o servidor TLS. Se o arquivo estiver faltando, o QEMU irá
gerar um conjunto de parâmetros DH na inicialização. Este é um computador caro
operação que consome entropia de pool aleatório, por isso é recomendado que um
conjunto persistente de parâmetros seja gerado antecipadamente e salvo.

-objeto
tls-creds-x509, id =id, endpoint =Ponto final, dir =/ caminho / para / cred / dir, verificar-par =ligado | desligado
Cria um objeto de credenciais anônimas TLS, que pode ser usado para fornecer TLS
suporte em back-ends de rede. o id parâmetro é um ID único que rede
back-ends usarão para acessar as credenciais. o Ponto final é também servidor or
cliente dependendo se o back-end da rede QEMU que usa as credenciais
estará atuando como um cliente ou como um servidor. Se verificar par está habilitado (o padrão)
então, assim que o handshake for concluído, as credenciais do par serão verificadas. Com
certificados x509, isso significa que os clientes devem receber certificados
certificados de cliente também.

A dir parâmetro informa ao QEMU onde encontrar os arquivos de credencial. Para servidor
endpoints, este diretório pode conter um arquivo dh-params.pem fornecendo diffie-
Parâmetros hellman a serem usados ​​para o servidor TLS. Se o arquivo estiver faltando, o QEMU irá
gerar um conjunto de parâmetros DH na inicialização. Este é um computador caro
operação que consome entropia de pool aleatório, por isso é recomendado que um
conjunto persistente de parâmetros seja gerado antecipadamente e salvo.

Para credenciais de certificado x509, o diretório conterá outros arquivos
fornecendo os certificados x509. Os certificados devem ser armazenados no formato PEM, em
nomes de arquivos ca-cert.pem, ca-crl.pem (opcional), servidor-cert.pem (apenas servidores),
chave do servidor.pem (apenas servidores), cliente-cert.pem (apenas clientes), e cliente-chave.pem
(apenas clientes).

-objeto buffer de filtro, id =id, netdev =netdevid, intervalo =t[, fila =all | rx | tx]
Intervalo t não pode ser 0, este filtro agrupa a entrega do pacote: todos os pacotes
chegando em um determinado intervalo no netdev netdevid estão atrasados ​​até o final do
intervalo. O intervalo é em microssegundos.

fila all | rx | tx é uma opção que pode ser aplicada a qualquer filtro de rede.

todos os: o filtro é anexado à fila de recepção e transmissão do
netdev (padrão).

rx: o filtro é anexado à fila de recebimento do netdev, onde irá
receber pacotes enviados para o netdev.

tx: o filtro é anexado à fila de transmissão do netdev, onde irá
receber pacotes enviados pelo netdev.

-objeto filter-dump, id =id, netdev =dev, arquivo =nome do arquivo] [, maxlen =len]
Descarregue o tráfego de rede no netdev dev para o arquivo especificado por nome do arquivo. No máximo
len bytes (64k por padrão) por pacote são armazenados. O formato do arquivo é libpcap, então
ele pode ser analisado com ferramentas como tcpdump ou Wireshark.

Durante a emulação gráfica, você pode usar combinações de teclas especiais para alterar os modos. o
mapeamentos de teclas padrão são mostrados abaixo, mas se você usar "-alt-grab", o modificador é
Ctrl-Alt-Shift (em vez de Ctrl-Alt) e se você usar "-ctrl-agarrar" então o modificador é o
tecla Ctrl direita (em vez de Ctrl-Alt):

Ctrl-Alt-f
Alternar para o modo tela cheia

Ctrl-Alt- +
Amplie a tela

Ctrl-Alt--
Encolher a tela

Ctrl-Alt-você
Restaura as dimensões não dimensionadas da tela

Ctrl-Alt-n
Mude para o console virtual 'n'. Os mapeamentos de console padrão são:

1 Visor do sistema de destino

2 Monitore

3 Porta Serial

Ctrl-Alt
Alternar mouse e teclado.

Nos consoles virtuais, você pode usar Ctrl-Cima, Ctrl-Baixo, Ctrl-PageUp e Ctrl-PageDown para
mova no log de volta.

Durante a emulação, se você estiver usando o -nográfico opção, use Ctrl h para obter terminal
comandos:

Ctrl h
Ctrl ?
Imprima esta ajuda

Ctrl x
Sair do emulador

Ctrl s
Salve os dados do disco de volta ao arquivo (se -snapshot)

Ctrl t
Alternar carimbos de data / hora do console

Ctrl b
Send break (magic sysrq no Linux)

Ctrl c
Alternar entre console e monitor

Ctrl Ctrl
Enviar Ctrl-a

As seguintes opções são específicas para a emulação PowerPC:

-g WxH[xPROFUNDIDADE]
Defina o modo gráfico VGA inicial. O padrão é 800x600x32.

-prom-env corda
Defina as variáveis ​​OpenBIOS em NVRAM, por exemplo:

qemu-system-ppc -prom-env 'auto-boot? = false' \
-prom-env 'boot-device = hd: 2, \ yaboot' \
-prom-env 'boot-args = conf = hd: 2, \ yaboot.conf'

Essas variáveis ​​não são usadas pelo Open Hack'Ware.

As seguintes opções são específicas para a emulação Sparc32:

-g WxHx [xPROFUNDIDADE]
Defina o modo gráfico inicial. Para TCX, o padrão é 1024x768x8 com a opção de
1024x768x24. Para cgthree, o padrão é 1024x768x8 com a opção de 1152x900x8 para
pessoas que desejam usar o OBP.

-prom-env corda
Defina as variáveis ​​OpenBIOS em NVRAM, por exemplo:

qemu-system-sparc -prom-env 'auto-boot? = false' \
-prom-env 'boot-device = sd (0,2,0): d' -prom-env 'boot-args = linux single'

-M [SS-4|SS-5|SS-10|SS-20|SS-600MP|LX|Voyager|SPARCClassic] [| Livro SPARC]
Defina o tipo de máquina emulada. O padrão é SS-5.

As seguintes opções são específicas para a emulação Sparc64:

-prom-env corda
Defina as variáveis ​​OpenBIOS em NVRAM, por exemplo:

qemu-system-sparc64 -prom-env 'auto-boot? = false'

-M [sun4u | sun4v | Niágara]
Defina o tipo de máquina emulada. O padrão é sun4u.

Use qemu-system-cris online usando serviços onworks.net