LKN: Programmi Utili: differenze tra le versioni

Vai alla navigazione Vai alla ricerca

LKN: Programmi Utili (visualizza wikitesto)

Versione delle 13:15, 28 giu 2013

15 157 byte aggiunti ,  28 giu 2013
nuova categoria
m (link corretto)
(nuova categoria)
 
(20 versioni intermedie di 5 utenti non mostrate)
Riga 1: Riga 1:
''Torna all'indice: [[Linux Kernel in a Nutshell]]''
{{Template:LKN}}
__TOC__
__TOC__


I precedenti capitoli hanno mostrato come scaricare e compilare il kernel. Ora che si ha un file eseguibile -- con tutti i moduli compilati -- � ora di installare il kernel e provare a fare il boot. In questo capitolo, a differenza dei precedenti, tutti i comandi necessitano di essere eseguiti come utente root. Questo  pu� essere fatto anteponendo ad ogni comando ''sudo'', usando il comando ''su'' per diventare root, oppure accedendo come ''root''.
Scaricare [da Internet, NdT], compilare, aggiornare e mantenere i sorgenti del kernel Linux comporta diversi passi, come questo libro illustra. Essendo per natura creature pigre, gli sviluppatori hanno creato alcuni programmi a supporto di queste attività di routine. Descriviamo alcuni di tali utili strumenti e le nozioni di base sul loro utilizzo.


Per vedere se si ha ''sudo'' installato e gli appropriati diritti di accesso, lanciate:
Lo sviluppo del kernel Linux differisce per molti aspetti dal tradizionale processo di sviluppo software. A uno sviluppatore del kernel sono richieste alcune attività peculiari:


<pre>
* Applicare le modifiche ad un "bersaglio mobile" quale è il kernel, a causa della rapida pianificazione delle versioni di sviluppo.
  $ sudo ls ~/linux/linux-2.6.17.11/Makefile
* Risolvere i conflitti derivanti dalla fusione del proprio lavoro con quello dagli altri sviluppatori.
  Password:
* Esportare i suoi cambiamenti in un formato che permetta agli altri sviluppatori di incorporarli facilmente nel proprio lavoro.
  Makefile
</pre>
 
Inserite la vostra password personale al prompt di password, o la password del system administrator (root). La scelta dipende da come il comando di ''sudo'' � stato impostato. Se non ci sono problemi, e si vede una linea che contiene:


<pre> Makefile </pre>
==patch e diff==
Questa sezione è basata su un articolo pubblicato originariamento su ''Linux Journal''.


allora potete passare alla prossima sezione.
Una delle modalità più comuni per lavorare con il kernel è quella di usare i programmi ''patch'' e ''diff''. Per usare questi strumenti, sono necessarie due differenti directory: una "pulita" (clean) e una "di lavoro" (indicata con ''dirty'' in seguito). La directory clean contiene la versione originale del kernel, mentre quella dirty contiene le modifiche apportate dal programmatore alla stessa release.
Utilizzando ''patch'' e ''diff'' è possibile estrarre i cambiamenti apportati sul sorgente e portarli nella nuova release del kernel.


Se ''sudo'' non � installato o non si hanno i diritti appropriati, si provi ad usare il comando ''su'':
Per esempio, creiamo due directory contenenti l'ultima versione del kernel come descritto nel Capitolo 3.


<pre>
<pre>
  $ su
$ tar -zxf linux-2.6.19.tar.gz
  Password:
$ mv linux-2.6.19 linux-2.6.19-dirty
  # exit
$ tar -zxf linux-2.6.19.tar.gz
  exit
$ ls
  $
linux-2.6.19/
linux-2.6.19-dirty/
</pre>
</pre>


Al prompt della password, inserite la password del system administrator (''root''). Quando ''su'' accetta con successo la password, si � trasferiti ad eseguire ognicosa con i pieni privilegi di root. State molto attenti mentre siete ''root'', e fate solo il minimo necessario; dopodich� uscite dal programma per tornare con il vostro utente normale.
Ora è possibile apportare tutte le modifiche desiderate al sorgente presente nella directory dirty, lasciando inalterata quella clean. Dopo aver apportato le modifiche, si potrà creare una patch da inviare agli altri sviluppatori tramite i seguenti comandi:


<pre>
$ diff -Naur -X linux-2.6.19/Documentation/dontdiff linux-2.6.19/ \
linux-2.6.19-dirty/ > my_patch
</pre>


== Usare uno script di installazione di una distribuzione ==
Questo comando creerà un file dal nome ''my_patch'' che conterrà tutti i cambiamenti apportati al sorgente del kernel rispetto alla versione pulita presente nella directory clean. Tale file potrà essere distribuito o inviato ad agli altri sviluppatori via email.




Quasi tutte le distribuzioni hanno uno script chiamato ''installkernel'' che pu� essere usato dal sistema di creazione del kernel per installarne uno pronto automaticamente nel giusto posto e per modificare il bootloader cos� che nulla di pi� debba essere fatto dallo sviluppatore *.
===Nuove versioni del kernel===
Al rilascio di una nuova versione del kernel, se si desidera portare i cambiamenti su questa nuova versione è necessario applicare la patch ad una versione ''pulita'' del kernel.
Questo può essere fatto seguendo questi passi:
* Creare la patch, come illustrato nell'esempio precedente.
* Utilizzare la patch ufficiale dal sito ''kernel.org'' e aggiornare la vecchia versione alla nuova release:


<pre>
<pre>
Le distribuzioni offrono installkernel solitamente in un package chiamato mkinitrd, provate ad installare
$ cd linux-2.6.19
questo package se non trovate lo script sulla vostra macchina.
$ patch -p1 < ../patch-2.6.20
$ cd ..
$ mv linux-2.6.19 linux-2.6.20
</pre>
</pre>


Se avete compilato qualsiasi modulo e volete usare questo metodo per installare un kernel, inserite:
* Aggiornare la directory di lavoro rimuovendo la propria patch e, in seguito, applicando il nuovo aggiornamento:
<pre>
$ cd linux-2.6.19-dirty
$ patch -p1 -R < ../my_patch
$ patch -p1 < ../patch-2.6.20
$ cd ..
$ mv linux-2.4.19-dirty linux-2.6.20-dirty
</pre>


'''# make modules_install'''
* Provare ad applicare la propria patch al nuovo aggiornamento:
<pre>
$ cd linux-2.6.20-dirty
$ patch -p1 < ../my_patch
</pre>


Questo installer� tutti i moduli che avete compilato e li metter� nelle appropriate locazioni del filesystem per farli trovare correttamente dal nuovo kernel. I moduli sono posti in ''/lib/modules/kernel_version'', dove per ''kernel_version'' si intende la versione del nuovo kernel che state preparando.
Se l'applicazione della patch provoca dei problemi, è necessario risolvere i conflitti creati (il comando ''patch'' informerà circa questi conflitti creando i file ''.rej'' e ''.orig'' per l'analisi e la correzioni da parte dello sviluppatore).  
Questo processo di ''fusione'' (''merge'') può rappresentare la parte più difficile dell'intero processo se sono stati apportati cambiamenti a porzioni di codice che sono state modificate anche da altri.


Dopo che i moduli sono stati installati con successo, l'immagine principale del kernel deve essere installata:
Per applicare correttamente questo processo di sviluppo, consiglio vivamente di utilizzare l'eccellente insieme di programmi ''patchutils'' (reperibile qui: ''http://cyberelk.net/tim/patchutils''). Questi programmi permettono di manipolare le patch facilmente e hanno risparmiato agli sviluppatori molte ore di tedioso lavoro.


'''# make install'''


Questo causer�:
== Gestire le proprie patch con quilt ==


1. Il sistema di creazione del kernel verificher� che il kernel sia stato correttamente costruito.
I programmi ''patch'' e ''diff'' risultano essere molto utili e funzionali per lo sviluppo del kernel. Ma dopo un certo periodo di utilizzo, molti si stancano di questo modo si procedere nello sviluppo e cercano altra strade che non coinvolgano le noiose attività di pacthing e merging. Fortunatamente, alcuni sviluppatori del kernel hanno realizzato un programma chiamato ''quilt'' che gestisce il processo di manipolazione delle patch in modo molto più semplice.


