[HOW-TO] Gentoo su PC datati (aka Portatile Felice)

[maurs]

UPDATE: Se il metodo vi creava problemi, provate a leggere la nota 4 e 5 (soprattutto la 5)

PREMESSA

Questo è il mio primo “how-to”. Sicuramente non sarà completo e qualche passaggio lo darò "troppo" per scontato. Inoltre sarà ricco di errori, di temi trattati superficialmente e di mancate considerazioni. Correzioni, aggiunte e modifiche saranno ben accette

COSA VUOL FARE QUESTO HOW-TO?

Ho scritto questo How-To per coloro che vogliono:

- Utilizzare il loro "ultra veloce processore" per compilare (anche dal bootstrap) Gentoo dallo stage 1 anche su un computer ben più datato;
- Installare Gentoo su vecchie macchine (ovvero coloro i quali vogliono ottenere il massimo anche da un pentium 200!);
- Installare/aggiornare Gentoo sul loro portatile senza stressare l'hard disk/cpu di quest'ultimo;

Riguardo questo argomento ho trovato molte guide, ma nessuna che veramente mi soddisfaceva: il problema principale consisteva nell'eccessivo traffico di rete risolvibile solo con l'impiego di due schede ethernet 1 Gigabit (cosa molto poco probabile sui vecchi portatili). Inoltre, su PC datati, la velocità dell'hard disk pecca, e di sicuro non sarà veloce come una compilazione in RAM. Così ho cercato un metodo per ridurre il traffico di rete e avere meno accessi possibili sui dischi del vecchio pc.

SITUAZIONE

Avremo due PC:
PC1 = Computer veloce con tanta RAM (meglio se sopra il 1GB)
PC2 = Computer vecchiotto.

BOOTSTRAP

Il PC 1 sarà avviato con Gentoo (installata “normalmente” ) e con il supporto a NFS (fare riferimento a questolink per ulteriori informazioni).
Il PC 2 dovrà essere avviato con un live cd che supporti NFS (nel mio caso Gentoo DVD Live RR4 2.6).

Nel caso preso in considerazione, il PC 1 ha due schede di rete (eth0 collegata a internet, e eth1 collegata direttamente con PC 2), ma, con qualche modifica, si può fare anche con una sola scheda di rete "per computer" (i più esperti non troveranno difficoltà).

Nel mio caso...

Console PC1:

Code: Select all

ifconfig eth1 10.0.0.1 up
echo "1" > /proc/sys/net/ipv4/ip_forward #abilita il fowarding dei pacchetti
iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

Console PC2:

Code: Select all

 ifconfig eth0 10.0.0.2 up
route add default gw 10.0.0.1
echo “nameserver x.x.x.x” > /etc/resolv.conf #dove x.x.x.x sta per il dns del vostro provider.
echo “/mnt/gentoo/ 10.0.0.1(no_root_squash,rw,no_all_squash)” >> /etc/exports
/etc/init.d/nfs restart

Su PC 2, infine, seguite l'ottimo Hand Book di Gentoo, fino ad arrivare al momento del Boostrap (precisamente prima di eseguire script/bootstrap.sh. Unica nota è quella di inserire nel make.conf

Code: Select all

AUTOCLEAN="yes"

per evitare di occupare troppa RAM.
A questo punto fermatevi e tornate sul PC 1.

Console PC 1:

Code: Select all

/etc/init.d/nfsmount start
mkdir /mnt/nfs
mkdir /mnt/tmp/
mount -t nfs 10.0.0.2:/mnt/gentoo/ /mnt/nfs/ 
mount -t tmpfs tmpfs -o size=1000M,mode=770 /mnt/tmp/ #Guarda nota (1)(2)
mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/ 
mount --bind /usr/portage/ /mnt/nfs/usr/portage/ #Guarda nota (5)
mount -t proc none /mnt/nfs/proc
chroot /mnt/nfs/ /bin/bash -c 'env-update && source /etc/profile &&  exec /bin/bash'

Continuate con il normale bootstrap sempre dalla console del PC1 (che sarà ovviamente il chroot remoto del nostro vecchio portatile). Questo sistema utilizzerà la CPU e la memoria della vostra “workstation” senza stressare il vostro vecchio pc e/o portatile.

Finito il bootstrap potete continuare con emerge -e system e, perché, no anche con l'emerge di xorg e kde.
Prima di riavviare il PC 2, è vivamente consigliato di smontare tutte i device nel PC1:

Console PC1:

Code: Select all

