<- SL: Teoria del firewall - Archivio Generale - Copertina - SL: Il Mio "Personal Firewall" ->

GNU/Linux e autoloader: un'avventura

di Rudi Giacomini Pilon

Dopo una piacevole avventura con un file server GNU/Linux :-), abbiamo deciso di upgradare il sistema, che era divenuto un poco stretto per le nostre necessità. Abbiamo incontrato non poche difficoltà a gestire il backup, così ho deciso di evitare ad altri una simile avventura spiegando come siamo arrivati alla fine dei nostri guai.

Viste le nostre necessità e ciò che offriva il mercato, si è deciso l'acquisto di un server IBM Netfinity 5000, con controller SCSI Hot-Swap e 4 dischi da 36Gb riuniti in un disco logico da 80Gb. La scelta è stata motivata da una dichiarata conformità a GNU/Linux da parte di IBM.

Si prevedeva di dover eseguire il backup di almeno 30Gb di dati, e quindi abbiamo acquistato un autoloader (previsto come opzione dalla IBM). Un autoloader è un unità a nastro che al posto del nastro accetta un apposito contenitore ('magazine') dotato di guide per ospitare 6 nastri da 20Gb (40Gb compressi) per un totale max di 240Gb di backup. I nastri vengono posizionati sulla testina dalla meccanica dell'unità. Il singolo nastro si intende 'caricato' solo quando viene portato in posizione di lettura/scrittura.

Sul suddetto server è stata installata una distribuzione Red Hat 6.2 (per mere ragioni di competenza del sottoscritto, come illustrato anche in un altro articolo sul backup).

L'unità è stata riconosciuta senza difficoltà ;-) dal sistema; scorrendo i messaggi di avvio del PC, infatti, si scopre che essa viene identificata come Seagate DAT 06241-xxx, ed indirizzata tramite un device /dev/st0 che, per comodità, è stato linkato con un nome più significativo tramite il comando seguente:

	ln -s /etc/st0 /etc/tape

Abbiamo, quindi, caricato un magazine di nastri e poi un nastro (tramite i comandi sul pannello frontale), ed eseguito una copia di test sul dispositivo /dev/tape con il comando

	tar -cvf /dev/tape testfile

Il tutto ha funzionato alla perfezione, e ci siamo ritrovati un backup del file testfile a velocità record.

Nasceva quindi la necessità di sfruttare l'autoloader per il caricamento automatico dei nastri ed il cambio degli stessi. Dopo molte ricerche in internet ho scoperto (da un newsgroup) l'esistenza del programma mtx (rif. mtx.sourceforge.net ). Questo programma viene definito come "tape changer control program", ovvero un programma in grado di gestire la parte robotica di un autoloader. Infatti, leggendo attentamente il file delle FAQ che accompagna i sorgenti di tale comando, si comprende che una unità autoloader è composta da due devices:

1. l'unità di backup
2. il meccanismo di loading

le due unità vengono interpretate come dispositivi di tipologia differente, uno sequenziale e uno a blocchi, e devono venire associate a due differenti device.

Il problema era che il kernel individuava in automatico solo il device per il backup; infatti dando un comando:

	cat /proc/scsi/scsi

l'output risultante non mostrava nessuna unità "Media changer" o similari.

La risposta ancora una volta nelle FAQ: il controller scsi installato nel server ha uno SCSI ID unico ma 2 LUN's (Logical Units) differenti. Per risolvere il problema bisogna ricompilare il kernel o aggiungere la seguente linea al file /etc/lilo.conf : append="max_scsi_luns=2"

Eseguire poi: /sbin/lilo e riavviare il pc.

Vi assicuro che a tale punto l'unità è stata individuata immediatamente dal sistema (come device /dev/sge). Come suggerito dalle istruzioni di mtx il device è stato linkato ad un nome che viene individuato come dispositivo di default dal comando:

	ln -s /dev/sge /dev/changer

Il comando mtx permette il caricamento dei nastri con comandi tipo

	mtx load n (ove n è il numero del nastro)

o di scaricare il magazine completo con

	mtx eject

Per automatizzare le procedure di backup ho quindi modificato degli script che ho preso dal "Backup how-to", e che sono disponibili al link seguente:

ftp:web.tiscalinet.it/rgnet/files/backupfunctions.tar.gz