2. Il sistema di creazione copier� la parte statica nella directory ''/boot'' e rinominer� l'eseguibile sulla base della versione del kernel.
L'idea alla base di ''quilt'' discende da un insieme di script di Andrew Morton, realizzati originariamente per gestire il codice del sottosistema di gestione della memoria e, in seguito, utilizzati per l'intero kernel. I suoi script erano legati molto strettamente al processo di sviluppo, ma l'idea sottostante era molto potente.
Andreas Gruenbacher ha quindi ripreso questa idea creando ''quilt''.


3. Qualsiasi immagine di ramdisk iniziale necessaria verr� creata automaticamente, usando i moduli che sono appena stati installati durante la fase di ''modules_install''.
L'idea principale sottostante ''quilt'' è di lavorare con una versione ''pulita'' del kernel alla quale aggiungere un insieme di patch. E&grave; possibile inserire e togliere diverse patch dal sorgente e mantenere una lista delle patch in modo molto semplice.


4. Al programma di bootloader verr� correttamente notificato che un nuovo kernel � presente, e verr� aggiunto nel giusto menu cos� che l'utente possa selezionarlo la prossima volta che la macchina verr� avviata.
1. Per iniziare, creiamo una directory contenente il sorgente del kernel:
<pre>
$ tar -zxf linux-2.6.19.tar.gz
$ ls
linux-2.6.19/
</pre>


5. Dopo questo ha finito, il kernel � installato con successo, si pu� tranquillamente riavviare e provare la nuova immagine di kernel. Notare che questa installazione non sovrascrive nessuna vecchia immagine dei kernel, cos� se c'� un problema con la vostra nuova immagine del kernel, il vecchio kernel potr� essere selezionato al boot time.
2. Spostiamoci in tale directory:
<pre>
$ cd linux-2.6.19
</pre>


3. Creiamo una directory ''patches'' che conterrà tutte le nostre patch:
<pre>
<pre>
* Eccezioni da riportare a questa regola sono Gentoo e altre distribuzioni tipo "from scratch", le quali si
$ mkdir patches
aspettano che l'utente sappia come installare i kernels da solo. Questi tipi di distribuzoni includono la
documentazione su come installare un nuovo kernel, si consulti quest'ultima per l'esatto metodo richiesto.
</pre>
</pre>


== Installazione manuale ==
4. Tramite ''quilt'' creiamo una nuova patch chiamata ''patch1'':
<pre>
$ quilt new patch1
Patch patches/patch1 is now on top
</pre>


5. ''quilt'' necessita di sapere quali file saranno modificati da questa patch. Per fare questo, utilizziamo il comando ''add'':
<pre>
$ quilt add Makefile
File Makefile added to patch patches/patch1
</pre>


Se la distribuzione non � provvista del comando ''installkernel'', o si desidera semplicemnete fare il lavoro a mano per capire i passi che servono, eccoli qua:
6. Apriamo il file ''Makefile'' e modifichiamo la linea EXTRAVERSION, salvando poi il file. Alla fine, aggiorniamo la patch tramite ''quilt'':


I moduli devono essere installati:
<pre>
$ quilt refresh
Refreshed patch patches/patch1
</pre>


<pre> # make modules_install </pre>
Il file ''patches/patch1'' conterrà una patch con tutti i cambiamenti appena fatti:
<pre>
$ cat patches/patch1
Index: linux-2.6.19/Makefile
===================================================================
--- linux-2.6.19.orig/Makefile
+++ linux-2.6.19/Makefile
@@ -1,7 +1,7 @@
VERSION = 2
PATCHLEVEL = 6
SUBLEVEL = 19
-EXTRAVERSION =
+EXTRAVERSION = -dirty
NAME=Crazed Snow-Weasel
# *DOCUMENTATION*
</pre>


L'immagine statica del kernel deve essere copiata nella directory /boot. Per un kernel basato su piattaforma i386, fare:
Ora è possibile continuare a lavorare su una patch, o crearne una nuova in testa a quella attuale.
 
Ad esempio, se sono state create tre diverse patch ''patch1'', ''patch2'' e ''patch3'', esse saranno applicate una sopra l'altra.
<pre>
Per vedere la lista delle patch attualmente applicate:
  # make kernelversion
<pre>
  2.6.17.11