exit
umount /mnt/nfs/proc
umount /mnt/nfs/usr/portage/
umount /mnt/nfs/var/tmp/portage/ 
umount /mnt/tmp/
umount /mnt/nfs/

AGGIORNAMENTO

Infine, potete utilizzare lo stesso metodo per aggiornare il vostro oramai "Gentoo PC 2" . Basterà difatti seguire quasi lo stesso procedimento con qualche piccola modifica:

Sul PC2

Code: Select all

echo “/ 10.0.0.1(no_root_squash,rw,no_all_squash)” >> /etc/exports

al posto di

Code: Select all

echo “/mnt/gentoo/ 10.0.0.1(no_root_squash,rw,no_all_squash)” >> /etc/exports

e sul PC 1

Code: Select all

mount -t nfs 10.0.0.2:/ /mnt/nfs/

al posto di

Code: Select all

mount -t nfs 10.0.0.2:/mnt/gentoo/ /mnt/nfs/ 

Naturalmente l'aggiornamento con questo metodo porta alcuni problemi. (vedi nota 2 e 3)

Potete anche riassumere, per comodità, il tutto in due semplici script:

File montaportatile.sh

Code: Select all

#!/bin/sh
mount -t nfs 10.0.0.2:/ /mnt/nfs/
mount -t tmpfs tmpfs -o size=1400M,mode=770 /mnt/tmp/
mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/
mount --bind /usr/portage/ /mnt/nfs/usr/portage/
mount -t proc none /mnt/nfs/proc
chroot /mnt/nfs/ /bin/bash -c 'env-update && source /etc/profile &&  exec /bin/bash'

e il file smontaportatile.sh (dopo aver digitato exit per uscire dal chroot).

Code: Select all

#!/bin/sh
umount /mnt/nfs/proc
umount /mnt/nfs/usr/portage/
umount /mnt/nfs/var/tmp/portage/
umount /mnt/tmp/
umount /mnt/nfs/

CONCLUSIONI

Le vostre esperienze e le segnalazioni d'errori sono moooooolto ben accette Spero di poter dedicare quanto più tempo possibile alla correzione.

NOTE

Nota 1: 1000 Mb sono tanti, ma se avete in precedenza attivato l'opzione AUTOCLEAN nel make.conf difficilmente si arriverà a occuparli tutti.
Nota 2: Allocando 1400 MB per il tmpfs, ho avuto problemi ad installare OpenOffice e Wine, avidi di spazio per i file temporanei. In questo caso bastarebbe saltare la linea di codice che permette la compilazione in RAM.
Nota 3: Il metodo funzionerà solamente se il PC 1 avrà un processore più recente del PC 2. Inoltre, se il pc1 è a 64 bit e il pc2 a 32, bisogna fare il chroot premettendo il comando linux32:

Code: Select all

linux32 chroot /mnt/nfs/ /bin/bash
env-update && source /etc/profile
export PS1="(chroot) $PS1"

Per ulteriori informazioni, fate riferimento a questa guida

Nota 4: Quanto detto sopra vuol dire che, per esempio, non potrete usare questo metodo se il vostro PC1 è (per esempio) un athlon-xp e il PC2 è un Pentium4 (che ha in più le istruzione SSE2). In questo caso distcc fa al caso vostro (niente portatile felice).
Nota 5:
- Se compilate da PC1 con architettura a 64 bit e il PC2 a 32;
- e/o se facendo emerge -uDav world senza il metodo e poi applicando il medesimo il risultato differisce,
- e/o per altri problemi simili;
provate a modificare lo script in questo modo:

Code: Select all

mount -t nfs 10.0.0.2:/ /mnt/nfs/
mount -t tmpfs tmpfs -o size=1400M,mode=770 /mnt/tmp/
mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/ 
#mount --bind /usr/portage/ /mnt/nfs/usr/portage/  #<<-- riga da commentare
mount --bind /usr/portage/distfiles /mnt/nfs/usr/portage/distfiles #<<-- riga da aggiungere
mount -t proc none /mnt/nfs/proc
chroot /mnt/nfs/ /bin/bash -c 'env-update && source /etc/profile &&  exec /bin/bash'

Naturalmente andrà anche modificato l'umount, ovvero

Code: Select all

#umount /mnt/nfs/usr/portage/ #<<-- riga da commentare
umount /mnt/nfs/usr/portage/distfiles #<<-- riga da aggiungere

Come noterete, ci sarà qualche accesso in più al disco del PC2, ma sicuramente risolverà molti dei problemi riscontrati da alcuni utenti. Se invece non ne avete mai riscontrati, continuate ad utilizzare il metodo originale.

