Chroot: come creare un ambiente a 32-bit su AMD 64

Mi è capitato pochi giorni fa di dover far fronte a questo problema: eseguire un software basato su perl 5.8.8 sparito ormai dalle più attuali distribuzioni ubuntu per essere precisi. La mia, che non è la ultimissima versione, la lucid, mette a disposizione il pacchetto perl 5.10.x.x, per ovviare avrei dovuto fare il downgrade del pacchetto perl, con tutti i problemi annessi e connessi. Per altro il SW è supportato solo su architetture a 32 bit, praticamente non avevo chance. Come fare a risolvere ? Semplice, creando un ambiente a 32 bit, attraverso il comando chroot. Vediamo come.

Dopo una breve ricerca, ho trovato che il pacchetto perl 5.8.8 è presente nella distro ubuntu hardy quindi ho battezzato quella versione come target del mio ambiente a 32 bit.

#1. Installare il pacchetto debootstrap il quale contiene una serie di script utili:

mulp@devme:~$ apt-get install debootstrap

Per saperne di più del comando vi rimando al seguente link

#2. Installare il pacchetto dchroot il quale contiene una serie di comandi utili alla creazione e all’accesso su diversi ambienti chroot:

mulp@devme:~$ apt-get install dchroot
mulp@devme:~$ mkdir /devme/chroot

Posizionatevi quindi nel punto del file system in cui desiderate creare fisicamente l’ambiente.

#3. Editare il file /etc/dchroot.conf e aggiungere la seguente riga:

hardy_i386 /devme/chroot/hardy_i386

Assicuratevi che il percorso sia corretto.

#4. Ci siamo. Siamo pronti a creare il nuovo ambiente. Eseguire il seguente comando:

mulp@devme:~$ debootstrap --variant=buildd --arch i386 hardy /devme/chroot/hardy_i386 http://archive.ubuntu.com/ubuntu/

Al termine dell’esecuzione avrete il nuovo sistema installato. Per ulteriori dettagli sul comando debootstrap vi rimando al man di sistema, aggiungo solo che il parametro variant indica il tipo di sistema che si vuol creare, in questo buildd. Il nuovo sistema creato avrà installati i pacchetti base-system.

#5. Procediamo ora alla configurazione del nuovo sistema. Eseguire i seguenti comandi:

mulp@devme:~$ cp /etc/resolv.conf /devme/chroot/hardy_i386/etc/resolv.conf
mulp@devme:~$ cp /etc/apt/sources.list /devme/chroot/hardy_i386/etc/apt/
mulp@devme:~$ chroot /devme/chroot/hardy_i386/
mulp@devme:~$ apt-get update
mulp@devme:~$ apt-get install gnupg locales dialog
mulp@devme:~$ apt-get update
mulp@devme:~$ locale-gen it_IT.UTF-8
mulp@devme:~$ tzconfig
mulp@devme:~$ exit

In sostanza si ereditano alcune configurazioni dell’ambiente principale all’interno di quello appena creato. Il primo comando consente di poter navigare dal nuovo ambiente e il secondo mette a disposizione le source list di apt affinché sia possibile aggiornarlo. Vengono installi alcuni comandi fondamentali e impostato il locale corretto. Ricordatevi di modificare il file sources.list se la distro del vostro sistema differisce dall’ambiente creato.

#6. A questo punto per accedere all’ambiente appena creato si utilizza il comando dchroot -d oppure dchroot -d- c hardy_i386 se avete a disposizione più ambienti. Vi accorgerete che il comando di cui sopra richiedono i diritti da superutente. Affinchè sia possibile accedere da utente normale, è necessario copiare alcuni file di configurazione dall’ambiente centrale in quello appena creato:

mulp@devme:~$ cp /etc/passwd /devme/chroot/hardy_i386/etc/
mulp@devme:~$ sed 's/\([^:]*\):[^:]*:/\1:*:/' /etc/shadow | tee /devme/chroot/hardy_i386/etc/shadow
mulp@devme:~$ cp /etc/group /devme/chroot/hardy_i386/etc/
mulp@devme:~$ cp /etc/hosts /devme/chroot/hardy_i386/etc/