$ quilt series -v
+ patches/patch1
+ patches/patch2
= patches/patch3
</pre>
</pre>


Notare che la versione del kernel probabilmente sar� differente da quella del vostro. Usate questo valore al posto del testo KERNEL_VERSION nei seguenti passaggi:
Il risultato del comando mostra che tutte e tre le patch sono state applicate e che quella corrente è la ''patch3''.
Al rilascio di una nuova versione del kernel, se si vuole portare i cambiamenti effettuati sulla versione precedente anche sulla nuova versione, è possibile utilizzare ''quilt'' secondo i seguenti passi:


1. Togliere le patch attualmente applicate al sorgente
<pre>
<pre>
  # cp arch/i386/boot/bzImage /boot/bzImage-KERNEL_VERSION
$ quilt pop -a
  # cp System.map /boot/System.map-KERNEL_VERSION
Removing patch patches/patch3
Restoring drivers/usb/Makefile
Removing patch patches/patch2
Restoring drivers/Makefile
Removing patch patches/patch1
Restoring Makefile
No patches applied
</pre>
</pre>


Modificate il bootloader in modo che conosca il nuovo kernel. Questo implica modificare il file di configurazione per il bootloader che si usa, � spiegato pi� avanti in "Modificare il bootloader per il nuovo kernel" in GRUB e LILO.
2. Utilizzando la patch ufficiale da ''kernel.org'' aggiornare la vecchia versione del kernel:
 
Se il processo di avvio non funziona, solitamente � perch� una immagine iniziale di ramdisk (initial ramdisk) �  necessaria. Per crearla correttamente, si usino i passi all'inizio di questo capitolo per installare un kernel automaticamente, poich� lo script di installazione della distribuzione sa come creare adeguatamente il ramdisk usando gli scripts e gli strumenti necessari. Dato che ogni distribuzione fa questo in maniera differente, � oltre lo scopo di questo libro ricoprire tutti i differenti metodi di costruzione dell'immagine di ramdisk.
 
Qui c'� uno script agevole che pu� essere usato per installare un kernel automaticamente invece di dover digitare tutti i precedenti comandi ogni volta:
 
<pre>
<pre>
  #!/bin/sh
$ patch -p1 < ../patch-2.6.20
  #
$ cd ..
  # installs a kernel
$ mv linux-2.6.19 linux-2.6.20
  #
  make modules_install
 
  # find out what kernel version this is
  for TAG in VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION ; do
    eval `sed -ne "/^$TAG/s/ //gp" Makefile`
  done
  SRC_RELEASE=$VERSION.$PATCHLEVEL.$SUBLEVEL$EXTRAVERSION
 
  # figure out the architecture
  ARCH=`grep "CONFIG_ARCH " include/linux/autoconf.h | cut -f 2 -d "\""`
 
  # copy the kernel image
  cp arch/$ARCH/boot/bzImage /boot/bzImage-"$SRC_RELEASE"
 
  # copy the System.map file
  cp System.map /boot/System.map-"$SRC_RELEASE"
 
  echo "Installed $SRC_RELEASE for $ARCH"
</pre>
</pre>
 
   
 
3. A questo punto, tramite ''quitl'' applicare nuovamente le patch sul nuovo sorgente:
== Modificare il bootloader per il nuovo kernel ==
 
 
Esistono due bootloader comuni per i kernel Linux: GRUB e LILO. GRUB � quello maggiormente usato nelle distribuzioni moderne, e fa' alcune cose un po' pi� facilmente di LILO, ma LILO � tuttora anch'esso utilizzato. Li vedremo entrambi in questa sezione.
 
Per determinare quale bootloader il vostro sistema usa, guardate nella directory ''/boot/''. Se esiste una sottodirectory ''grub'':
 
<pre>
<pre>
  $ ls -F /boot | grep grub
$ quilt push
  grub/
Applying patch patches/patch1
patching file Makefile
Hunk #1 FAILED at 1.
1 out of 1 hunk FAILED -- rejects in file Makefile
Patch patches/patch1 does not apply (enforce with -f)
</pre>
</pre>