[cloc3]

NOTE

Nota 1: 1000 Mb sono tanti, ma se avete in precedenza attivato l'opzione AUTOCLEAN nel make.conf difficilmente si arriverà a occuparli tutti.
Nota 2: Allocando 1400 MB per il tmpfs, ho avuto problemi ad installare OpenOffice e Wine, avidi di spazio per i file temporanei. In questo caso bastarebbe saltare la linea di codice che permette la compilazione in RAM.

Non sono daccordo sul consiglio di omettere l'uso di tmpfs.
tmpfs è fondamentale, altrimenti la compilazione avviene con l'accesso all'hd remoto via nfs, e i tempi si dilatano inesorabilmente.
Se si ha poca ram, probabilmente, conviene effettuare l'installazione sul disco rigido locale del PC1, importando via nfs solamente la /proc del PC2.
Al termine il traferimento del sistema completo con rsync o cp -a.

Pensi che sia possibile?

P.S: sed -i -e 's/Cntinuate/Continuate/'

[maurs]

Non sono daccordo sul consiglio di omettere l'uso di tmpfs.
tmpfs è fondamentale, altrimenti la compilazione avviene con l'accesso all'hd remoto via nfs, e i tempi si dilatano inesorabilmente.
Se si ha poca ram, probabilmente, conviene effettuare l'installazione sul disco rigido locale del PC1, importando via nfs solamente la /proc del PC2.
Al termine il traferimento del sistema completo con rsync o cp -a.

Pensi che sia possibile?