Il comando sed rimuove le password criptate dal file shadow. Dal momento che stiamo facendo login in un’ambiente chroot non sono necessarie. In questo modo evitiamo anche di duplicare il file delle password su due ambienti diversi.

#7. Se si vuole poter eseguire il comando sudo è necessario copiare i seguenti file:

mulp@devme:~$ cp /etc/sudoers /devme/chroot/hardy_i386/etc/
mulp@devme:~$ chroot /devme/chroot/hardy_i386
mulp@devme:~$ dpkg-reconfigure passwd
mulp@devme:~$ passwd <username>
mulp@devme:~$ apt-get install sudo

E infine aggiungere la seguente riga nel file /etc/sudoers nell’ambiente chroot.

# Members of the admin group may gain root privileges
%mulp ALL=(ALL) ALL

#8. Procediamo con il mapping di alcune directory che sono utili all’interno dell’ambiente chroot. Editare il file /etc/fstab e aggiungere le seguenti righe:

/home         /devme/chroot/hardy_i386/home        none    bind      0 0
/tmp          /devme/chroot/hardy_i386/tmp         none    bind      0 0
/media/cdrom  /devme/chroot/hardy_i386/media/cdrom none    bind      0 0
/dev          /devme/chroot/hardy_i386/dev         none    bind      0 0 
proc-chroot   /devme/chroot/hardy_i386/proc        proc    defaults  0 0
devpts-chroot /devme/chroot/hardy_i386/dev/pts     devpts  defaults  0 0

Assicuratevi di effettuare la modifica sul file /etc/fstab dell’ambiente principale e che esistano tutti i mount point. Quindi eseguire il comando:

mulp@devme:~$ mount -a

#9. Infine, se volete che di fianco nel prompt appaia l’indicazione dell’ambiente chroot editate il file /devme/chroot/hardy_i386/etc/debian_chroot e aggiungete la seguente riga:

hardy_i386

Se il file non esiste createlo.

Stay tuned!

Linux command cheat sheet

Buon 2011 a tutti !!
Navigando per la rete ho trovato un interessante insieme di siti i quali elencavano alcune liste dei più diffusi comandi di linux. Ho pensato di raccoglierli e di creare il mio primo cheat sheet, in formato HTML, da pubblicare come articolo sulle pagine del mio blog…sai mai che possa interessare a qualcuno. Ci sono alcuni comandi di uso comune molto chiari, altri molto interessanti da usare solo se la tastiera è la naturale continuazione della proprio mani!

Stay tuned!

Linux Kernel Module – A [little] programming guide

Volete scrivere un modulo per il kernel di linux ? Conoscete il linguaggio C ? Benissimo, allora armatevi e partite. Considerate questa piccola guida, un punto di partenza per la creazione di un piccolo modulo per il kernel di linux.
Prima di partire cerchiamo di capire cos’è un modulo del kernel. I moduli in generale sono dei piccoli programmi che possono essere montati e smontati run-time dal kernel ogni qual volta si presenta la necessità. Ad esempio un modulo potrebbe essere quello per un dispositivo hardware, stiamo parlando quindi di un driver di dispositivo, il quale dopo essere stato caricato permetterà l’utilizzo del dispositivo stesso. I moduli quindi estendono la funzionalità del kernel senza necessità che si effettui un reboot del sistema.
Senza moduli si avrebbero i cosiddetti kernel monolitici, ovvero blocchi di kernel che inglobano tutte le funzionalità le quali verrebberò caricate tutte assieme al momento del boot del sistema.

In linux per elencare la lista dei moduli caricati dal kernel è sufficiente eseguire il seguente comando: 
 

