[Tutorial] Buildare il vostro primo kernel

[KlaasMad]

Da un'idea di N1m0y e dalla mia traduzione, ecco una guida su come buildare un kernel dai sorgenti.
Tutti i crediti vanno all'autore su XDA.

Prefazione

Usate questa guida per diffondere la conoscenza e per darvi alcuni termini chiave e per accendere qualche lampadina ed ingranare qualche marcia.

Nota: questa non è una guida per newbie su Linux. Prima che postiate questa domanda, dateci un'occhiata. Se involvesse una sintassi di comandi che non conoscete, fate la vostra ricerca da qualche altra parte prima di continuare con questa guida.

Step 1. Ambiente

A. Installate Ubuntu 12.04 (ultima versione 13.10) (nessun aiuto qui, se non sapete farlo, non dovreste avere a che fare coi kernel). Nota di Dionysus: è davvero semplicissimo e nella sezione Android x86 ho fatto una guida che si può applicare a qualsiasi distro Linux Debian based ed anche qualche altra (Fedora, OpenSuse etc etc).

B. Pacchetti richiesti: git-core, gnupg, flex, bison, gperf, libsdl-dev, libesd0-dev, libwxgtk2.8-dev, build-essential, zip, curl, libncurses5-dev, zlib1g-dev, lib32z1, lib32ncurses5, lib32bz2-1.0, lib32z1-dev, lib32ncurses5-dev, gcc-multilib, g++-multilib, e Adb.
Quindi per installare le dipendenze richieste, da terminale digitiamo:

sudo apt-get install git-core gnupg flex bison gperf libsdl-dev libesd0-dev libwxgtk2.8-dev build-essential zip curl libncurses5-dev zlib1g-dev lib32z1 lib32ncurses5 lib32bz2-1.0 lib32z1-dev lib32ncurses5-dev gcc-multilib g++-multilib

e per installare adb, potete installarlo via terminale:

sudo apt-get install android-tools-adb

NB. il forum storpia il codice ed inserisce una "k" ed una chiocciola "@" di troppo, per cui sarebbe android, trattino, tools, trattino e alla fine adb.

o potete trovarlo nella cartella dove avete estratto SDK, a sua volta dentro la cartella platform-tools.

Installate anche git:

sudo apt-get install git

C. Aprite un terminale (ctrl+alt+t su Ubuntu)

D. Digitate "mkdir android" (crea la cartella android) (non inserite le virgolette)

E. Digitate "cd android" (entra dentro la cartella android)

G. Digitate "mkdir kernel" (crea la cartella kernel)

F. Chiudete il terminale.

Step 2. Vostri sorgenti

A. Aprite il terminale

B. Digitate "cd android/kernel" (entra dentro la cartella kernel situata dentro la cartella android)

C. Digitate "git clone git://github.com/DooMLoRD/android_prebuilt_toolchains.git toolchains" (recupera attraverso il comando git clone, il toolchains e lo piazza dentro la cartalla toolchains)

D. Adesso arriva la parte difficile, vi serve alcuni tipi di sorgenti per il vostro kernel. Controllate i due seguenti siti per il vostro dispositivo. Una volta che li avete scaricati, devono essere estratti o clonati dentro una cartella nella tua directory del kernel

Welcome to HTCdev
Samsung Open Source Release Center
Developer World
OpenSource Code Distribution

Cos'è un toolchain? Date un'occhiata qui. Questi toolchains sono instabili e non totalmente supportati ancora. Queste sono le versioni che uso e se volete usare una versione stabile (4.5.3 as of 07/06/12) trovate il link su google.

Step 3. Modifiche

Questa è la parte che incuriosisce la gente, loro vorrebbero sapere come fare modifiche al kernel e renderlo speciale. Comincia tutto questo che viene dalla root directory (~/android/kernel) del sorgente del kernel.

Mod 1. Applicare una patch

A. Scarica la patch che vuoi applicare, in questo caso questa dovrebbe funzionare.

B. Salvate il file come "kernelPatch" nella vostra directory del kernel

C. Aprite un terminale

D. Spostate dentro la root del vostro kernel la directory del kernel che volete patchare

E. Digitate "patch -p1 < ../kernelPatch"

Spiegazione:
A. Semplice, ci serve una patch. La patch in se stessa è semplice e differisce dall'originale albero (tree) del codice del kernel.
Posterà un veloce tutoria su come creare una patch nel terzo post. La patch sopra contiene diversi governor da aggiungere al vostro kernel.

