Custom Kernel Compilation with ABS (Italiano)

From ArchWiki
Revision as of 00:04, 13 March 2010 by Mr.Elendig (Talk | contribs) (Flagged out of date. More or less all the info is wrong/not relevant anymore)

Jump to: navigation, search


Tango-view-refresh-red.pngThis article or section is out of date.Tango-view-refresh-red.png

Reason: please use the first argument of the template to provide a brief explanation. (Discuss in Talk:Custom Kernel Compilation with ABS (Italiano)#)

This template has only maintenance purposes. For linking to local translations please use interlanguage links, see Help:i18n#Interlanguage links.


Local languages: Català – Dansk – English – Español – Esperanto – Hrvatski – Indonesia – Italiano – Lietuviškai – Magyar – Nederlands – Norsk Bokmål – Polski – Português – Slovenský – Česky – Ελληνικά – Български – Русский – Српски – Українська – עברית – العربية – ไทย – 日本語 – 正體中文 – 简体中文 – 한국어


External languages (all articles in these languages should be moved to the external wiki): Deutsch – Français – Română – Suomi – Svenska – Tiếng Việt – Türkçe – فارسی

Introduzione

Potete scegliere di compilare il vostro kernel nel modo tradizionale, oppure usando la guida ABS. Alcuni utenti Arch preferiscono il modo tradizionale, comunque usare ABS è di auto per automatizzare alcuni compiti. La scelta è vostra, nessun modo è in assoluto migliore dell'altro.

Questo howto è stato aggiornato per offrire un PKGBUILD definitivo per la creazione del pacchetto del kernel. Esso permette di mantenere più kernel con un unico schema per la truttura del nome, sotto il controllo di pacman. Il PKGBUILD considera automaticamente le variabili EXTRAVERSION e LOCALVERSION, variabili pienamente supportate dal kernel.

  • EXTRAVERSION è usata dai maggiori "set di patch" come -ck e -nitro.
  • EXTRAVERSION è usata anche nel ramo 2.6.x.y per le varianti .y.
  • LOCALVERSION può invece essere settata durante la configurazione ed è il modo più semplice e RACCOMANDATO per personalizzare il pkgnames del vostro kernel.

Settate semplicemente LOCALVERSION a -custom oppure il suffisso sarà la data e.s. -20050105! Un LOCALVERSION unico garantisce un pacchetto unico.

Filosofia e logica (come lavora e perchè lavora in questo modo)

  • Nella filosofia di Arch - Semplice è meglio.
  • Questo PKGBUILD, costruito sui precedenti, è una versione largamente condivisa.
  • Questa versione fornisce pacchetti kernel e componenti con un semplice, logico e non complicato schema di nomi che, SOLO le variabili che sono parte del sistema ABS, e parte della compilazione del kernel possono variare.
    • Il kernel di default di Arch usa il nome di base kernel26 che viene esteso con lo schema 2.6.x e 2.6.x.y es. kernel2611 e kernel26117
      Questi danno anche il nome ai file in /boot es. vmlinux26 e vmlinuz26117
    • Il processo di compilazione del kernel usa la versione del kernel (2.6.x), prendendo EXTRAVERSION dal Makefile e CONFIG_LOCALVERSION dal config del kernel per creare il nome per la directory dei moduli del kernel, es. :


2.6.x$EXTRAVERSION$LOCALVERSION
2.6.11-cko2-ARCH/


Questa parte è sotto il controllo del PKGBUILD quindi per creare un pkg dei componenti con nomi simili il PKGBUILD usa lo stesso schema per creare file unici sotto /boot e directory uniche sotto /usr/src aggiungendo -EXTRAVERSION-LOCALVERSION, es.:
/boot/vmlinuz2611-cko2-ARCH
/boot/System.map2611-cko2-ARCH
/boot/kconfig2611-cko2-ARCH

/usr/src/linux-2.6.11-cko2-ARCH/


  • Se avete una buona conoscenza di ABS potete osservare che il PKGBUILD è stato costruito in maniera trasparente, auto-esplicativa e facilmente personalizzabile.
  • Gli input dell'utente sono pressoché identici a tutti i pacchetti ABS: vanno semplicemente settati pkgver, pkgrel, e pkgdesc e aggiunte sorgenti addizionali, incluse patch, all'array source. Gli utenti che vogliono inserire Patch dovrebbero inserire il comando appropriato dove indicato. A parte la configurazione e la scelta di usare il make clean o no il resto della compilazione è automatica.
  • Avendo creato un nome del pacchetto durante la costruzione, il PKGBUILD si corregge e aggiorna automaticamente con il nuovo pkgname permettendo le operazioni come il gensync.

ATTENZIONE

  1. Questo PKGBUILD è creato solo per il ramo 2.6 del kernel - il kernel 2.4 non è supportato da Arch Linux (news)
  2. Questo NON è un howto ABS - per capire questo HOWTO è ESSENZIALE una conoscenza su come "costruire" i pacchetti con ABS - per favore leggete ABS - The Arch Build System, Creating Packages e Patching in ABS

Non si consiglia di "costruire" un pacchetto kernel come primo progetto ABS. Se è necessario aiuto per usare fakeroot o per costruire una directory di build si legga l'altra documentazione.

  1. Allo stesso modo è utile conoscere come configurare un kernel! Se questa è la prima esperienza è Fortemente raccomandato iniziare con la configurazione di default di Arch, come spiegato meglio di seguito.

Note

  • pkgname viene dichiarato nelle prime 10 righe del PKGBUILD - quindi NON toccatele - lasciatele semplicemente dove sono.

Se non lo fate il PKGBUILD non aggiornerà il pkgname automaticamente quando avrà finito di creare il pacchetto. Potrete comunque usare gensync MA dovrete editare il PKGBUILD manualmente ogni volta.

  • Finchè non avrete la vostra configurazione funzionante, la cosa più semplice è quella di iniziare con la configurazione di default di Arch; è possibile anche usare il file kernel26.install, creare un kernel26.install personalizzato o commentare la linea install=kernel26.install nel PKGBUILD. I file ufficiali di Arch sono entrambi nelle directory ABS, normalmente si trovano in /var/abs/kernels/kernel26. Per scaricare tutto "l'albero" di ABS sul vostro sistema basterà lanciare semplicemente abs da root.
NOTE: Se si usa Lilo o un altro bootloader statico sarà necessario reinstallarlo al termine della compilazione del vostro kernel personalizzato. Di seguito un esempio di kernel26.install nel caso si utilizzi LILO:
# arg 1:  the new package version
# arg 2:  the old package version

# Script by Jouke Witteveen (j <dot> witteveen <at> gmail)
# Revision: 4

link () {
  dialog --backtitle "$ba" --title Linking --yesno
  "\nDo you want to link /vmlinuz to the $ke kernel?\n(This can be useful for configuring your bootloader)" 9 60 &&{
    [ -e /vmlinuz -o -h /vmlinuz ] &&\
      mv -f /vmlinuz /vmlinuz.old
    kern () {
      ls -t /boot/vmlinuz$1* 2> /dev/null | head -n 1
    }
    vm=`kern \`echo $1 | sed "s|\.||g"\``
    [ ! -e "$vm" ] &&\
      vm=`kern`
    ln -s $vm /vmlinuz
  }
}

exec () {
  dialog --backtitle "$ba" --title "Bootloader execution" --yesno
  "\nDo you want to run Lilo to make the $ke kernel bootable?\n\n\
Remember: If you choose 'No' now you will not be able to boot the $ke kernel until you manually update your bootloader!" 12 60 &&\
    lilo &&\
      echo -e $1   # At least Lilo did not return an error
}

warn () {
  dialog --backtitle "$ba" --title Warning --msgbox
  "\nYou will not be able to boot the $ke kernel until you manually update your bootloader." 9 60
}


post_install () {
  ba="Installing kernel $1"
  ke="new"
  link $1 &&\
    exec "\nKernel $1 successfully installed!\n" ||\
      warn
}

post_upgrade () {
  ba="Upgrading kernel $2 to kernel $1"
  ke="upgraded"
  link $1
  exec "\nKernel $2 successfully upgraded to version $1!\n" ||\
    warn
}

post_remove () {
  unli () {
    [ -h $1 -a ! -e $1 ] &&\
      unlink $1
  }
  unli /vmlinuz
  unli /vmlinuz.old
  [ -e /vmlinuz.old -a ! -e /vmlinuz ] &&{
    ba="Removing kernel $1"
    ke="old"
    mv /vmlinuz.old /vmlinuz
    exec "\nThe old kernel was successfully restored\n" ||\
      warn
  }
}


op=$1
shift

$op $*


  • Per verificare se la variabile EXTRAVERSION è settato nel vostro patchset provate con
grep +EXTRAVERSION= ./patchname
il comando dovrebbe tornare una riga tipo:
+EXTRAVERSION = -ck3
Se così non fosse, probabilmente la variabile non è settata e dovreste assicurarvi di aver usato LOCALVERSION per personalizzare il nome del pacchetto.
Nei kernel di default di Arch la variabile LOCALVERSION è settata a -ARCH - voi potrete settarla a vostro piacimento (es. -custom) (da notare la presenza del trattino -)
  • Se usato correttamente, questo PKGBUILD dovrebbe fornire sempre un kernel unico basato su EXTRAVERSION e LOCALVERSION, e su pkgver e pkgrel - d'altra parte è compito dell'utente controllare il nome del pacchetto risultante e il contenuto prima dell'installazione, per prevenire la sovrascrittura (si veda di seguito per maggiori dettagli ed esempi).

Configurare PKGBUILD

Copiare il PKGBUILD nella vostra $startdir. Il PKGBUILD può inoltre essere scaricato da here.Prima di iniziare è necessario ricordare le seguenti cose:

  1. pkgname può essere lasciato com'è; sarà settato automaticamente e corretto.
  2. Inserire il pkgver per il vostro kernel (ad esempio: 2.6.9).
  3. Modificare pkgrel per la vostra revisione. Tale variabile dovrebbe essere incrementarla ogni qual volta che un cambiamento alla configurazione del kernel fosse effettuato o quando si volesse creare un pacchetto per rimpiazzare il vecchio. Se non si volesse rimpiazzare la build precedente ma semplicemente installare una nuova versione in parallelo si dovrebbe utilizzare la variabile LOCALVERSION per creare un pacchetto unico.
  4. Modificare la variabile pkgdesc per descrivere ogni patches o opzioni di configurazione applicate.
  5. Modificare i sorgenti aggiungendo le patch all'array source.
  6. {OPZIONALE} Inserire i comandi della patch dove indicato.
  7. Scegliere un metodo di make lasciando tale metodo non commentato - gconfig (basato su gtk) xconfig (basato su qt) menuconfig (basato su ncurses).
  8. Durante la creazione vi sarà chiesto se si vuole eseguire un make clean - la risposta di default è yes, rispondete NO se sapete quello che state facendo.
# Contributor: dibblethewrecker <dibblethewrecker.at.jiwe.org>
pkgname=kernel26
pkgver=2.6.x.y
pkgrel=1
pkgdesc="The Linux Kernel 2.6.x.y and modules (IDE support)"
url="http://www.kernel.org"
depends=('module-init-tools')
install=kernel26.install
arch=(i686 x86_64)
license=('GPL')

##### add any patch sources to this section
source=(config ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-$pkgver.tar.bz2 )

# Function to grab var from src
getvar() {
  old=$(cat Makefile | grep "^$1")
  echo $(echo ${old/"$1 ="/} | sed -e "s/[ ]*\(.*\)[ ]*/\1/g")
  return 0
}

build() {
  cd $startdir/src/linux-$pkgver

  ##### Uncomment and apply any patches here
  #patch -Np1 -i ../patchname || return 1

  # get rid of the 'i' in i686
  carch=`echo $CARCH | sed 's|i||'`
  cat ../config | sed "s|#CARCH#|$carch|g" >./.config

  ##### Load config - uncomment your preferred config method
  #yes "" | make config
  #make oldconfig || return 1
  #make menuconfig
  #make xconfig
  make gconfig

  ##### NO USER CHANGES BELOW HERE #####

  # save the current pkgname
  old_pkgname=$pkgname

  # set pkgname for build purposes - DO NOT alter!
  pkgname=kernel26

  # save the updated config to build with today's date
  cp ./.config $startdir/config-$(date +%b%d\-%Hh)

  # get EXTRAVERSION from Makefile to create a unique pkgname and /usr/src directory
  _kernextra=$(getvar "EXTRAVERSION")
  # grab the 2.6.x.y version suffix from pkgver
  _y="`echo $pkgver | cut --delim "." --fields 4`"
  # remove .y version suffix from _kernextra
  _kernextra="`echo $_kernextra | sed "s|\.$_y||g"`"

  # Read the full kernel version info from new config to use in pathnames and pkgname
  . ./.config

  # Kernel custom - to create a unique pkgname (see below)
  _kerncust="${_kernextra}${CONFIG_LOCALVERSION}"
  # Kernel release - will be the same as Makefile
  _kernrel="${pkgver}${_kerncust}"
  # Get the pkgver suffix for unique pkgname and /boot file suffices
  _pkgversuf="`echo $pkgver | sed "s|2.6.||g" | sed "s|\.||g"`"
  # Set /boot file suffices from kernel release and pkgver suffix
  _kernboot="${_pkgversuf}${_kerncust}"

  # Set a new pkgname from  kernel release and pkgver suffix
  pkgname="${pkgname}${_pkgversuf}${_kerncust}"

  # build!
  echo
  echo -n "Do you want to make clean (default YES)? (YES/NO): "
  read choice
  echo
  echo -n "Press any key to start make or CTRL+C to quit"
  read anykey

  if [ "${choice}" = "NO" ] ; then
  	make bzImage modules || return 1
  else
	make clean bzImage modules || return 1
  fi

  mkdir -p $startdir/pkg/{lib/modules,boot}
  make INSTALL_MOD_PATH=$startdir/pkg modules_install || return 1
  cp System.map $startdir/pkg/boot/System.map26${_kernboot}
  cp arch/i386/boot/bzImage $startdir/pkg/boot/vmlinuz26${_kernboot}
  install -D -m644 Makefile \
    $startdir/pkg/usr/src/linux-${_kernrel}/Makefile
  install -D -m644 kernel/Makefile \
    $startdir/pkg/usr/src/linux-${_kernrel}/kernel/Makefile
  install -D -m644 .config \
    $startdir/pkg/usr/src/linux-${_kernrel}/.config
  install -D -m644 .kernelrelease \
    $startdir/pkg/usr/src/linux-${_kernrel}/.kernelrelease
  install -D -m644 .config $startdir/pkg/boot/kconfig26${_kernboot}
  mkdir -p $startdir/pkg/usr/src/linux-${_kernrel}/include
  mkdir -p $startdir/pkg/usr/src/linux-${_kernrel}/arch/i386/kernel
  for i in acpi asm-generic asm-i386 config linux math-emu media net pcmcia scsi sound video; do
    cp -a include/$i $startdir/pkg/usr/src/linux-${_kernrel}/include/
  done
  # copy files necessary for later builds, like nvidia and vmware
  cp Module.symvers $startdir/pkg/usr/src/linux-${_kernrel}
  cp -a scripts $startdir/pkg/usr/src/linux-${_kernrel}
  mkdir -p $startdir/pkg/usr/src/linux-${_kernrel}/.tmp_versions
  cp arch/i386/Makefile $startdir/pkg/usr/src/linux-${_kernrel}/arch/i386/
  cp arch/i386/Makefile.cpu $startdir/pkg/usr/src/linux-${_kernrel}/arch/i386/
  cp arch/i386/kernel/asm-offsets.s \
    $startdir/pkg/usr/src/linux-${_kernrel}/arch/i386/kernel/
  # copy in Kconfig files
  for i in `find . -name "Kconfig*"`; do
    mkdir -p $startdir/pkg/usr/src/linux-${_kernrel}/`echo $i | sed 's|/Kconfig.*||'`
    cp $i $startdir/pkg/usr/src/linux-${_kernrel}/$i
  done
  cd $startdir/pkg/usr/src/linux-${_kernrel}/include && ln -s asm-i386 asm
  chown -R root.root $startdir/pkg/usr/src/linux-${_kernrel}
  cd $startdir/pkg/lib/modules/${_kernrel} && \
    (rm -f source build; ln -sf /usr/src/linux-${_kernrel} build)

  # Correct the pkgname in our PKGBUILD - this allows correct gensync operation
  # NOTE: pkgname variable must be declared with first 10 lines of PKGBUILD!
  cd $startdir
  sed -i "1,11 s|pkgname=$old_pkgname|pkgname=$pkgname|" ./PKGBUILD
}
# vim:syntax=sh
  • Istallate il vostro nuovo pacchetto normalmente.

Il vostro file config

DA NOTARE: durante la creazione, la configurazione finale è memorizzata nella vostra $startdir come, per esempio, config-Apr13-12h. La configurazione originale rimarrà nella $startdir con nome config.Se si volesse usare la nuova configurazione per una nuova build, fate attenzione a copiare il file giusto!

Aggiornare il Bootloader

  • Ricordare di editare la configurazione di LILO o GRUB per includere una nuova entry per il nuovo kernel. Il nuovo kernel si affiancherà al vecchio, quindi potrete lasciare un riferimento al vecchio kernel nella configurazione del bootloader finché non sarete sicuri che il vostro kernel funzioni. QUESTO COMPORTAMENTO È FORTEMENTE RACCOMANDATO!
  • Se usate lilo, ricordate di lanciare lilo per aggiornarlo.

Voglio il logo di Arch!

Si copi logo_linux_clut224.ppm da /var/abs/core/base/kernel26 nella vostra $startdir e si aggiunga logo_linux_clut224.ppm all'array dei sorgenti. Poi è necessario incollare i testo segnalato con (>>) nel PKGBUILD come indicato:

   ##### Uncomment and apply any patches here
   #patch -Np1 -i ../patchname || return 1

>>  ##### Arch logo - not compatible with gensplash!
>>  cp ../logo_linux_clut224.ppm drivers/video/logo/

   # get rid of the 'i' in i686
   carch=`echo $CARCH | sed 's|i||'`
   cat ../config | sed "s|#CARCH#|$carch|g" >./.config

Il config di default di Arch usa i seguenti settaggi per il logo, assicuratevi di averli settati nella fase di configurazione:

#
# Logo configuration
#
CONFIG_LOGO=y
CONFIG_LOGO_LINUX_MONO=y
CONFIG_LOGO_LINUX_VGA16=y
CONFIG_LOGO_LINUX_CLUT224=y

Personalizzazioni e Usi Avanzati

Alcune persone hanno personalizzato il PKGBUILD per i loro bisogni, questo ha portato ad un approccio completamente differente. Una delle modifiche è raccomandata alle persone che realizzano più build della stessa versione del kernel, da usare in parallelo, è quella di aggiungere un comando sed che automaticamente setta la variabile CONFIG_LOCALVERSION nella configurazione in maniera univoca prima della fase di configurazione. Questa è basata sulla data, sull' hostname, ecc.

Ad esempio:

    # get rid of the 'i' in i686
    carch=`echo $CARCH | sed 's|i||'`
    cat ../config | sed "s|#CARCH#|$carch|g" >./.config

  >>  # set LOCALVERSION to -date
  >>  sed -i "s|CONFIG_LOCALVERSION=.*|CONFIG_LOCALVERSION=-`date +%y%m%d`|g" ./.config

    ##### Load config - uncomment your preferred config method
    #yes "" | make config

o

    # set LOCALVERSION to -date-hostname
    sed -i "s|CONFIG_LOCALVERSION=.*|CONFIG_LOCALVERSION=-`date +%y%m%d`-`hostname`|g" ./.config

Per renderla veramente unica LOCALVERSION può essere settata come 00:00:00 1970-01-01 UTC!

    sed -i "s|CONFIG_LOCALVERSION=.*|CONFIG_LOCALVERSION=-`date +%s`|g" ./.config

Usare i driver video nVIDIA con il vostro kernel

Per usare i driver nvidia con il vostro kernel, si veda: Come installare i driver nVIDIA con il vostro kernel personalizzato

Feedback

Se avete domande/commenti/suggerimenti riguardo al PKGBUILD sentitevi liberi di aggiungervi alla discussione su: http://bbs.archlinux.org/viewtopic.php?t=9272

Alcuni suggerimenti sono stati già inseriti, ma siete pregati di considerare la filosofia Keep It Simple e ricordate gli obbiettivi originali. La compilazione del kernel è un processo individuale e ci sono un ENORME varietà di modi di farlo. Questo PKGBUILD non vuole assolutamente coprire tutte le eventualità, siete liberi di modificarlo per soddisfare i vostri bisogni. I Migliori auguri!

DibbleTheWrecker