mulp@devme-station:~$ lsmod
Module                  Size  Used by
binfmt_misc             7960  1 
snd_hda_codec_analog    78702  1 
snd_hda_intel          25677  3 
snd_hda_codec          85759  2 snd_hda_codec_analog,snd_hda_intel
snd_hwdep               6924  1 snd_hda_codec
snd_pcm_oss            41394  0 
........
........

Sopra vediamo un esempio di lista dei moduli caricati attualmente dal kernel sulla mia macchina.

Ma come vengono caricati i moduli all’interno del kernel ? Quando il kernel ha bisogno di una funzionalità che non è stata finora caricata, si rifà al demone kmod il quale esegue il comando modprobe che si occupa del caricamento. modprobe seleziona il modulo da caricare indicandone il nome oppure un identificatore generico:

• nome del modulo: devme-driver
• identificativo generico: char-major-10-20

Nel caso dell’identificatore generico viene consultato il file /etc/modules.conf all’interno del quale sono definiti gli alias per ogni modulo, in questo caso dato l’identificativo precedente, il kernel farà riferimento al modulo chiamato devme-driver.o. Successivamente viene consultato il file /lib/modules/version/modules.dep per verificare se il modulo ha delle dipendenze rispetto ad altri moduli, e nel caso in cui li abbia, vengono caricate prima del modulo stesso. Questo file è creato attraverso il comando depmod -a.  Un esempio chiarificatore è dato dalla dipendenza del modulo msdos.o dal modulo fat.o, in questo caso la sequenza del caricamento sarà:

mulp@devme-station:~$ insmod /lib/modules/2.5.1/kernel/fs/fat/fat.o
mulp@devme-station:~$ insmod /lib/modules/2.5.1/kernel/fs/msdos/msdos.o

oppure

mulp@devme-station:~$ modprobe -a msdos

Passiamo quindi ad un piccolo esempio pratico di scrittura del nostro modulo. Ovviamente si tratta di un modulo esemplificativo che illustra come fare a scriverne degli altri molto più complessi, il nostro si limiterà ad illustrare i passi da svolgere per arrivare alla creazione. Quello che segue quindi è il più semplice modulo del kernel possibile: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 *  devme-module-t1.c - Il più semplice modulo
 **/
#include <linux/module.h>  /* Needed by all modules */
#include <linux/kernel.h>  /* Needed for KERN_ALERT */
 
 
int init_module(void) {
   printk("<1>Hello, I'm DevMe Kernel Module.\n");
 
   // A non 0 return means init_module failed; module can't be loaded.
   return 0;
}
 
 
void cleanup_module(void) {
  printk(KERN_ALERT "It was a pleasure work with U.\n");
}

Il codice di sopra è molto semplice e di facile comprensione. Come potete vedere ci sono alcuni metodi che devono essere implementati affinché il modulo possa essere creato correttamente. L’unica cosa degna di nota è l’utilizzo della funzione printk che non stampa nulla in output come potrebbe suggerire, ma è un meccanismo di loggin per il kernel. Il numero indicato tra parentesi acute rappresenta la priorità del log. Nel file linux/kernel.h sono elencate le varie priorità.

Affinché il modulo possa essere caricato è necessario compilarlo (ho scoperto l’acqua calda eh! :P ) , procediamo quindi con la creazione del nostro Makefile il quale renderà la procedura di installazione più pratica. Da precisare che con i kernel della serie 2.6 la procedura di compilazione dei kernel è leggermente cambiata, i moduli hanno estensione .ko e non .o come per la precedente serie 2.4. Anche la sintassi del Makefile è cambiata, ci sono alcune MACRO diverse da indicare durante la compilazione. Vediamo l’esempio che segue: 

1
2
3
4
5
6

obj-m += devme-module-t1.o
KVERSION = $(shell uname -r)
all:
	make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
clean:
	make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

otteniamo quindi:

mulp@devme-station:~$ make
make -C /lib/modules/2.6.32-24-generic/build M=/home/mulp/blog/kernel modules
make[1]: ingresso nella directory «/usr/src/linux-headers-2.6.32-24-generic»
  CC [M]  /home/mulp/blog/kernel/devme-module-t1.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/mulp/blog/kernel/devme-module-t1.mod.o
  LD [M]  /home/mulp/blog/kernel/devme-module-t1.ko
make[1]: uscita dalla directory «/usr/src/linux-headers-2.6.32-24-generic»
 
mulp@devme-station:~$ modinfo devme-module-t1.ko 
filename:       devme-module-t1.ko
srcversion:     C8EB2BC02FE416B3877C877
depends:        
vermagic:       2.6.32.15+drm33.5 SMP mod_unload modversions

Non rimane quindi che inserire il modulo all’intero del kernel e vedere cosa succede. Eseguiamo il comando bash:

mulp@devme-station:~$ insmod devme-module-t1.ko

Tutti i moduli caricati all’interno del kernel sono presenti all’interno di /proc/modules, se non credete andate a fare cat di quel file e troverete il modulo appena inserito al suo interno. Dopo aver provato l’emozione della creazione di un modulo del kernel, procedete alla sua rimozione con il comando:

mulp@devme-station:~$ rmmod devme-module-t1

e andate a vedere nei file kern.log e syslog….troverete i log indicati nel file sorgente del modulo. L’esempio di scrittura di questo modulo è puramente didattico, la logica è praticamente inesistente ed esistono altri modi di ottimizzare le chiamate di init e cleanup di un modulo. Nei prossimi vedremo qualche altro esempio più complesso.

Stay tuned !

Il backup di linux

In questo ultimo periodo mi sto occupando di trovare un metodo di backup da implementare per il server che amministro. Ho dato un occhiata a diversi sistemi che consentono di effettuare l’operazione di backup dei dati, ma al momento non ho ancora scelto quello che fa per me. In più ho postato anche sul forum del sito debianizzati.org un’ottima risorsa per la comunità Debian con gente in gamba disponibile ad aiutare altri in difficoltà. Quindi essendo un’altro in difficoltà, ho deciso di scrivere sul forum chiedendo loro un parere, al fine di risolvere il problema e di creare un guida più o meno completa del problema del backup su linux.
Vi siete mai chiesti quale sia lo strumento di backup utilizzato da wikipedia ? Sinceramente sì, ma non so come possa essere implementato…mi vengono in mente cluster di server che fanno solo quello con tera e tera disponibili utilizzati per salvare i dati.
E riferiamoci proprio a Wikipedia per la definizione di backup: "Il backup, copia di sicurezza o copia di riserva in informatica indicano un’operazione atta a prevenire la perdita totale dei dati archiviati nella memoria di massa dei computer siano essi stazione di lavoro o server. L’attività di backup è un aspetto fondamentale della gestione di un computer: in caso di guasti, manomissioni, furti, ecc., ci si assicura che esista una copia dei dati, pertanto l’esecuzione del backup è quasi sempre automatica e svolta normalmente con una periodicità stabilita (per esempio una volta al giorno o alla settimana)."
Su Linux esistono diversi strumenti per effettuare il backup dei dati…uno di questi è dd, un tool che si usa da riga di comando mooolto potente. Nei prossimi articoli riguardanti questo argomento vedremo altri tool.

Il comando dd

Il comando dd permette di copiare i dati in blocchi, effettuando delle conversioni all’occorrenza. E’ molto facile da utilizzare, in sostanza è necessario indicare il valore di 2 parametri.

devme:~$ dd if=/dev/sda1 of=/media/backup.img

Nell’esempio di sopra è richiesto a dd di effettuare la copia della prima partizione dell’unità sda all’interno dell’immagine backup.img. Al termine, il file di immagine corrisponderà alla partizione sorgente e sarà possibile montarlo grazie al comando mount. Vedremo più avanti come.

devme:~$ dd if=/dev/sda of=/media/sdb