Eliminando la riga (precisamente quella riga (mount -t tmpfs tmpfs -o size=1000M,mode=770 /mnt/tmp/) la compilazione non avviene sull'hard disk del PC2 come dici tu, ma sull'harddisk del PC1 . Infatti quella che permette ciò è la riga successiva (mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/).
Quindi, se nell'hard disk locale, in /mnt/tmp/ c'è montato tmpfs, allora la compilazione avverrà nella RAM del PC1, altrimenti, se ometto la riga, la compilazione avverrà in /mnt/tmp/, ovvero sull'harddisk del PC1. L'unica cosa che si deve fare, al massimo, è dare i giusti permessi alla cartella.

Riassumendo

mount -t tmpfs tmpfs -o size=1000M,mode=770 /mnt/tmp/ --> mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/ ---> /mnt/nfs/var/tmp/portage si riferirà a tmpfs
con solo mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/ ---> /mnt/nfs/var/tmp/portage si riferirà all'hard disk PC1.

P.S: sed -i -e 's/Cntinuate/Continuate/'

Spero sia un incoraggiamento

[cloc3]

la compilazione non avviene sull'hard disk del PC2 come dici tu, ma sull'harddisk del PC1 . Infatti quella che permette ciò è la riga successiva (mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/).

Astuto. Non avevo notato.
Quindi, avresti proprio previsto tutto .

P.S: sed -i -e 's/Cntinuate/Continuate/'

Spero sia un incoraggiamento

Ti serve un incoraggiamento?

[Luca89]

Code: Select all

#!/bin/sh
mount -t nfs 10.0.0.2:/ /mnt/nfs/
mount -t tmpfs tmpfs -o size=1400M,mode=770 /mnt/tmp/
mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/
mount --bind /usr/portage/ /mnt/nfs/usr/portage/
mount -t proc none /mnt/nfs/proc
chroot /mnt/nfs/ /bin/bash
env-update && source /etc/profile

Code: Select all

env-update && source /etc/profile

questi li devi fare a mano tu perchè chroot apre una subshell e lo script di partenza non è in grado di controllarla. Come li hai scritti, i due comandi verrano eseguiti dopo aver terminato il chroot. Comunque hai avuto una idea bellina, io fino ad ora compilavo in un ambiente chrootato sul mio pc e poi spostavo tutto con rsync appoggiandomi a ssh. Si evita un passaggio con il tuo metodo

[maurs]

Code: Select all

env-update && source /etc/profile

questi li devi fare a mano tu perchè chroot apre una subshell e lo script di partenza non è in grado di controllarla. Come li hai scritti, i due comandi verrano eseguiti dopo aver terminato il chroot. Comunque hai avuto una idea bellina, io fino ad ora compilavo in un ambiente chrootato sul mio pc e poi spostavo tutto con rsync appoggiandomi a ssh. Si evita un passaggio con il tuo metodo

Hai perfettamente ragione. Difatti nei script locali sul mio pc non li avevo inseriti. Ma ieri nella fretta, li ho aggiunti in automatico . Tnx per la segnalazione

Astuto. Non avevo notato.
Quindi, avresti proprio previsto tutto

Un'altra kikka è quella che, sul vecchio computer, se avete poco spazio, potete risparmiare 300 Mb di portage, cancellando il contenuto di /var/tmp/portage/ in quanto verrà bindato (passatemi il termine ) quello del PC1 Provare per credere

[Luca89]

Ora che ci penso i due script possono essere accorpati.

Code: Select all

#!/bin/sh
mount -t nfs 10.0.0.2:/ /mnt/nfs/
mount -t tmpfs tmpfs -o size=1400M,mode=770 /mnt/tmp/
mount --bind /mnt/tmp/ /mnt/nfs/var/tmp/portage/
mount --bind /usr/portage/ /mnt/nfs/usr/portage/
mount -t proc none /mnt/nfs/proc
chroot /mnt/nfs/ /bin/bash
umount /mnt/nfs/proc
umount /mnt/nfs/usr/portage/
umount /mnt/nfs/var/tmp/portage/
umount /mnt/tmp/
umount /mnt/nfs/

monta tutto, chroota, terminato il chroot smonta, più automatico di così.

[fbcyborg]

Nota 3: Il metodo funzionerà solamente se il PC 1 avrà un processore più recente del PC 2. Inoltre, dovrebbero esserci degli effetti collaterali se il PC 1 è un sistema a 64 bit mentre il PC 2 no.

Nessun problema sul fatto che il PC1 sia a 64 bit e il PC2 a 32, lo uso da tempo questo sistema (sempre sotto consiglio di maurs) ed è sempre filato tutto liscio.

Ottimo Howto!

[maurs]

Nessun problema sul fatto che il PC1 sia a 64 bit e il PC2 a 32, lo uso da tempo questo sistema (sempre sotto consiglio di maurs) ed è sempre filato tutto liscio.

Ottimo Howto!

Tnx, mi sa tanto che allora il problema persiste solo se si cerca di compilare il kernel. Giusto?

Modifico l'how-to con la tua segnalazione. Se qualcun'altro ha problemi mi faccia sapere

[makoomba]

Code: Select all

chroot /mnt/nfs /bin/bash -c 'env-update && source /etc/profile &&  exec /bin/bash'

esegue in automatico (nel chroot) env-update e source /etc/profile prima di passare il controllo alla shell.

[fbcyborg]

Tnx, mi sa tanto che allora il problema persiste solo se si cerca di compilare il kernel. Giusto?

Si! in effetti mi ero dimenticato di dirlo, se devo compilare il kernel allora le cose cambiano, non funziona bene. Comunque nulla di oneroso per il portatile se consideriamo che le compilazioni pesanti sono effettuate tramite emerge. Il kernel lo possiamo anche ricompilare col portatile direttamente.

[maurs]

Code: Select all

chroot /mnt/nfs /bin/bash -c 'env-update && source /etc/profile &&  exec /bin/bash'

esegue in automatico (nel chroot) env-update e source /etc/profile prima di passare il controllo alla shell.

Grazie mille. Ho appena aggiornato l'how-to (e l'ho anche testato )

[cloc3]

Nessun problema sul fatto che il PC1 sia a 64 bit e il PC2 a 32, lo uso da tempo questo sistema (sempre sotto consiglio di maurs) ed è sempre filato tutto liscio.

Ottimo Howto!

Tnx, mi sa tanto che allora il problema persiste solo se si cerca di compilare il kernel. Giusto?

Se il pc1 è a 64 bit e il pc2 a 32, bisogna fare il chroot premettendo il comando linux32:

Code: Select all

# linux32 chroot /mnt/nfs

Come da manuale.

[fbcyborg]

Aaaah!!! Perfetto, quindi col comando linux32 si riesce a compilare anche il kernel!!!
Ottimo!

[maurs]

Se il pc1 è a 64 bit e il pc2 a 32, bisogna fare il chroot premettendo il comando linux32:

Code: Select all

# linux32 chroot /mnt/nfs

Come da manuale.

Modificato l'how-to. Tnx mille. Ma conviene farlo sempre e cmq o solo per il kernel? a quanto ho capito cyborg nn ha avuto problemi se non per il kernel.
Cmq, onde evitare grane (vedi moduli del kernel) mi sa che è sempre meglio farlo a 32 bit sempre... o sbaglio?

[cloc3]

Ma conviene farlo sempre e cmq o solo per il kernel?

