Mounten von Datenträgern

In dieser Anleitung wird das Mounten von Datenträgern anhand einiger Beispiele beschrieben. So wird die Verwendung von usbmount, der fstab und den Befehlen mount und umount mit den Dateisystemen ext2/3/4, NTFS und VFAT erläutert. Diese Anleitung kann als Grundeinstieg in das Thema Mounten dienen und ist auch für absolute Anfänger geeignet.

Softwarevoraussetzungen: Editor | Paketverwaltung
Schwierigkeitsgrad: Mittel (Grundwissen erforderlich)
Ausgetestet mit folgenden Betriebssystemen: Ubuntu | Debian

Grundbegriffe des Mountens

Unter Unix/Linux müssen Dateisysteme, die sich beispielsweise auf Wechseldatenträger (USB-Sticks, USB-Festplatten) oder lokalen Datenträgern (interne Festplatte) befinden gemountet werden, um verwendet zu werden. Dies geschieht unter allen gängigen Desktopdistributionen automatisch.
Nur Serversysteme machen hierbei eine Ausnahme, deshalb müssen hier Dateisysteme manuell gemountet werden, dies geschieht mit dem Befehl mount. Ausgehängt werden kann das Dateisystem schließlich mit umount.

Datenträger

Datenträger tragen unter Linux zum Beispiel die Bezeichnungen sda, eine Partitionen (in diesem Fall die erste) trägt dann auf diesem Datenträger die Beizeichnung sda1. Die Datenträger liegen zusammen mit anderen Geräten in /dev, also in unserem Beispiel /dev/sda beziehungsweise /dev/sda1. Die korrekte Bezeichnung erfahre ich, indem ich mir den Inhalt von /dev anschaue und nach sdaxx Ausschau halte, die kann man so erledigen:

user@system:~$ ls /dev/ | grep sd

Ich erhalte folgende Ausgabe:

sda     sda2    sdb
sda1   sda5   sdb1

Dem entsprechend habe ich zwei Festplatte/Wechseldatenträgermedien angeschlossen, nämlich sda und sdb. sda hat drei Partitionen (sda1, sda2, sda5) und sdb nur eine (sdb1). Diese Partitionen kann ich nun mounten.
Alternativ könnte ich mir auch mit cat die Datei /proc/partitions ausgeben lassen:

Hinweis: sda ist meistens die Systemplatte; IDE Platten haben meistens einen anderen Vorsatz (hdxx), deshalb muss auch anders gesucht werden (ls /dev/ | grep hd)

user@system:~$ cat /proc/partitions 
major minor  #blocks  name
 
   8        0 1953514584 sda
   8        1 1947495658 sda1
   8        2          1 sda2
   8        5    6016311 sda5
   8       16 2930266584 sdb
   8       17 2930264015 sdb1

An dieser Ausgabe kann ich nun zusätzlich die Größer der Partitionen erkennen (sda1 ist fast 2TB groß, sdb1 fast 3TB).

Dateisysteme

Linux unterstützt von Haus aus verschiedene Dateisysteme, unter anderem NTFS, allerdings werden dazu unter bestimmten Umständen auf Debian erst noch folgende Pakete benötigt:

ntfsprogs ntfs-3g libntfs-3g75

Diese installieren wir einfach nach:

user@system:~$ sudo apt-get install ntfsprogs ntfs-3g

Dateisysteme (Partitionen) werden in einem so genannten Mountpoint gemountet. Dazu legt man entweder in /mnt oder /media einen passenden Ordner an, in diesem wird dann diese gemountet, wie das geht erfährst du in den folgenden Beispielen.

Mounten

Einfaches Beispiel mit ext2/3/4

In diesem Beispiel will ich die Partition 1 der Platte sdb mit dem Dateisystem ext3 und in /media/Platte mounten. Dazu brauche ich als erstes den Ordner /media/Platte, also lege ich diesen an:

user@system:~$ sudo mkdir /media/Platte

Nun kann ich die Platte ganz einfach mounten:

user@system:~$ sudo mount /dev/sdb1 /media/Platte

Anschließend müsste sdb1 in /media/Platte gemountet sein. Ein kleiner Test gibt Aufschluss darüber, dazu nutzen wir mount -l:

user@system:~$ mount -l

Wie ich an der Ausgabe erkennen kann, ist sie richtig gemountet:

/dev/sda1 on /media/Platte type ext3 (rw) 

Möchte ich die Partition jetzt wieder aushängen, dann muss ich mit umount arbeiten:

user@system:~$ sudo umount /media/Platte

Nun ist die Platte wieder ausgehängt.

NTFS mounten