allora si sta utilizzando GRUB come programma per fare il boot. Se questa directory non � presente, si guardi se � presente il file ''/etc/lilo.conf'':
4. Come risultato, le patch non si applicano immediatamente senza problemi. E&grave; possibile forzare l'applicazione della patch e poi procedere alle correzioni necessarie:
 
<pre>
<pre>
  $ ls /etc/lilo.conf
$ quilt push -f
  /etc/lilo.conf
Applying patch patches/patch1
patching file Makefile
Hunk #1 FAILED at 1.
1 out of 1 hunk FAILED -- saving rejects to file Makefile.rej
Applied patch patches/patch1 (forced; needs refresh)
$ vim Makefile.rej Makefile
</pre>
</pre>


se � presente, state usando LILO come programma per fare il boot.
5. Dopo aver applicato manualmente la patch, aggiornare la patch:
I passi che implicano l'aggiunta del nuovo kernel a ognuno di questi programmi sono differenti, per cui si segua solo la sezione che corrisponde al programma che si sta usando.
 
==='''GRUB'''===
 
Per fare in modo che GRUB sappia che un nuovo kernel � presente, tutto ci� che dovete fare � modificare il file ''/boot/grub/menu/lst''. Per i dettagli completi della struttura di questo file, e tutte le differenti opzioni disponibili, consultate le pagine di info di GRUB:
 
 
'''$ info grub'''
 
 
Il metodo pi� veloce per aggiungere una nuova voce kernel a ''/boot/grub/menu.lst'' � quello di copiare una voce gi� esistente. Per esempio, considerate il seguente ''menu.lst'' da un sistema Gentoo:
 
<pre>
<pre>
  timeout 300
$ quilt refresh
  default 0
Refreshed patch patches/patch1
 
  splashimage=(hd0,0)/grub/splash.xpm.gz
 
  title 2.6.16.11
    root (hd0,0)
    kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305
 
  title 2.6.16
    root (hd0,0)
    kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305
</pre>
</pre>


La linea che comincia con la parola title definisce una nuova voce di kernel, in questo modo questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con la linea title, come:
6. Procedere all'applicazione delle altre patch:
 
<pre>
<pre>
  title 2.6.16.11
$ quilt push
    root (hd0,0)
Applying patch patches/patch2
    kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305
patching file drivers/Makefile
Now at patch patches/patch2
$ quilt push
Applying patch patches/patch3
patching file drivers/usb/Makefile
Now at patch patches/patch3
</pre>
</pre>


Dopodich aggiungete il blocco alla fine del file, e modificate il numero di versione con la nuova versione del nuovo kernel che si appena installato. Il titolo non ha alcuna importanza, purch unico, ma visualizzato nel menu di boot, per cui si dovrebbe dargli qualcosa che abbia un significato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per tanto la copia finale del file assomiglier a:


<pre>
''quilt'' ha anche delle opzioni che permettono di inviare automaticamente le nuove patch ad un gruppo di persone o a una mailing list, di eliminare specifiche patch all'interno della serie, di ricercare una specifica patch all'interno della serie e molte altre utili opzioni.
  timeout 300
 
  default 0
''quilt'' è vivamente consigliato per qualsiasi attività di sviluppo del kernel, anche per tenere traccia di poche patch, invece di usare i più ostici ''diff'' e ''patch''. E&grave; decisamente più semplice e consente di risparmiare parecchio tempo e sforzi.


  splashimage=(hd0,0)/grub/splash.xpm.gz
Come nota personale, non raccomanderò mai abbastanza l'utilizzo di questo strumento, poiché lo utilizzo tutti i giorni per gestire centinaia di patch in diversi rami di sviluppo.
Esso è anche usato da numerose distribuzioni Linux per gestire il proprio kernel e può contare su una comunità di sviluppo entusiasta e reattiva.


  title 2.6.16.11
== git ==
    root (hd0,0)
    kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305


  title 2.6.16
''git'' è uno strumento di controllo del codice sorgente originariamente scritto da Linus Torvalds quando stava cercando un nuovo sistema di gestione del codice per il kernel di Linux.
    root (hd0,0)
    kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305


  title 2.6.17.11
&Egrave; un sistema distribuito che differisce dai sistemi tradizionali di gestione del codice (come ad esempio CVS) nel fatto che non è necessario essere connessi al server per effettuare un commit sul deposito.
    root (hd0,0)
    kernel /bzImage-2.6.17.11 root=/dev/sda2 vga=0x0305