In questo caso invece viene effettuata il clone del disco sda all’interno del disco sdb. Si noti che la copia in questo caso prevede la copia eventuale anche del MBR , master boot record e dell’eventuale partizione di swap.
La sintassi base del comando dd è la seguente:

devme:~$ dd if=<source></source> of=<target> bs=<byte size=""> skip= seek= conv=<conversion> </conversion></byte></target>

Per effettuare l’operazione simmetrica, ovvero il ripristino dei dati da un backup, è sufficiente invertire il valore dei parametri if e of. Vediamo ora una serie di esempi di utilizzo del comando dd.

Effettua la duplicazione di una partizione in un’altra partizione, copiando i dati in blocchi da 4kb, effettuando le conversioni: notrunc=non troncare il file di output,noerror=non fermarti in caso di errore nella lettura di un blocco di dato.

devme:^$ dd if=/dev/sda2 of=/dev/sdb2 bs=4096 conv=notrunc,noerror

Crea un’immagine ISO di un cd, leggendo in blocchi da 2kb, effettuando le conversioni: sync fa padding dei blocchi letti con bye nulli, noerror non fermarti in caso di errore nella lettura di un blocco di dato.

devme:^$ dd if=/dev/hdb of=/home/devme/cdrom.iso bs=2048 conv=sync,notrunc

Crea un’immagine ISO di un cd, leggendo in blocchi da 2kb, effettuando le conversioni: sync fa padding dei blocchi letti con bye nulli, noerror non fermarti in caso di errore nella lettura di un blocco di dato. Successivamente sarà possibile montare l’immagine creata usando il comando mount.

devme:^$ dd if=/dev/hdb of=/home/devme/cdrom.iso bs=2048 conv=sync,notrunc
devme:^$ mount -o loop /home/devme/cdrom.iso /mnt/iso_images

Effettuare una cancellazione sicura a prova di bomba, ovvero senza la possibilità di poter risalire ai dati scritti (secure delete).

1
2

#!/bin/bash 
for n in `seq 7`; do dd if=/dev/urandom of=/dev/sda bs=8b conv=notrunc; done

Modo semplice e veloce per effettuare un backup del proprio portatile. Segue comando per effettuare il ripristino.

devme:^$ dd if=/dev/hda of=/dev/sda bs=64k conv=notrunc,noerror
devme:^$ dd if=/dev/sda of=/dev/hda bs=64k conv=notrunc,noerror

Crea il backup di un hard disk e memorizzalo all’interno di una serie di DVD. Seguono comandi per il ripristino.

devme:^$ if=/dev/sda3 of=/home/devme/dvd_set_1.img bs=1M count=4430
devme:^$ dd if=/dev/sda3 skip=4430 of=/home/devme/dvd_set_2.img bs=1M count=4430
devme:^$ dd if=/dev/sda3 skip=4430 of=/home/devme/dvd_set_3.img bs=1M count=4430
devme:^$
devme:^$ dd if=/media/devme/devme_set_1.img of=/dev/sda3 bs=1M conv=sync,noerror
devme:^$ dd if=/media/devme/devme_set_2.img of=/dev/sda3 seek=4430 bs=1M conv=sync,noerror
devme:^$ dd if=/media/devme/devme_set_3.img of=/dev/sda3 seek=4430 bs=1M conv=sync,noerror

Copia il master boot record, ma non la tabella delle partizioni.

devme:^$ dd if=/dev/sda of=/home/devme/devme_mbr.img bs=446 count=1

Vediamo ora un caso particolare, ovvero fare il backup completo di un disco, quindi con MBR, tabella delle partizioni e tutte le partizioni del disco, e vediamo come fare a selezionare solo la partizione da montare con il comando mount. Quindi supponiamo di avere:

devme:^$ dd if=/dev/sda of=my_disk_image.img