B. Si spiega da sé.
C. Si spiega da sé.
D. Si spiega da sé.
E. In pratica lanciamo il comando della patch sulla nostra sorgente usando la patch che abbiamo scaricato prima. La porzione della patch è il binario, l'opzione "-p1" ci consente di controllare il numero di successivi slash (/) da rimuovere dal percorso del file (vi servirà di guardare quest'opzione più che usare una strana struttura di directory o di applicare le patch da un posto a casaccio) L'operatore "<" dirige il contenuto del nostro file "../kernelPatch" nel comando.

Mod 2. Aggoiungere un singolo governor

A. Aprite "drivers/cpufreq/Kconfig"

B. Aggiungete le seguenti stringe in uno spazio appropriato tra gli altri governorAdd the following lines in appropriate spot amongst the other govenor's

config CPU_FREQ_DEFAULT_GOV_SMARTASS
            bool "smartass"
            select CPU_FREQ_GOV_SMARTASS
            select CPU_FREQ_GOV_PERFORMANCE
            help
              Use the CPUFreq governor 'smartass' as default.

config CPU_FREQ_GOV_SMARTASS
           tristate "'smartass' cpufreq governor"
           depends on CPU_FREQ
           help
             smartass' - a "smart" optimized governor!
             If in doubt, say N.

C. Aprite "drivers/cpufreq/Makefile"
D. Aggiungete le seguenti stringhe in uno spazio appropriato.

    obj-$(CONFIG_CPU_FREQ_GOV_SMARTASS)     += cpufreq_smartass.o

E. Create a file chiamato "drivers/cpufreq/cpufreq_smartass.c" (l'ha spiegato un po' a cazzo di cane, il file è cpufreq_smartass.c dentro la direcotry drivers/cpufreq).

F. Inserite il sequente codice in quel file
[C] Smartass Kernel Govenor - Pastebin.com

G. Aprite "include/linux/cpufreq.h"

H. Sotto la sezione "Cpufreq Default" aggiugnete

#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_SMARTASS)
extern struct cpufreq_governor cpufreq_gov_smartass;
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_smartass)

Ok, c'è un governor aggiunto, fate gli stessi identici step per qualunque altro governor che vogliate aggiungere.

Spiegazione:

A. Aprite un file che avete già. Il Kconfig file ci lega dentro il nostro comando "make menuconfig" più tardi, facendo sì che la nostra mod sia un'opzione selezionabile.

B. Aggiungete il codice appropriato per il nostro governor per avere il nostro file .config. Il primo trancio ci permette di settare il nostro governor come default per il nostro kernel, l'altro ci permette di rimuoverlo o aggiungerlo alla build come vogliamo.

E-F. La creazione del governor stesso, non saltate questo passo. Suggerisco di leggere attrraverso questo codice per capire come funziona, è qualcosa di strepitoso.

G-H. Apre un file e aggiunge il codice necessario per legare il nostro modulo al resto del sorgente. Senza questo non saremo capaci di compilare il dovuto resto del sorgente senza conoscere se il modulo esiste.

Step 4. Ottenere un file config

Opzione A. Prendere un config file da un kernel.

A. Agganciare un device che sta usando un kernel simile al tuo e usarlo come base.

B. Aprite un terminale.

C. Andate nella vostra directory root del kernel.

D. Digitate "adb pull /proc/config.gz"

E. Digitate "gunzip config.gz"

F. Digitate "mv config arch/arm/configs/<your_config_name>_defconfig"

Spiegazione:

A. Questo vi permetterà di prendere un file di configurazione da un kernel che sapete funzionare. È molto più facile iniziare così. Come nota, non tutti i kernel supportano quest'opzione, così devi provarne diversi prima di avere il file funzionante. Se non funziona, guarda l'opzione B.

B. Hehe, ormai sei bravo a farlo.

C. Naviga verso la parte più alta della directory del tuo kernel.

D. Usa adb per prendere una copia del file config per i tuoi sorgenti.

E. Unzippa il file di configurazione.

F. Sposta il file di configurazione che hai preso verso la directory di configo così possiamo usarlo come referenza più tardi.

Opzione B. Usare il config del produttore.

Sfortunatamente, come detto sopra, non tutti i kernel supportano il metodo "/proc/config.gz". Puoi trovare un file di configurazione tipicamente nel percorso di configurazione del produttore "arch/arm/configs". Credo che quello per il mio HTC Flyer è chiamato "flyer_hc_defconfig", così dovrebbe essere (almeno simile) per te Inoltre leggi i readme per farti un'idea di come modificarli. Io farei una copia di esso chiamata "<your_config_name>_defconfig" e usarla come mia base.

