USB Storage

Utilizzo delle periferiche di storage connesse alla porta USB

In questa sezione, vedremo come utilizzare memory stick, floppy, hard disk, unità cd/dvd e fotocamere connesse ai nostri pc tramite porta USB.

Si da per scontato che sul sistema sia già configurato e funzionante il normale supporto per USB.

I dispositivi di storage connessi in questo modo, devono essere trattati come periferiche SCSI e gestiti con il supporto usbstorage. E' quindi necessario che il kernel linux in uso integri il supporto per questo tipo di periferiche.

Nelle distribuzioni di recente rilascio ( diciamo quelle uscite da un'anno a questa parte ) è difficile che non abbiano già incluso quanto richiesto. Solitamente è presente in forma modulare, quindi si troveranno i moduli:

sd_mod

scsi_mod

per quanto riguarda il supporto SCSI, e

usb-storage

Per accertarci che detti moduli siano presenti e disponibili per l'utilizzo, possiamo usare il comando 'modprobe', il quale oltre che a caricare i moduli del kernel, ci da modo di avere una lista di quelli disponibili. Possiamo provare quindi:

# modprobe -l  

Avremo la lista di tutti i moduli disponibili. Per una ricerca più veloce è il caso di usare un filtro ( grep ) sul comando appena visto:

# modprobe -l | grep sd_mod
/lib/modules/2.6.11-k7-2/kernel/drivers/scsi/sd_mod.ko

# modprobe -l | grep scsi_mod
/lib/modules/2.6.11-k7-2/kernel/drivers/scsi/scsi_mod.ko

# modprobe -l | grep usb-storage
/lib/modules/2.6.11-k7-2/kernel/drivers/usb/storage/usb-storage.ko 

Solitamente se il sistema HOT PLUG funziona, quando inseriamo una periferica usb, i moduli necessari al suo funzionamento, vengono caricati senza che sia necessario l'intervento manuale dell'utente. Per vedere facilmente cosa succede quando colleghiamo la nostra periferica, si può monitorare uno dei file di log del sistema, apriamo quindi una shell, acquisiamo i permessi di 'root' ed usiamo il seguente comando:

# tail -f /var/log/messages

Ci verranno visualizzate le ultime righe del file '/var/log/messages', 'tail' rimarrà attivo e ci mostrerà in tempo reale tutti i messaggi che verrano scritti in quel file. Inserendo ad esempio uno stick nella porta usb, sul mio sistema appare quanto segue:

usb 4-6.1: 
new
 full speed USB device 
using
 ehci_hcd and address 4
SCSI subsystem initialized
Initializing USB Mass Storage driver...
scsi0 : SCSI emulation 
for
 USB Mass Storage devices
usbcore: registered 
new
 driver usb-storage
USB Mass Storage support registered.
usb-storage: device found at 4
usb-storage: waiting 
for
 device to settle before scanning
Vendor:           Model: TS128MJFLASHA     Rev: 1.00
Type:   Direct-Access                      ANSI SCSI revision: 02
usb-storage: device scan complete
SCSI device sda: 253400 512-byte hdwr sectors (130 MB)
sda: assuming Write Enabled
sda: assuming drive cache: write through
SCSI device sda: 253400 512-byte hdwr sectors (130 MB)
sda: assuming Write Enabled
sda: assuming drive cache: write through
/dev/scsi/host0/bus0/target0/lun0: unknown partition table
Attached scsi removable disk sda1 at scsi0, channel 0, id 0, lun 0

E' da premettere che quando ho inserito la chiavetta, nessuno dei moduli su citati era stato caricato, il tutto è stato fatto in modo automatico da hotplug.

Ciò che ci interessa maggiormente al momento è l'ultima riga

Attached scsi removable disk sda1 at scsi0, channel 0, id 0, lun 0

Perche' ci indica il device 'sda1' del nostro dispositivo.

Per poterlo utilizzare, dovremo montare la partizione #1 in una directory del nostro disco ( ad esempio /mnt/usb ) che possiamo creare con il comando:

# mkdir /mnt/usb

Si presume che il tipo di filesystem utilizzato per la nostra periferica sia di tipo vfat ( o fat16 ) e che nel nostro kernel sia disponibile il supporto. Anche per questo, possiamo usare il sistema precedente, ovvero controllare che ci sia il modulo che ci serve:

# modprobe -l | grep vfat
/lib/modules/2.6.11-k7-2/kernel/fs/vfat/vfat.ko

Quindi carichiamolo, nel caso in cui non lo sia già:

# modprobe vfat

Montiamo la partizione del nostro disco:

# mount -t vfat /dev/sda1 /mnt/usb

Controlliamo cosa c'è dentro:

# ls -la /mnt/usb

Ci farà vedere il contenuto della partizione che abbiamo montato. Prima di sfilare lo spinotto dalla presa usb, dobbiamo ricordarci di smontare la partizione

# umount /mnt/usb

Possiamo semplificare le operazioni di mount, inserendo nel file /etc/fstab la seguente riga

/dev/sda1    /mnt/usb    vfat    rw,noauto,user,uid=1000     0   0

NB: 'uid=1000' rende l'utente con userid 1000, proprietario del punto di mount, che in questo caso corrisponde al mio utente, questo per avere i permessi di lettura e scrittura sul device.

Per conoscere qual'è il proprio userid:

# id netwalker
uid=1000(netwalker) gid=1000(netwalker)

In questo modo potremo montare il nostro dispositivo, semplicemente digitando il comando:

# mount /mnt/usb

Di recente è stato introdotto un sistema 'udev' che ci facilita notevolmente la gestione di questo tipo di periferiche, come descritto nella sezione PersistentDeviceNames. Vedremo di seguito qualche esempio pratico di utilizzo, che ci consente di eseguire automaticamente tutte le operazioni che vogliamo, quando connettiamo una periferica alla porta USB, come ad esempio il suo montaggio o qualsiasi altra operazione che ci viene in mente, utilizzando un più o meno semplice script bash.

In Debian Sarge (l'attuale release 'stable'), udev non viene installato di default, dovremo quindi procedere ad installarlo:

# apt-get install udev

A questo punto, posso attribuire alla mia penna USB, un device diverso da quello standard che abbiamo visto prima (/dev/sda1).

Poniamo il caso che voglia ottenere /dev/usbkey e che desideri anche che venga montato automaticamente nella directory /media/usbkey.

Per prima cosa devo trovare degli elementi distintivi che mi permettano di indicare ad udev come riconoscerlo. Andrò a connettere la penna su una porta USB e leggerò le sue caratteristiche tramite udev:

# udevinfo -a -p /block/sda/sda1|less

Otterò come risultato qualcosa di simile a quanto segue:

device '/sys/block/sda/sda1' has major:minor 8:0
looking at 
class
 device '/sys/block/sda/sda1':
SUBSYSTEM="
block
"
SYSFS{dev}="
8:0
"
SYSFS{range}="
16
"
SYSFS{removable}="
1
"
SYSFS{size}="
253400
"            <<--
SYSFS{stat}="
  12  183  217  301    0    0    0    0    0  223  301
"

follow the 
class
 device's "
device
"
looking at the device chain at '/sys/devices/pci0000:00/0000:00:10.3/usb4/4-6/4-6.1/4-6.1:1.0/host10/target10:0:0/10:0:0:0':
BUS="
scsi
"                      <<--
ID="
10:0:0:0
"
DRIVER="
sd
"
SYSFS{device_blocked}="
0
"
SYSFS{iocounterbits}="
32
"
SYSFS{iodone_cnt}="
0x26
"
SYSFS{ioerr_cnt}="
0x2
"
SYSFS{iorequest_cnt}="
0x26
"
SYSFS{max_sectors}="
240
"
SYSFS{model}="
TS128MJFLASHA   
"  <<--
SYSFS{queue_depth}="
1
"
SYSFS{queue_type}="
none
"
SYSFS{rev}="
1.00
"
SYSFS{scsi_level}="
3
"
SYSFS{state}="
running
"
SYSFS{timeout}="
30
"
SYSFS{type}="
0
"
SYSFS{vendor}="
        
"         <<--

NB: con '<<--' sono indicate le caratteristiche che prenderò come riferimento.

Come descritto in PersistentDeviceNames, andrò a creare una regola che consenta ad UDEV di riconoscere questa specifica periferica. Le regole di default di UDEV si trovano nel file /etc/udev/udev.rules. Queste vengono lette in modo sequenziale, dall'alto verso il basso e considerato il fatto che ce ne sono già di generiche per le periferiche usb, andrò ad inserie le mie personalizzate, all'inizio del file /etc/udev/udev.rules, come segue:

# There are a number of modifiers that are allowed to be used in some
# of the different fields. They provide the following subsitutions:
#
# %n the "
kernel number
" of the device.
#    For example, 'sda3' has a "
kernel number
" of '3'
# %e the smallest number 
for
 that name which does not matches an existing node
# %k the kernel name 
for
 the device.
# %M the kernel major number 
for
 the device
# %m the kernel minor number 
for
 the device
# %b the bus id 
for
 the device
# %c the string returned by the PROGRAM
# %s{filename} the content of a sysfs attribute.
# %% the '%' 
char
 itself.
#

# Device personalizzati
BUS="
scsi
", SYSFS{vendor}="
        
", SYSFS{model}="
TS128MJFLASHA   
", SYSFS{size}="
253400
", NAME="
usbkey
", SYMLINK="
%k
"

Salviamo il file. Inserendo la chiave nella porta USB, se tutto funziona correttamente, dovrei ritrovarmi "usbkey" (come impostato con NAME="usbkey") fra i miei device.

root@netserv:/ # ls -la /dev/usb*
brw-rw----  1 root floppy 8, 0 2005-10-08 20:02 /dev/usbkey

Non mi resta che dire ad UDEV se e cosa fare quando connetto il dispositivo. Poniamo il caso che io voglia montatlo automaticamente nella directory /media/usbkey.

Per prima cosa, dovrò modificare /etc/fstab come visto in precedenza, in questo caso:

/dev/usbkey    /media/usbkey    vfat    rw,noauto,user,uid=1000     0   0

Creiamo la directory /media/usbkey:

# mkdir /media/usbkey

Possiamo ora montare la nostra chiavetta con un semplice:

$ mount /media/usbkey

Chiedere ad UDEV di farlo per noi è abbastanza semplice, una volta creato il device, esegue da solo qualsiasi script bash, con estensione .dev, che si trovi nella directory /etc/dev.d/'nome_device'. Tali directory non vengono create da UDEV e quindi dovremo farlo a manina:

# mkdir /etc/dev.d/usbkey

Creeremo uno script che chiameremo mount.dev il quale non farà altro che lanciare per nostro conto il comando di mount, visto prima:

# vi /etc/dev.d/usbkey/mount.dev

#!/bin/sh
if
 [ "
$ACTION
" == "
add
" ]; then
su netwalker -c "
mount /media/usbkey
"
fi

Lo renderemo eseguibile:

# chmod +x /etc/dev.d/usbkey/mount.dev

Connettendo la chiave e dando il comando 'mount' troveremo il nostro dispositivo montato:

# mount
/dev/usbkey on /media/usbkey type vfat (rw,noexec,nosuid,nodev,uid=1000,user=netwalker)

Buon divertimento