con il quale effettuiamo il backup creando il nostro file immagine my_disk_image.img che contiene al suo interno l’intero disco. Per montare solo una certa partizione dovremmo sapere l’offset in cui inizia la partizione e quindi montarla con il comando mount sul dispositivo di loop. Per determinare l’offset dei vari elementi costituenti il disco utilizziamo un’altro comando di linux che consente di far questo, parted. Lanciando parted sul file appena creato otteniamo:

devme:^$ parted my_disk_image.img
GNU Parted 1.7.1
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) unit
Unit?  [compact]? B
(parted) print
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Number  Start        End           Size         Type     File system  Flags
1      32256B       106928639B    106896384B   primary  ext3         boot
2      106928640B   1184440319B   1077511680B  primary  linux-swap
3      1184440320B  10256924159B  9072483840B  primary  ext3
(parted) quit

a questo punto possiamo montare il file system che ci interessa indicando l’offset specifico, ovvero:

devme:^$ mount -o loop,ro,offset=32256 my_disk_image.img /mnt/devme

E qui mi fermo, anche perché potrei continuare per delle ore con degli esempi su dd, alcuni dei quali dimostrano quanto veramente potente è questo comando. Nei prossimi articoli vedremo altri strumenti per realizzare il backup.
Stay tuned !

Linux Day 2007

In occasione del Linux Day 2007 che si terrà in 118 città italiane, tra cui anche qui, vorrei dedicare questo post ad alcuni trick per linux, cose che magari non sono note a tutti, ma solo perchè un pò nascoste….in realtà siamo tutti un pò pigri.

 # 1 shopt -s cdspell shopt -s nocaseglob

Il primo abilita la correzione automatica dei nomi delle directory, quindi scrivendo /hom/mulp il riconoscimento avverrà per il percorso più simile a quanto digitato, probabilmente /home/mulp. Il secondo, permette di effettuare una ricerca case-insensitive quando si preme il tasto TAB per l’autocompletamento.

 #2 chattr +i file.txt chattr -i file.txt

Permette di rendere il file non vulnerabile ad eliminzioni casuali indipendentemente dall’utente che ne effettua l’operazione, anche da root. Il secondo comando lo disabilita.

#3 setterm -blenght 0

Messo in .bash_profile, permette di spegnere l’allarme dallo speaker del computer ogni volta che digitate qualcosa di sbagliato.

#4 mount -o loop -t iso9660 fileiso.iso /mnt/iso

Permette di montare una immagine ISO all’interno del file system e navigarla come se ne facesse parte.

#5 find . -type d | xargs chmod 775

xargs permette di formattare l’output fornito da un comando e darlo in pasto in modo formattato in input ad un altro programma. Il comando di sopra cerca tutti i file a partire dalla directory corrente, di tipo directory e lo fornisce in input a xargs che lo formatta e lo passa a chmod per settarne opportunamente i permessi.

#6 shred -z -u myfile

Elimina in modo sicuro myfile, sovrascrivendo il file 25 volte con dati casuali per poi terminare con una sequenza di 0.

#7 vm.swappiness=10

Modificate quella riga presente nel file /etc/sysctl.conf (createlo se non esiste) per forzare l’utilizzo minimo della swap. Se avete molta RAM tale da non saturarla mai, un valore minimo farà in modo che la quantità di swap occupata verrà minimizzata.

#8 opzione noatime

L’opzione noatime abilitata su una riga del file /etc/fstab, dove vengono montati i dischi, permetterà di aumentare le prestazioni del disco del 10%. Ogni volta che il disco compie una lettura, compie anche una scrittura per memorizzare le informazioni che riguardano l’orario di lettura del file. Abilitanto questa opzione il disco non scriverà quelle informazioni e si avrà un aumento delle prestazioni. Questo è solo un piccolissimo esempio su alcuni trick spulciati per fare qualcosa in più con il nostro sistema operativo Linux. Ne esistono molti altri ovviamente, tuttavia bisogna smanettare un pò per venirne a conoscenza. Se volete postarne qualcuno di nuovo fate pure. Alla prossima.