Da man zu mounten von NTFS Dateisystemen andere Optionen braucht, werde ich hier kurz noch drauf eingehen. Ich will das Dateisystem sdb2, auf welchem sich ein NTFS Dateisystem befindet in /media/ntfs mounten, also lege ich wieder einen Mountpoint an:

user@system:~$ sudo mkdir /media/ntfs

Nun kann das Dateisystem gemountet werden:

user@system:~$ sudo mount -t ntfs  -o rw,users,nls=utf8,umask=007,gid=46 /dev/sdb2 /media/ntfs

Aushängen geht dann wieder relativ einfach über..

user@system:~$ sudo umount /media/ntfs

VFAT mounten

Auch VFAT Dateisysteme benötigen bestimmte Optionen. Hier will das Dateisystem sdb2, auf welchem sich ein VFAT Dateisystem befindet in /media/vfat mounten, also lege ich wieder einen Mountpoint an:

user@system:~$ sudo mkdir /media/vfat

Jetzt kann das Dateisystem gemountet werden:

user@system:~$ sudo mount -t vfat  -o utf8,umask=007,gid=46 /dev/sdb2 /media/vfat

Aushängt wird wieder über:

user@system:~$ sudo umount /media/vfat

Bind Mounts

Muss ein Verzeichnis an zwei Orten im Dateisystem eingebunden werden hilft entweder ein SymLink oder ein mount –bind, wie man –bind mountet wird hier erklärt. Der Vorteil ist davon, dass man so Verzeichnisse an mehreren Orten im Dateisystem unter verschiedenen rechten verwalten kann, dies ist ganz praktisch im Bezug auf FTP- oder Web-Server.

Ein solcher Mount sieht in der Syntax vereinfacht so aus:

user@system:~$ sudo mount --bind  /Ort /Ziel

Zum Beispiel will ich /home/user/share auch in /home/user1/share-user verfügbar machen, das würde dann so aussehen:

user@system:~$ sudo mount --bind /home/user/share /home/user1/share-user

und somit wäre der mount perfekt ;)

Umounten klappt wie gewohnt:

user@system:~$ sudo umount /home/user1/share-user

Mountpoint in der fstab definieren

Da sich Beizeichnungen von Festplatten ändern können definiert man generell in der sogenannten fstab (/etc/fstab) die Mountpoints. Dazu öffnen wir diese mit nano (falls nicht vorhanden: apt-get install nano)

user@system:~$ sudo nano /etc/fstab

Einführung mit ext4

Um dort allerdings Mountpoints über die UUID des Dateisystems zu mounten brauchen wir das Tool blkid, mit diesem lassen wir uns die UUIDs anzeigen:

user@system:~$ blkid

Die Aussgabe zeigt von allen angeschlossenen Dateisystemen die UUIDs, wie hier in einem Beispiel dargestellt:

/dev/sdb1: UUID="2fbd073f-e1b7-4011-87c1-df1c6b00fc21" TYPE="ext4"

Auch wird das Dateisystem (hier ext4, da TYPE=„ext4“) angezeigt. Mit diesem Angaben füttern wir nun fstab in folgender Syntax:

# <Dateisystem> <Mountpoint>   <Dateisystemart>  <Optionen>   <Für Backupprogramm dump>  <Automatische Überprüfung>

Ein Beispiel mit der oben dargestellten Ausgabe:

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21 /media/second  ext4   auto,defaults   0   2

Hier würde die Platte automatisch beim Starten gemountet werden (auto →wenn die Festplatte nicht angeschlossen ist, wird Linux beim Starten hängen bleiben und nach der Platte verlangen!) und nach einer gewissen Anzahl Boots überprüft werden (0=keine Üperprüfung 2= Überprüfung). Diese Überprüfungsfunktionen muss für NTFS Dateisystemen deaktiviert werden! Das Dateisystem würde in /media/second gemountet werden.

Angenommen, ich will die Festplatte nicht bei hochfahren mounten wollen, weil sie eine externe Platte ist und nur gelegentlich an dem Rechner hängt, dann müsste das so aussehen:

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21 /media/second  ext4   noauto,defaults   0   2

Dank noauto wird die Platte nun beim starten nicht automatisch gemountet, das könnte ich dann von Hand so erledigen:

user@system:~$ sudo mount /media/second

Ich müsste praktisch nur den Mountpoint mounten.

NTFS über fstab

Angenommen das oben dargestellte Dateisystem wäre vom Typ NTFS (TYPE=„NTFS“), dann müsste die fstab so aussehen (automatischer Mount durch auto):

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21 /media/second  ntfs  rw,auto,users,exec,nls=utf8,umask=007,gid=46  0  0

Wollte ich die Platte nicht automatisch mounten (noauto), müsste das so aussehen:

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21 /media/second  ntfs  rw,noauto,users,exec,nls=utf8,umask=007,gid=46  0  0