Spero di essere stato esauriente e di avere evitato a qualcuno la fatica da noi compiuta per far funzionare il tutto. Scrivetemi pure per segnalare errori o richiedere aiuto:

Appendice A

backup.sh

#!/bin/sh
#
# backup.sh  -  Backup control script
#
# Usage:  backup.sh LEVEL
#
#   where LEVEL = 0, 1
#

# Variables
#manda un e-mail del risultato a: 
EMAILTO=" <rudig@mercury>"
#nome del device di backup
DESTFILE="/dev/tape"
#directory o singoli files da backuppare (separati da uno spazio)
BACKUPFILES="/root /etc /home "
#directory dove stanno le funzioni di backup
BACKUPDIR="/usr/local/bin"
#livello del backup (atteso come parametro)
LEVEL="${1}"
#block factor del nastro modificare come di convenienza
BLOCKS=512
#device del autoloader
MEDIACHANGER="/dev/changer"

# Load backup functions
cd ${BACKUPDIR}
. backup-functions


TAPE_N=$(date '+%w')
if [ $TAPE_N = 7 ]
then
	#domenica
	unload_tape
	eject_magazine
	exit
fi
if [ $TAPE_N = 6 ]
then
	#pulizia
	unload_tape
	load_tape	
	exit
fi

Appendice B

backup-functions

# This is not a shell script; it provides functions for the backup.sh script
# that sources it.

# Variables
L0DATESTAMP="${BACKUPDIR}/.level0_datestamp"
NOW=`date`



#activate dat compression
compression_on ()
{
  echo "Activating compression..."
  mt -f ${DESTFILE} datcompression
  wait $!
}


#unload the tape from autoloader
unload_tape ()
{
  echo "Unloading tape..."
  mt -f ${DESTFILE}  offline
  wait $!
}

#load tape (tape_n)
load_tape ()
{
  echo "Loading tape..." $TAPE_N

  mtx -f $MEDIACHANGER load $TAPE_N
  wait $!
} 

#eject magazine from autoloader
eject_magazine ()
{
  mtx -f $MEDIACHANGER eject	
}


# tar_backup function: does the archiving
tar_backup ()
{
  echo "Level-${LEVEL} Backup ${NOW}"
  if [ "${LEVEL}" = "0" ]; then
    # make Level-0 datestamp
    echo ${NOW} > ${L0DATESTAMP}
    # Level-0 backup
    tar --create  --verbose --file ${DESTFILE} \
        --blocking-factor ${BLOCKS} --label "Level-${LEVEL} Backup ${NOW}" ${BACKUPFILES}
  elif [ "${LEVEL}" = "1" ]; then
    # get last Level-0 datestamp
    LAST=`cat ${L0DATESTAMP}`
    # Level-1 backup
    tar --create --verbose --file ${DESTFILE} --blocking-factor ${BLOCKS} \
        --after-date "${LAST}" --label "Level-${LEVEL} Backup from ${LAST} \
	to ${NOW}" ${BACKUPFILES}
  else
    # Backup level error
    echo "Error: Level-${LEVEL} unknown"
    exit
  fi
  echo "Level-${LEVEL} Backup END"
}

# tar_verify function: test the archive for errors
tar_verify ()
{
  echo "Level-${LEVEL} Backup Verify ${NOW}"
  # Backup verify test
  tar --list --verbose --file ${DESTFILE} --blocking-factor ${BLOCKS} 
  echo "Level-${LEVEL} Backup Verify END"
}


#tar_list function: List files from archive
tar_list ()
{
  tar --list --verbose --file ${DESTFILE}  --blocking-factor ${BLOCKS} 
}

# mail_report function: sends backup report
mail_report ()
{
  # Email backup report
  mail -s "${HOSTNAME} - Level-${LEVEL} Backup" "${EMAILTO}" << EOF

###########################################################
Level-${LEVEL} Backup
###########################################################

Host:  ${HOSTNAME}
Files: ${BACKUPFILES}

Destination: ${DESTFILE}
Tape: ${TAPE_N}

###########################################################
Started:   ${NOW}
Completed: `date`
###########################################################

EOF
}

<- SL: Teoria del firewall - Archivio Generale - Copertina - SL: Il Mio "Personal Firewall" ->