[KlaasMad]

Step 5. Building

È tempo di partire col vero atto del building.

Part A. Step prebuild.

A. Apri un terminale e vai nella root del tuo kernel

B. Digitate "export ARCH=arm"

C. Digitate "export CROSS_COMPILE=~/android/kernel/toolchains/arm-eabi-linaro-4.6.2/bin/arm-eabi-"

Part B. La prima build.

A. Digitate "make <your_config_name>_defconfig"

B. Digitate "make menuconfig" e fate i cambiamenti richiesti per usare qualsiasi modulo avete aggiunto.

C. Digitate "make -j<maximum number of jobs>" (I jobs sono le operazioni per volta che la macchina esegue. Solitamente si fa [numero di core del pc] x2, ma tanti tengono la tesi di [numero di core del pc]+1. Io personalmente quando buildo faccio make -j8 ossia 4 core x2.)

Part C. Re-Builds

A. Digitate "make clean"

B. Digitate "make oldconfig"

C. Digitate "make -j<maximum number of jobs>"

Part D. Building i moduli

Avete due opzioni:

A. Digitate "make modules"

B. Digitate "make path/to/your/module.ko"

Spiegazione:

Parte A. (Questi step sono richiesti ogni volta che chiudi il terminale e lo riapriThese steps are required every time you close your terminal and re-open it to build again.)

A. Ok, non lo spiego più.

B. Questo comando setta il tuo obbiettivo dell'architettura (arm, x86, powerpc etc)

C. Definisce il percorso per il toolchain che stiamo per usare per compilare il kernel. Puoi cambiarlo indicando il percorso di qualunque toolchain hai scaricato o ti senti di usare. Il modo in cui è configurato è per usare il toolchain Linaro usato sopra.

Parte B. (Questi devono essere eseguire la prima volta che buildi il kernel)

A. Carica il tuo file di configurazione da prima.

B. Apri un meno per configurare il kernel. Userà il file di config caricato nel precedenti step come basi.

C. L'inizio del build. Tipicamente permetto un job per core, così sulla mia macchina quad core metto "make -j4". Aumentare il numero non renderà la build più velocemente, il tuo processore deve essere in grado di supportare i jobs che gli stai assegnando.

Parte C. (usate i comandi quando build qualsiasi volta che non sia la prima)

A. Questo comando soddisfa ogni vecchio binario o modulo che avete compilato prima e iniziamolo daccapo. Mi piace eseguirlo ogni build, a meno che i miei cambiamenti piccoli e localizzati.

B. Un meraviglioso comando: analizza quello che ha cambiato e ti conduce verso le nuove opzioni.

C. Vedi la spiegazione per la parte C sopra.