Mounten könnte ich das Dateisystem dann wieder so:

user@system:~$ sudo mount /media/second

VFAT über fstab

Bei VFAT-Dateisystemen würde die fstab so aussehen (auto):

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21  /media/second  vfat auto,utf8,umask=007,gid=46  0  2

…mit noauto:

UUID=2fbd073f-e1b7-4011-87c1-df1c6b00fc21  /media/second  vfat noauto,utf8,umask=007,gid=46  0  2

und der Mount (nur bei noauto):

user@system:~$ sudo mount /media/second

Bind Mounts in der fstab

Das würde an dem Beispiel von oben (/home/user/share in /home/user1/share-user) so aussehen:

/home/user/share /home/user1/share-user   none  auto,bind  0  0

Der Mount würde dann automatisch durchgeführt werden, um das zu verhindern müsste wieder ein noauto eingefügt werden.

Automatisches Mounten

Datenträger, die statisch im Rechner verbaut sind und somit immer angeschlossen sind, sollten beim Booten über die fstab gemountet werden und nicht mit usbmount oder dem hier erläuterten Mount-Skript. Diese Methoden (usbmount, Mount-Skript) eignen sich nur für Datenträgern, die nicht automatisch bei Reboot gemountet werden sollen und später bei Bedarf temporär einhängt werden.

Automatisches Mounten durch ein Mount-Skript

Auf die Dauer kann es wahnsinnig lästig werden, immer die externe Platte auf dem Server zu mounten, wenn man sie mal wieder braucht, dazu gibt es eine einfache Abhilfe.

Zu erst muss die Platte in der fstab eingetragen werden und zwar auf noauto, da das Skript minütig überprüft, ob die Festplatte angeschlossen ist und, wenn die der Fall ist diese mountet. Dann braucht man das Tool lsusb (falls nicht vorhanden: apt-get install usbutils). Wir wollen erst einmal wissen, wie der Wechseldatenträger erkannt wird:

user@system:~$ lsusb

Ich erhalte folgende Ausgabe, was die Festplatte betrifft (jedes Modell wird anders erkannt):

Bus 001 Device 003: ID 0bc2:5021 Seagate RSS LLC

Nun wird es problematisch, wenn man mehrere Festplatten besitzt, die unter selben Namen (ID .. beachten) erkannt werden und mit diesem System in Kontakt kommen. Falls dies der Fall ist, kann dieses Skript nicht verwendet werden. Deshalb bitte bei mir melden, ich würde das Skript dann erweitern. Wichtig ist in meinem Fall diese Passage:

ID 0bc2:5021 Seagate RSS LLC

Da ich keine weitere Platte dieser Art habe, nehme ich nur folgendes:

Seagate RSS LLC

So, nun habe ich alle relevanten Daten gesammelt, das bedeutet, ihr bekommt das Skript zu Gesicht:

automount.sh
#!/bin/bash
###
# Konfig
###
 
log="/var/log/automount.log"    # Logfile
p1="/media/fourth"              # Mountpoint Platte 1
device="Seagate RSS LLC"        # wie wird die Platte erkannt (lsusb)
 
#### nicht verändern ####
test -d  $log || touch $log
 
if mount | fgrep $p1 > /dev/null 2>&1 ; then echo "$(date) bereits gemountet" >> $log && exit
else     
	if lsusb | egrep "$device" > /dev/null 2>&1 ; then 
	 mount $p1 && echo "$(date) $p1 gemountet" >> $log
        else echo " $(date) keine Platte" >> $log && exit 1
	fi
fi

Der Konfig Header muss geändert werden, wie ihr seht ist das Skript nur für ein Dateisystem geeignet, hier eins für zwei (diese zwei Dateisysteme müssen auf dem selben Datenträger liegen!):

automount.sh
#!/bin/bash
###
# Konfig
###
 
log="/var/log/automount.log"    # Logfile
p1="/media/fourth"              # Mountpoint Platte 1
p2="/media/third"               # Mountpoint Platte 2
device="Seagate RSS LLC"        # Wie wird die platte erkannt (lsusb)
 
#### nicht verändern ####
test -d  $log || touch $log
 
if mount | fgrep $p1 > /dev/null 2>&1 ; then echo "$(date) bereits gemountet" >> $log && exit
else     
	if lsusb | egrep "$device" > /dev/null 2>&1 ; then 
	 mount $p1 && echo "$(date) $p1 gemountet" >> $log
	 mount $p2 && echo "$(date) $p2 gemountet" >> $log
	else echo " $(date) keine Platte" >> $log && exit 1
	fi
fi

Die Konfiguration ist hoffentlich selbsterklärend.