</pre>


Dopo che si � salvato il file, riavviate il sistema e assicuratevi che il titolo della nuova immagine del kernel sia presente nel menu di boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, e premete enter per avviare la nuova immagine.
''git'' è uno dei più potenti, flessibili e veloci sistemi di gestione del codice sorgente attualmente disponibili, e ha alle spalle un team di sviluppo molto attivo.
La pagina principale di ''git'' è ''http://git.or.cz/''.
Si consiglia ad ogni nuovo utente di seguire le guide pubblicate al fine di familiarizzare con la modalità di funzionamento di git, in modo da poterlo utilizzare correttamente.


==='''LILO'''===
Il kernel di Linux è sviluppato utilizzando ''git'', e le ultime versioni possono essere trovate all'indirizzo ''http://www.kernel.org/git/'' insieme ad una vasta lista di altri depositi git.


Per fare in modo che LILO sappia che un nuovo kernel � presente, dovete modificare il file di configurazione ''/etc/lilo.conf'' ed eseguire il comando ''lilo'' per applicare le modifiche fatte al file di configurazione. Per i dettagli completi sulla struttura del file di configurazione di LILO, consultate la manpage di LILO:
Non è necessario utilizzare ''git'' per sviluppare il kernel di Linux, ma è molto utile per tenere traccia dei bug rilevati.
Se doveste segnalare un bug agli sviluppatori del kernel, essi potranno richiedevi di utilizzare ''git bisect'' al fine di identificare l'esatta modifica che ha causato il bug. In questo caso, potete seguire le indicazioni sulla documentazione di ''git'' per capire come procedere.


'''$ man lilo'''
== ketchup ==


Il modo pi facile per aggiungere una nuova voce di kernel nel file ''/etc/lilo.conf'' � copiare una voce esistente. Per esempio, considerate il seguente file di configurazione di LILO di un sistema Gentoo:
''ketchup'' è uno strumento molto comodo utilizzato per aggiornare una versione del kernel o per passare da una versione all'altra del codice sorgente.


<pre>
Esso offre la possibilità di:
  boot=/dev/hda
* Trovare l'ultima versione del kernel, scaricarla e decomprimerla.
  prompt
* Aggiornare una versione attualmente installata del codice sorgente del kernel, applicando le patch necessarie.
  timeout=50
* Gestire i diversi rami di sviluppo del kernel, incluse le versioni -mm e -stable
  default=2.6.12
* Scaricare qualsiasi patch o archivio tar necessario per l'aggiornamento, se non già presenti sulla macchina locale.
* Controllare la firma GPG dell'archivio e delle patch per verificarne l'integrità.


  image=/boot/bzImage-2.6.15
''ketchup'' si trova all'indirizzo ''http://www.selenic.com/ketchup/'' insieme a molta documentazione presente nel wiki ''http://www.selenic.com/ketchup/wiki/''.
    label=2.6.15
    read-only
    root=/dev/hda2


  image=/boot/bzImage-2.6.12
Di seguito un esempio che illustra quanto sia semplice utilizzare ''ketchup'' per fare scaricare una specifica versione del kernel e '''per passare ad un'altra versione''' con un numero minimo di comandi.'''VERIFICARE LA TRADUZIONE DELLA PARTE IN GRASSETTO [...and then have it switch the directory to another kernel version...]'''
    label=2.6.12
    read-only
    root=/dev/hda2
</pre>


La linea che comincia con la parola image= definisce una nuova voce kernel, quindi questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con image=, come:
Per scaricare il sorgente del kernel 2.6.16.24 in una directory, e rinominare la directory perché abbia lo stesso nome della versione del kernel, utilizzare il seguente comando:


<pre>
<pre>
  image=/boot/bzImage-2.6.15
$ mkdir foo
    label=2.6.15
$ cd foo
    read-only
$ ketchup -r 2.6.16.24
    root=/dev/hda2
None -> 2.6.16.24
Unpacking linux-2.6.17.tar.bz2
Applying patch-2.6.17.bz2 -R
Applying patch-2.6.16.24.bz2
Current directory renamed to /home/gregkh/linux/linux-2.6.16.24
</pre>
</pre>


