Como compilar o kernel AOSP Android e testá-lo com o emulador Android?

StackOverflow https://stackoverflow.com/questions/1809774

Pergunta

Alguém já compilado com sucesso o kernel android e testado no emulador Android, e se assim não há nada que especial que precisa ser feito?

A documentação do SDK é excelente, no entanto documentação para compilar o kernel e configurar uma máquina personalizada no emulador tem sido difícil para mim encontrar.

Foi útil?

Solução

Desde agosto de 2009 o kernel não faz mais parte do manifesto repo padrão que você começa quando você siga as instruções para baixar o código fonte para o projeto de código aberto Android. Os passos que são necessários para baixar com êxito, construir e executar um kernel específico no emulador são os seguintes:

  • Obter o kernel do Android ou por adicioná-lo ao seu repo manifesto ou manualmente executando:
    git clone https://android.googlesource.com/kernel/goldfish.git
  • Confira o ramo correto para trabalhar com o emulador, ou seja, peixinho:
    git checkout -t origin/android-goldfish-2.6.29 -b goldfish
  • Gerar a configuração emulador (qemu emulador corre armar código, isto é, uma configuração do braço):
    make ARCH=arm goldfish_defconfig
    • Se isso não funcionar, tente make ARCH=arm goldfish_armv7_defconfig
  • Agora compilar o kernel usando as ferramentas de compilação cruzada distribuídos com o projeto open source:
    make ARCH=arm CROSS_COMPILE=mydroid/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-
  • O kernel construído desta forma deve acabar na pasta arch / arm / boot de sua árvore do kernel (onde você colocar o código do clone git)
  • Para executar o emulador com o seu kernel há duas alternativas, ou copiá-lo para o pré-construídos do kernel pasta do projeto open source para substituir o kernel padrão. A outra opção é para iniciar o emulador com o conjunto de opção do kernel:
    emulator -kernel mydroid/kernel/common/arch/arm/boot/zImage

Note que eu usei os caminhos padrão na descrição acima, você precisa alterá-los para o que se aplica à sua configuração. Tem sido um tempo desde a última vez que eu testei isso, mas eu acho que deve funcionar.

Algumas informações adicionais: Na distribuição de código aberto Android padrão o kernel é distribuído como um binário pré-compilado na pasta mydroid/prebuilt/android-arm/kernel eo código fonte não está incluída. A fonte do kernel foi retirado do manifesto padrão por duas razões como eu levá-la. Uma delas é que ele tem um monte de largura de banda e espaço em disco para um componente da plataforma que a maioria das pessoas não vai trabalhar com muito. A outra razão é que desde que o kernel é construído com o sistema de compilação do kernel e não como parte do sistema de compilação AOSP faz sentido mantê-la separada. A filial comum para o kernel é o utilizado pelo emulador. Há também ramos para experimental, msm (plataformas da Qualcomm) e OMAP (plataforma de TI) e talvez um pouco mais. Se você quer usar o kernel do Android com hardware estes podem ser mais interessante para você.

Outras dicas

Apenas para corrigir algumas coisas com o post de BMB (que foi muito útil para mim, ele salvou o meu projeto):

  • git clone git: //android.git.kernel.org/kernel/common.git (o do kernel não atendidas);
  • git checkout -t origem / android-peixinho-2.6.29 peixinho -b (o mesmo);
  • fazer ARCH = braço goldfish_defconfig (idem);
  • fazer ARCH = armar CROSS_COMPILE = mydroid / pré-construídos / linux-x86 / toolchain / arm-EABI-4.2.1 / bin / arm-eabi- (idem)
  • emulador -avd my_avd -kernel mydroid / kernel / common / arch / arm / boot / zImage (aqui eu adicionei um avd no comando, não fez trabalho sem para mim).

Esta é uma atualização para as respostas do BMB e Arnaud LM.
Parece que os branchnames peixinho foram alteradas a partir de 2011/03/03. Ao verificar o ramo peixinho, use o seguinte: 

git checkout -t origin/archive/android-gldfish-2.6.29 -b goldfish

Observe os desaparecidos 'o' em android-gldfish-2.6.29!

Espero que isso economiza tempo para alguém.

A partir de 2012, de baixar o kernel está bem documentado na source.google.com, no entanto, achamos a compilá-lo levou algumas tentativas. Aqui estão os comandos que usei para construir um kernel para o emulador ARM: 

cd /kernel/source/root
make mrproper
adb pull /proc/config.gz # from the emulator
gunzip config
mv config .config  # now you have a (perhaps slightly outdated kernel .config)
make ARCH=arm silentoldconfig # update the .config - take the defaults if prompted
make ARCH=arm menuconfig # make any further changes
time make -j4 ARCH=arm CROSS_COMPILE=/path/to/android/source/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin/arm-eabi- 2>&1 | tee ../../logs/$(date +%Y%m%d-%H%M)-make-kernel.log
emulator -kernel /kernel/source/root/kernel/goldfish/arch/arm/boot/zImage -avd myAVD &

Obrigado a todos que responderam este - eu era capaz de fazê-lo com pedaços de esta resposta. Amaund de 'você precisa do AVD' foi a última peça que me deu problemas.

totalmente automatizada Android 8.1 convidado no Ubuntu 17.10 anfitrião 