Direi che va fatto sempre.
Quel comando modifica un insieme di variabili di sistema fondamentali on solo per la compilazione del kernel, ma anche per quella di molti altri pacchetti.

Per capirlo, guarda qui:

Code: Select all

s939 install # linux32 chroot /mnt/hda10
s939 / # uname -rm
2.6.15-reiser4-r7 i686
s939 / # exit
exit
s939 install # chroot /mnt/hda10
s939 / # uname -rm
2.6.15-reiser4-r7 x86_64

P.S.: forse è meglio che nel tuo howto, aggiungi anche un link alla guida che ho segnalato sopra.

[GiRa]

Per essere sicuri che tutto funzioni anche se si cross compila da un AMD64 ad una macchina a 32bit anteporre ai comandi di chroot linux32:

Code: Select all

# linux32 chroot /mnt/gentoo /bin/bash
# env-update
>> Regenerating /etc/ld.so.cache...
# source /etc/profile
# export PS1="(chroot) $PS1"

[maurs]

Modifiche effettuate.
tnx to GiRa e cloc3!

[fbcyborg]

Sto compilando un kernel in chroot dal mio amd64 al portatile a 32 bit.. e nonostante io abbia usato la parola magica "linux32" .. anche adesso se mi consente di compilare il kernel, al contrario di prima che ovviamente andava in errore, mi sta venendo il dubbio che le operazioni di compilazione siano sempre a carico del processore sul portatile.. questo credo che sia dovuto al fatto che emerge funziona bene perchè abbiamo una variabile nel /etc/make.conf che specifica quanta memoria usare per compilare in ram, mentre per la compilazione del kernel, che non avviene con emerge, non è stato specificato nulla.. ne è la prova il fatto che la ventola del portatile cominci a girare dal momento in cui inizia la compilazione.
Pertanto compilare il kernel con questa tecnica in nfs, equivale a farlo in chroot.
E' possibile delegare anche le operazioni di compilazione del kernel al mio potentissimo amd64 ???

[cloc3]

compilare il kernel con questa tecnica in nfs, equivale a farlo in chroot.

Questa è una affermazione talmente vera che, per sua conseguenza, stai usando la cpu a 64.
Se hai dubbi, puoi usare un semplice top delle due macchine.

In ogni caso, non ho capito quali siano le osservazioni che ti permettono di affermare il contrario.

[fbcyborg]

I'm Sorry!
intendevo dire... in SSH!!!!!!!

mea culpa!

[Luca89]

I'm Sorry!
intendevo dire... in SSH!!!!!!!

mea culpa!

quando ti connetti con ssh tu apri semplicemente una shell sull'altro pc, tutto il carico se lo fa il pc a cui sei collegato. Forse ti può aiutare distcc per fare quello che dici.

[fbcyborg]

Beh, insomma.. vorrei delegare le operazioni di compilazione del kernel al mio amd64.. come faccio con emerge.
Vorrei evitare di usare distcc e utilizzare nfs anche per compilare il kernel

[Luca89]

Beh, insomma.. vorrei delegare le operazioni di compilazione del kernel al mio amd64.. come faccio con emerge.
Vorrei evitare di usare distcc e utilizzare nfs anche per compilare il kernel

e allora usa nfs, prima hai detto di aver usato ssh, e quindi ti ho detto perchè non andava bene, facendo il chroot su una partizione nfs è la stessa cosa di fare un chroot in una partizione normale. Tieni conto naturalmente che l'altro pc avrà un hard-disk lento e quindi prima che al tuo megaprocessore gli arrivino i dati da processare ci vorrà un pochino causando rallentamenti.

[fbcyborg]

No! allora scusate, non mi sono spiegato bene forse...

Intendevo dire:

La situazione è questa: utilizzo questo howto per compilare pacchetti con emerge e tutto va alla grande.. utilizzo nfs ed è il mio amd64 a compilare tutto per il mio duron 800....
Vorrei (per esempio dopo aver fatto un emerge "qualche cosa") poter compilare anche il kernel facendolo fare all'amd64.

Dicevo appunto, o meglio volevo dire, che utilizzando questa tecnica anche per la compilazione del kernel non sembra funzionare... sembra proprio che sia il portatile stesso a compilarsi il kernel da solo.... stando così le cose.. dando quindi il comando di compilazione dal mio amd64 in chroot su nfs, è equivalente a fare un ssh ip_del_portatile e dopo essere connessi dare un make in /usr/src/linux, dato che tanto la compilazione è onere del duron.

Spero di essere stato un pochino più preciso adesso!