Aggiungete dopo il blocco alla fine del file, e modificate il numero di versione per contenere quella del nuovo kernel appena installato. La label non ha alcuna importanza, purch� unica, ma � visualizzata nel menu di boot, per cui dovreste dargli qualcosa di sensato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per cui la copia finale del file sar�:
Ora, per aggiornare il sorgente affinché contenga l'ultimo rilascio stabile, digitare:
 
<pre>
<pre>
  boot=/dev/hda
$ ketchup -r 2.6
  prompt
2.6.16.24 -> 2.6.17.11
  timeout=50
Applying patch-2.6.16.24.bz2 -R
  default=2.6.12
Applying patch-2.6.17.bz2
 
Downloading patch-2.6.17.11.bz2
  image=/boot/bzImage-2.6.15
--22:21:14-- http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.17.11.bz2
    label=2.6.15
=> `/home/greg/.ketchup/patch-2.6.17.11.bz2.partial'
    read-only
Resolving www.kernel.org... 204.152.191.37, 204.152.191.5
    root=/dev/hda2
Connecting to www.kernel.org|204.152.191.37|:80... connected.
 
HTTP request sent, awaiting response... 200 OK
  image=/boot/bzImage-2.6.12
Length: 36,809 (36K) [application/x-bzip2]
    label=2.6.12
100%[====================================>] 36,809 93.32K/s
    read-only
22:21:14 (92.87 KB/s) - `/home/greg/.ketchup/patch-2.6.17.11.bz2.partial'saved [36809/36809]
    root=/dev/hda2
Downloading patch-2.6.17.11.bz2.sign
 
--22:21:14-- http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.17.11.bz2.sign
  image=/boot/bzImage-2.6.17
=> `/home/greg/.ketchup/patch-2.6.17.11.bz2.sign.partial'
    label=2.6.17
Resolving www.kernel.org... 204.152.191.37, 204.152.191.5
    read-only
Connecting to www.kernel.org|204.152.191.37|:80... connected.
    root=/dev/hda2
HTTP request sent, awaiting response... 200 OK
Length: 248 [application/pgp-signature]
100%[====================================>] 248 --.--K/s
22:21:14 (21.50 MB/s) - `/home/greg/.ketchup/patch-2.6.17.11.bz2.sign.
partial' saved [248/248]
Verifying signature...
gpg: Signature made Wed Aug 23 15:01:04 2006 PDT using DSA key ID 517D0F0E
gpg: Good signature from "Linux Kernel Archives Verification Key >
ftpadmin@kernel.org<"
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: C75D C40A 11D7 AF88 9981 ED5B C86B A06A 517D 0F0E
Applying patch-2.6.17.11.bz2
Current directory renamed to /home/greg/linux/tmp/x/linux-2.6.17.11
</pre>
</pre>


Dopo aver salvato il file, lanciate il programma ''/sbin/lilo'' per salvare i cambiamenti del file di configurazione nella sezione di boot del disco:


<pre> # /sbin/lilo </pre>
Questo esempio mostra come ''ketchup'' determini in modo automatico che la nuova versione stabile del kernel è la 2.6.17.11 e scarichi le patch necessarie per aggiornare il sorgente.


Ora il sistema pu� essere riavviato in sicurezza. La scelta del nuovo kernel si pu� vedere tra le scelte disponibili a boot time. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, premete Enter per lanciare il boot della nuova immagine.
L'uso di ''ketchup'' è vivamente consigliato per scaricare qualsiasi sorgente del kernel di Linux. Esso si occupa di reperire le patch necessarie sul server e applicarle automaticamente nel modo corretto, dopo averne controllato l'autenticità tramite la firma digitale.


L'uso combinato di ''ketchup'' e ''quilt'' permette di avere tutto ciò che serve per gestire il kernel di Linux e per soddisfare le esigenze degli sviluppatori.


----
----
Riga 271: Riga 302:
----
----


[[Categoria:Kernel]]
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/appa.pdf ''Capitolo originale'']
 
[[Categoria:Documentazione tecnica]]
[[Categoria:Linux Kernel in a Nutshell]]
S3v
6 999

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/14696...32773"

Menu di navigazione