# Download the source. Takes several minutes.
curl https://storage.googleapis.com/git-repo-downloads/repo >repo
chmod a+x repo
./repo init -b android-8.1.0_r1 --depth 1 -u https://android.googlesource.com/platform/manifest
./repo sync -c  -j $(($(nproc) - 2)) --no-tags --no-clone-bundle

# Do the actual build. Takes minutes / hours.
. build/envsetup.sh
lunch aosp_x86_64-eng
USE_CCACHE=1 CCACHE_DIR=ccache make -j $(($(nproc) - 2))

# Run the emulator.
emulator -show-kernel

O diretório de construção out/ ocupa cerca de 90GB, eo resto da árvore sobre 40Gb, excluindo CCache.

Sobre 1-2 minutos após o início do emulador, os shows da tela inicial:

e se você pressionar enter no host terminal Android foi lançado a partir, você obtém um shell no sistema Android no seu terminal host:

enter descrição da imagem aqui

Notas:

  • ./repo init -b ponto deve a uma tag . ramo master está sempre quebrado, e por isso foram ramos -release.

    A lista de tags podem ser encontradas em: https://android.googlesource.com/platform/ manifesto ou por clonagem que repo.

    Existem provavelmente duas razões pelas quais ramos estão sempre quebrados:

    • Android é desenvolvido por trás de portas e código fechados caiu. Portanto Google e OEM já devs ter uma tonelada de paches em cima do público "mestre", e já corrigiu o problema.

      Pela mesma razão, é provável inútil tentar e relatar quaisquer erros de compilação no mestre: eles já foram relatados e corrigidos. Também Eu te desafio a até achar o lugar oficial direito de falhas de compilação do relatório.

    • repo sync em uma filial simplesmente pega tudo o mais recente versão de todos os 650 repos git torna-se AOSP para o ramo dado, sem sincronizar-los como submódulos. Portanto, nada garante que eles são compatíveis. Etiquetas no entanto buscar uma tag específica de todos os repos.

  • --depth 1 e sync -c --no-tags --no-clone-bundle eram uma tentativa de fazer o clone dolorosamente lento mais rápido. Não tenho certeza o quão bem sucedido que era. Veja também: AOSP repo sync leva muito tempo

  • Nós usamos lunch aosp_x86_64-eng vez de ARM porque corre muito mais rápido devido ao acolhimento extensões de virtualização x86.

    Para construir uma versão ARM em vez disso, apenas o uso lunch aosp_arm-eng vez.

    Além disso, a imagem ARM é buggy, possivelmente devido à lentidão? Quando começar a GUI (se você tiver sorte), ele mostra "UI sistema não está respondendo". Veja também: não está respondendo no android emulador

  • -show-kernel liga o terminal a uma série, ou seja, você vê mensagens de inicialização, e obter uma shell no final, o que é muito útil para as coisas de depuração.

  • type emulator mostra que é apenas um alias para o emulator sem nenhum argumento. Run ROM personalizado no emulador Android pede como passar alguns argumentos para selecionar explicitamente o seu ROM.

    Os alvos emulador -help são surpreendentemente perspicaz: 

    emulator -help
emulator -help-build-images
emulator -help-disk-images

    Você pode determinar os exatos argumentos de linha de comando QEMU dadas com: 

    emulator -verbose | grep 'emulator: argv'

    como mencionado em: Como mostrar quais opções são passados ??para QEMU ao lançar o emulador Android?

    Isto mostra algumas opções personalizadas por exemplo -android-hw, então eles devem ter bifurcada QEMU: QEMU vs emulador Android: opções de linha de comando Os source movimentos localização a cada 5 minutos, aparentemente: Modificando Android emulador de código fonte

Isso é fácil. Siga as instruções em http://source.android.com/download para obter e compilar o código fonte todo o android. Isso leva um tempo, mas não é tão complicado.

Ao construir isso, você terá que você está de saída no diretório <android>/out. Que inclui, além das imagens ROM, um monte de ferramentas também, incluindo o emulador. Meu emulador está em <android>/out/host/linux-x86/bin/emulator. Basta definir um ANDROID_PRODUCT_OUT variável de ambiente nomeado para <android>/out/target/product/generic, e então executar o emulador sem opções vai executar o seu ROM compilado.

A partir de maio de 2012, eu achei que você não pode usar o 'goldfish_defconfig' para compilar o kernel. Você precisa usar goldfish_armv7_defconfig'. Isso explicaria por que método de extrair a configuração do emulador (para o kernel pré-construídos) do JonnyLambada funciona, e é necessário.

O goldfish_defconfig configura o núcleo para ser executado em um processador ARM 926, mas o emulador está configurado para funcionar como um Coretex A8 (que é uma CPU ARM V7). Então, você precisa usar o mais recente defconfig se você quer que ele funcione (ou puxar a configuração do emulador).

Apenas FYI.

A maneira que eu era capaz de iniciar o AOSP rom eu compilei era para copiar o system.img que foi compilado para ~ / .android / avd / Froyo.avd / Mas, quando eu extrair o system.img e adicionar a versão enraizada de su e busybox, em seguida, refazer o system.img, o emulador não faz boot. Eu ainda estou tentando descobrir essa parte: S

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top