Parte D.(usa questi per buildare i moduli del kernel

A. Quest ribuilderà tutti i moduli.

B. Rebuilderà solo il modulo che ti serve. Utilissimo quando dovrai rebuildare il modulo wifi.

Step 6. Ed ora?

Ok, abbiamo cominciato a buildare ed aspettiamo che finisca. Quali sono i possibili risultati?

Risultato A. La build riesce

Grande! Hai buildato il tuo primo kernel dai sorgenti! Ci sono un paio di cose che ti serviranno per usare questo kernel nel tuo device: qualsiasi modulo ".ko" (kernel object) e i binary zImage. Se presti attentione all'output del compilatore, vedrai la locazione di questi oggetti. Comunque i seguenti comandi ti renderanno la vita un pelo più semplice:

A. Aprite un terminal

B. Andate nella root directory del kernel

C. Digitate "mkdir ../<tuo_kernel>_output"

D. Digitate "cp arch/arm/boot/zImage ../<tuo_kernel>_output/zImage"

E. Digitate "find . -name "*.ko" -exec cp {} ../<your_kernel>_output \;"

Spiegazione:

A-C. Si spiegano da sé

D. Spostate i binari del nostro kernel nella cartella di output

E. Questo tocco di magia trova tutti i moduli .ko e li copia nel file di output.

Vi servirà inoltre di assemblare l'immagine del kernel contenente gli iniramfs per il vostro device, assieme ai binari del kernel. Quello comunque è oltre lo scopo di questa guida. Per iniziare, provate a cercare le sequenti frasi.

building android kernel image
xda build kernel image
xda unpack boot.img

Risultato B. La build fallisce

Oh, è fallita. Beh, sai cosa, succederà un sacco di volte. Googla e sperimenta diverse soluzioni. I seguenti consigli cercheranno di aiutarti nel debug.

Esegui una build pulita.

A. Backuppa il tuo file di config (digitate "cp .config ../backupConfig")
B. Ri-eseguite il processo di build usando il vostro defconfig dall'inizio.

Limitate l'output

A. Un altro buon consiglio è quello di eseguire "make -j1" per capire dove sta l'errore, così il testo di output nel terminale sarà più lento e potrete scovarlo.

[KlaasMad]

Buildare il kernel Dorimanx

Vi propongo questo breve tutorial su come buildare il celebre kernel Dorimanx, il quale thread, su Androidiani, lo potete trovare qui.
Come sopra, non sono un developer, sono solo un appassionato di modding che si affaccia al mondo del development, per cui posso aiutarvi solo dove la mia (piccola) esperienza arriva. Il thread comunque è un ottimo modo per crescere insieme.

Prerequisiti

- un pc
- una distro Linux con architettura a 64 bit (assolutamente necessario questo requisito!)
- confidenza con il terminale Linux
- un cervello acceso

Preparazione

È necessario installare alcuni pacchetti indispensabili per buildare (altrimenti il toolchain Linaro fallirà l'esecuzione), per cui diamo da terminale:

sudo apt-get install ia32-libs lib32ncurses5-dev ccache imagemagick libxml2-utils optipng zip tar bash vim

Settate il vostro ssh nel bash

sudo chsh -s /bin/bash NOMEVOSTROUTENTE

Settate i permessi alla cartella /tmp

sudo chmod -R 777 /tmp

Dopo di ché, pulitela

sudo rm -rf /tmp/*

Installate un editor di testo, Dorimanx usa vim.

export EDITOR=/usr/bin/vim
update-alternatives --config editor

Nella schermata, scegliete /usr/bin/vim.basic

echo "syntax on" > $HOME/.vimrc
echo "colo elflord" >> $HOME/.vimrc

Preparazione dei sorgenti

Cominciamo con la clonazione vera e propria
Installiamo git (se già non lo avete):

sudo apt-get install git

Creiamo la cartella di lavoro. Chiamatela samsung-i9100, altrimenti vi darà un mucchio di problemi.

mkdir ~/samsung-i9100
cd ~/samsung-i9100

Ora cloniamo i file da remoto che ci servono:

git clone https://github.com/dorimanx/Dorimanx-SG2-I9100-Kernel.git
git clone https://github.com/dorimanx/initramfs3.git

Ora, se avete già settato git precedentemente, non è necessaria questa pratica. Al contrario, è necessario configurarlo per bene:
Entrate nella cartella del kernel:

cd ~/samsung-i9100/Dorimanx-SG2-I9100-Kernel

Identificati tramite git.

git config --global user.name VOSTRO NOME
git config --global user.email VOSTRAEMAIL

Ora è tempo di settare alcuni parametri. Copincollate semplicemente sul vostro terminale, un comando per volta.

git config --global push.default simple
git config --global alias.last 'log -1 HEAD'
git config --global alias.unstage 'reset HEAD --'
git config --global alias.hard 'reset --hard'
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global color.diff auto
git config --global color.ui auto
git config --global color.status auto
git config --global color.branch auto

Ora, tramite questo comando, avrete una visione panoramica di tutti quanti i settaggi imposti finora:

git config -l

Settate i comandi di auto completamento per git quando usate il terminale.

cp /usr/share/git/completion/git-completion.bash ~/.git-completion.bash
vi ~/.bashrc

Aggiungete questo alla fine del file che vi aprirà l'editor di testo:

source ~/.git-completion.bash

Salvate con shift :wq.

NB. potete usare anche altri editor di testo, consiglio gedit.

Chiudete la finestra del terminale e riapritela per far ripartire da zero.

Tempo di buildare!

Loggatevi come utente root:

sudo su

Entrate nella cartella del kernel:

cd ~/samsung-i9100/Dorimanx-SG2-I9100-Kernel

Avviate lo script di configurazione:

./load_config.sh

Avviate il processo di building attraverso il relativo script:

./build_kernel.sh

FATTO!

Dopo un periodo di tempo variabile a seconda della macchina che si usa, avrete pronto il vostro kernel Dorimanx homemade nella cartella READY-JB!

[KlaasMad]

Buildare il kernel Jeboo

1. Scaricate tutte le dipendenze (java, android sdk, etc, vedete i post sopra) per il vostro sistema operativo.

2. Scaricate il toolchain GCC 4.4.3: lo trovate in un sacco di posti, ma eccovi una copia qui. Estraete il toolchain nella cartella superiore a quella del progetto dove avete deciso di lavorare.

3. Ora create la cartella e clonate i git del kernel e degli initramfs. L'initramfs dovrebbe essere nel percorso ../initramfs dal kernel:
Per cui digitate da terminale

git clone https://github.com/jeboo/kernel_JB_ZSLS6_i9100.git
git clone https://github.com/jeboo/initramfs_XXLSJ.git ./initramfs

4. Ora andate nella cartella del kernel e modificate il file mk.sh. Dovrete sistemare la variabile CROSS_COMPILE variable (seconda riga) per far corrispondere il toolchain (del quale abbiamo parlato nel secondo punto).

5. Ora dobbiamo eseguire 'make u1_defconfig' che creerà '.config'. Il file u1_defconfig è posto in arch/arm/configs, giusto se avete intenzione di modificare qualche settaggio del build.

6. Se tutto va bene, ora tutto quello che vi resta è eseguire il file mk.sh tramite il comando

./mk.sh

in modo da avere la vostra zImage. Ci sono due righe in mk.sh che vi produrranno un errore a causa del fatto che sono editate secondo la compilazione di Jeboo (l'autore):
- riga 12 'cp -v ..' che copia l'ultima build della CWM di Jeboo (sempre inteso come l'autore) nella cartella del kernel
- la riga 14 che builda un tar flashabile da Odin.
Per quanto riguarda l'errore della CWM non preoccupatevi, c'è una copia nella cartella del kernel.
Per quanto riguarda l'altro errore, ecco lo script per creare il file .tar:

#!/bin/bash
#NOTE: If you use maketar.sh at the end, you should add a simple file .name (to kernel dir) with 1 line containing the name to use in the tar file name.
CURR_KERN="$(cat .name)_"
CURR_DATE="$CURR_KERN$(date +%b%d_%H%M)"
tar -H ustar -c zImage >> cust_kernel_$CURR_DATE.tar
md5sum -t cust_kernel_$CURR_DATE.tar >> cust_kernel_$CURR_DATE.tar
mv cust_kernel_$CURR_DATE.tar cust_kernel_$CURR_DATE.tar.md5
echo Created cust_kernel_$CURR_DATE.tar.md5

7. La prima volta che buildate il kernel, siate sicuri di eseguire una seconda volta mk.sh sempre tramite il comando

./mk.sh

per assicurarvi che initramfs abbia installato in maniera appropriata /lib/modules.

Avete, ora, buildato il vostro Jeboo kernel in maniera corretta!

[KlaasMad]

Riservato #3

[N1m0Y]

Risevato #4 for kernel Apolo (se riesco a buildare )

Grazie amico:beer::beer::beer:

[Brrmatteo]

Miooooooooo
Bella guida appena posso la provo

[Anna]

Facciamo così.
Decidete in privato dove metterla e poi ce lo fate sapere per pm

Inviato dal mio GT-I9505 usando Androidiani App

[N1m0Y]

Ubuntu 12.04 ce l'ho già.... appena ho un attimo proverò a fare qualcosa


Promemoria:
questo è il metodo di Jeboo: http://forum.xda-developers.com/show...php?p=36625818

[KlaasMad]

Ubuntu 12.04 ce l'ho già.... appena ho un attimo proverò a fare qualcosa

È uscito ubuntu 13.10 al quale hanno alleggerito Unity per renderlo più performante, te lo consiglio rispetto alla lts, visto che le risorse del PC ti serviranno per i make -jx (3 ore per buildare 20gb di roba oggi con 4 core).
Poi ognuno è libero di buildare dove vuole, anche la distro del team BBQ è ottima e già pronta a tutto, ma sinceramente mi trovo meglio con apt che con pacman.

No, non vedo il motivo di sentire qualcun altro.
La sezione corretta può essere sia questa che quella e a noi mod di sezione non cambia assolutamente niente se viene spostata. Dalle tue parole sembra quasi che noi non vogliamo spostarla...






Facciamo così. ..
Visto che il thread è stato riempito di ot ora io cancello ogni post tranne quelli relativi o riservati alla guida.
Poi dionysus che l'ha aperta decide dove vuole tenerla... oppure se la guida è di entrambi prima decidete in privato dove metterla e poi ce lo fate sapere per pm così evitiamo altri ot.

Inviato dal mio GT-I9505 usando Androidiani App

Ora ci mettiamo d'accordo tra di noi e ti faccio sapere in pvt onde non inquinare il thread. Grazie capo.

Spoiler:

vedi che ti ho letto nel thread che avete chiuso >:[