Nun muss ich das Skript nur noch in regelmäßigen Abständen ausführen, das übernimmt für uns Cron (falls nicht vorhanden: apt-get install cron). Das Skript muss wie immer ausführbar gemacht werden und als automount.sh (Name veränderbar) abgespeichert werden (mehr zu Shell-Skripten):

user@system:~$ nano /home/user/automount.sh                 # Pfad ändern; Skript einfügen und speichern [STRG]+O, dann schließen mit [STRG]+X
user@system:~$ chmod +x+u /home/user/automount.sh           # ausführbar machen

Nun erstellen wir eine Crontab für den User Root:

user@system:~$ sudo crontab -e

und erstellen erst mal eine Grundkonstellation für die Tab (falls bereits vorhanden, kann Schritt übersprungen werden):

#-----------------------------------------------------------------
# Shell variable for cron
SHELL=/bin/bash
# PATH variable for cron
PATH=/usr/local/bin:/usr/local/sbin:/sbin:/usr/sbin:/bin:/usr/bin:/usr/bin/X11
# mailto
MAILTO=root

danach füllen wir die Crontab mit folgendem:

* * * * *  /home/user/automount.sh       # Pfad zum Skript; bei Bedarf anpassen

Sollte der Vim für die Crontab verwenden worden sein, :wq eingeben, sollte nano verwendet worden sein, genügt [STRG]+O und danach [STRG]+X

Nun wird das Skript jede Minute ausgeführt, sollte die Festplatte angeschlossen, aber nicht gemountet sein, wird dies automatisch erledigt. Zur Sicherheit kann man nun das Logfile betrachten:

user@system:~$ sudo tail -f /var/log/automount.log

Automatisches Mounten mit usbmount

Eine weitere und wesentlich einfachere Möglichkeit, USB-Medien automatisch zu mounten bietet das Programm usbmount.

Wichtige Hinweise:

  • In der aktuellen Ubuntu/Debian Version von usbmount werden Datenträger, falls ein Eintrag in der /etc/fstab existiert wie dort verordnet gemountet, unbekannte Datenträger werden ebenfalls eingehängt.
  • Ältere usbmount Versionen können (einfach mal ausprobieren, ob usbmount auch in der fstab definierte Datenträger mountet) dies nicht, falls ein Datenträger/Dateisystem automatisch gemountet werden sollte, darf KEIN Eintrag zu diesem Dateisystem (wenn die fstab nicht verändert wurde, ist dies immer der Fall) in der /etc/fstab existieren.









usbmount lässt sich wie folgt installieren:

user@system:~$ sudo apt-get install usbmount

Die Datei bedarf noch einiger Feineinstellung, um auch NTFS und VAT Dateisysteme richtig zu mounten:

user@system:~$ sudo nano /etc/usbmount/usbmount.conf

Hier muss die Option FS_MOUNTOPTIONS so verändert werden:

FS_MOUNTOPTIONS="-fstype=ntfs,nls=utf8,umask=007,gid=46 -fstype=vfat,gid=floppy,dmask=0007,fmask=0117"

Sowie FILESYSTEMS durch NTFS erweitert werden:

FILESYSTEMS="vfat ntfs ext2 ext3 ext4 hfsplus"

Anschließend muss man noch die Systembenutzer, die Zugriff auf den USB-Wechseldatenträger mit dem Dateisystem VFAT wollen, der Gruppe floppy hinzufügen:

user@system:~$ sudo adduser USER floppy       # USER durch Benutzername ersetzten
user@system:~$ sudo adduser ich floppy        # Beispiel mit Benutzer "ich"

Beim Anschließen eines USB-Datenträgers wird jener in /media/usb0 gemountet, der nächste in /media/usb1 und so weiter - bis /media/usb7.

Hier ein Beispiel:

user@system:~$ ls -al /media

Ich erhalte folgende Ausgabe:

total 48
drwxr-xr-x 12 root root   4096 Sep 25 14:43 .
drwxr-xr-x 21 root root   4096 Sep 22 22:58 ..
lrwxrwxrwx  1 root root      4 Sep 25 14:43 usb -> usb0
drwxrwx--- 10 root floppy 4096 Jan  1  1970 usb0
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb1
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb2
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb3
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb4
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb5
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb6
drwxr-xr-x  2 root root   4096 Sep 25 14:43 usb7

…hier wurde ein VFAT Dateisystem erkannt und als /media/usb0 gemountet.


chrisge 2018/05/26 00:51

Zur Bereitstellung eines bestmöglichen Angebots setzt diese Webseite Cookies ein. Durch die Nutzung dieser Webseite erklären Sie sich mit der Verwendung von Cookies einverstanden. Weitere Informationen