[[Vorlage(Getestet, jammy, focal)]] {{{#!vorlage Wissen [:Pakete installieren: Installation von Programmen] [:Terminal: Ein Terminal öffnen] [:Programme_starten: Starten von Programmen] [:mit Root-Rechten arbeiten:] }}} [[Inhaltsverzeichnis()]] ## Alias: udisks, udisks2, udisksctl Das Subsystem UDisks ist ein ''"Disk Manager"'' und dient bei Linux-Systemen seit langem (Vorläufer ab 2003) zur Handhabung von Platten und anderen Geräten zur Datenspeicherung. Bei Ubuntu wird mit udisks2 die 2. Generation des Subsystems eingesetzt. Eine wichtige Aufgabe von UDisks ist die Ein- und Ausbindung von auf [:Datenträger:Datenträgern] gespeicherten [:Dateisysteme:Dateisystemen] in die Dateihierarchie des Systems auch für normale Benutzer (d.h. nicht [:root:]) zu ermöglichen. Man benutzt UDisks nicht direkt, sondern über ein Client-Programm. Das kann auch ein zu einer Desktop-Umgebung gehörendes GUI-Programm wie beispielsweise [:Laufwerksverwaltung:Laufwerke (gnome-disks)] oder ein [:Dateimanager:] wie z.B. [:Nautilus:] sein. Das System UDisks besteht aus mehreren Komponenten: * Einem [:Dienste:DAEMON] `udisksd`, dieser erhält über den [:D-Bus:System-D-Bus] Aufträge übermittelt und führt die jeweilige Operation aus. Dieser Dienst läuft unter dem Benutzer `root` und ist daher zur Ein-/Ausbindung von Dateisystemen berechtigt. * Etliche Dateien zur Integration in das System, insbesondere auch für das Init-System [:systemd:]. * Einer Bibliothek (`libudisks2`) von Programmen, die vom Anwenderprogramm aus aufgerufen werden können und mit dem DAEMON kommunizieren. * Einem Dienstprogramm `udisksctl` für die Kommandozeile[2][3], welches als Client mit dem DAEMON kommuniziert und daher auch zur Ein-/Ausbindung von Dateisystemen von jedem Benutzer eingesetzt werden kann. UDisks verwendet die von [:udev:] gesammelten Inforationen über die Geräte und stellt seinerseits Funktionen bereit, die von höheren Schichten wie beispielsweise [:GVfs:] benutzt werden können; somit wird UDisks indirekt auch von vielen Desktop-Umgebungen benutzt. Der Systemdienst UDisks wird in der Regel vom Endanwender gar nicht wahrgenommen, solange es „einfach funktioniert“. Es gibt gelegentlich Berührungspunkte für den Benutzer bei der Autorisierung der Einbindungen eines Wechselmediums (z.B. USB-Sticks) durch normale Benutzer ohne Root-Rechte[4] oder Problemen mit den automatisch gesetzten Mount-Optionen. Viele Probleme kann der Endanwender selber mit dem [#Dienstprogramm-udisksctl Dienstprogramm udisksctl] umgehen; andere kann ein [:Administrator:] mit geringem Konfigurationsaufwand beseitigen. = Installation = Das Subsystem ist bei allen Ubuntu-Installationen standardmäßig installiert[1] und besteht mindestens aus den Paketen: {{{#!vorlage Paketinstallation udisks2, D-Bus service to access and manipulate storage devices (aus main) libudisks2-0, GObject-basierte Bibliothek für den Zugriff auf udisks2 (aus `main`) }}} Bei Bedarf können noch Zusätze für spezielle Speichergeräte hinzu installiert werden. Die verfügbaren Pakete hängen von der Ubuntu-Version ab und können so abgefragt werden: [[Vorlage(Befehl, "apt list '*udisks*'" ) ]] Dieser Artikel behandelt aber nur die hier namentlich genannten Pakete. Wer sich intensiver mit UDisks beschäftigen möchte, wird die zusätzliche Installation der Dokumentation empfohlen: {{{#!vorlage Paketinstallation udisks2-doc, udisks2 documentation, optional aus main }}} = Dokumentation = Die Dokumentation wird erreicht über die URL '''file:///usr/share/gtk-doc/html/udisks2/index.html''', sofern das Dokumentationspaket installiert wurde. Immer verfügbar sind [:Manpage:Manpages] zu `udisks`, `udisksd`, `udisksctl` und `udisks2.conf`: {{{#!vorlage Befehl man udisks man udisksd man udisksctl man udisks2.conf }}} = Funktionsweise = Die Einbindung eines Dateisystems erfordert immer Systemprivilegien. Der Dienst UDisks läuft als `root` und verfügt damit über die erforderlichen Privilegien, die er auch normalen Benutzern zu Verfügung stellt. Datei unterscheidet er über ein von ihm selbst ermitteltes Merkmal `HintSystem` zwischen Systemlaufwerken (`=1`) und sonstigen Laufwerken (`=0`). * Für Systemlaufwerke erfolgt bei der Benutzung von UDisks über ein grafisches Programm eine Autorisierung per [:PolicyKit:]: * Jeder Benutzer in der Gruppe `sudo` gilt bereits durch diese Mitgliedschaft als hinreichend vertrauenswürdig und darf daher ohne Passwortabfrage das Subsystem benutzen. * Andere Benutzer werden PolicyKit zur Eingabe des Passwortes eines [:Administrator:Administrators] (d.h. ein Mitglied in der Gruppe `sudo`) aufgefordert. * Vorstehendes Standardverhalten kann individuell abweichend konfiguriert werden. Siehe Beispiel [#Systemschutz Systemschutz]. * Für andere als Systemlaufwerke wird UDisks bei der Einbindung gar nicht sichtbar. Diese Regeln gelten auch für das Programm `udisksctl` auf einer Kommandozeile. Zusätzlich gilt hierbei auch der Benutzer `root` als hinreichend vertrauenswürdig. Ein Aufruf von `udisksctl` mit [:sudo:] ist niemals erforderlich. = Dienstprogramm udisksctl = Das Dienstprogramm für UDisks kennt etliche Befehle, von denen hier nur einige ausgewählte beschrieben werden: == help == Dieser Befehl zeigt eine Übersicht aller Befehle: [[Vorlage(Befehl, "udisksctl help" ) ]] Einen Kurzhilfe zu jedem Befehl (hier als Beispiel: `status`) erhält man mit der nachgestellten Option `--help`: [[Vorlage(Befehl, "udisksctl status --help" ) ]] == status == Eine Übersicht aller von UDisks betreuten Geräte (''drive'' im Sprachgebrauch von UDisks) erhält man so: [[Vorlage(Befehl, "udisksctl status" ) ]] Beispielausgabe: {{{ MODEL REVISION SERIAL DEVICE -------------------------------------------------------------------------- CT1000P3SSD8 P9CR30A 2249E11E7B96 nvme0n1 hp DVDRW GUD1N MD00 KZCH5Q81111 sr0 SanDisk Cruzer Blade 1.00 4C530000471212248165 sda }}} == info == Hiermit erhält man detailliertere Information zu einem per `status` angezeigten Gerät (Spalte DEVICE) oder einer Partition eines angezeigten Gerätes: [[Vorlage(Befehl, "udisksctl info --block-device /dev/sda" ) ]] Die Option `--block-device` kann zu `-b` abgekürzt werden. Ein mit `status` z.B. als `sda` angezeigtes Gerät muss bei `info` als `/dev/sda` angegeben werden. Man kann auch die Daten für eine Partition abfragen: [[Vorlage(Befehl, "udisksctl info -b /dev/sda1" ) ]] Als Alternative zur Option `--block-device` gibt es `--drive`; hier muss man die Identifizierung des Gerätes aus mehreren Angaben von `status` zusammenbauen. Das Dienstprogramm beherrscht aber die Befehlsvervollständigung über die Tabulatortaste beim Aufruf von [:Bash:] aus. == mount == Eine Partition (hier beispielhaft: `nvme0n1p7`) einbinden kann man als normaler Benutzer mit diesem Befehl: [[Vorlage(Befehl, "udisksctl mount --block-device /dev/nvme0n1p7" ) ]] Die automatische Erkennung des zu benutzenden Dateisystemtreibers funktioniert nicht immer zuverlässig. Beim Dateisystemtyp NTFS gibt es beispielsweise zwei Kernel Module `ntfs` und `ntfs3` und den [:FUSE:]-Treiber [:ntfs-3g:]. In solchen Situationen sollte man angeben, was man benutzen möchte, beispielsweise: [[Vorlage(Befehl, "udisksctl mount --block-device /dev/nvme0n1p7 -t ntfs3" ) ]] Die Kennung des Dateisystemstyps muss im System bekannt sein, sonst erhält man eine [#Fehlermeldung-Dateisystemtyp-unbekannt Fehlermeldung]. Das Ergebnis des Befehls kann man mit dem Befehl `findmnt` erfragen, der auch die aktiven Mount-Optionen anzeigt: [[Vorlage(Befehl, "findmnt -l | grep nvme0n1p7" ) ]] Zusätzlich kann man auch selbst Mount-Optionen angeben. Allerdings sind hier nur die für UDisks für den jeweiligen Dateisystemtreiber als erlaubt (`allow`) konfigurierten Optionen zulässig, siehe hierzu [#Konfiguration Konfiguration]. Beispiel: [[Vorlage(Befehl, "udisksctl mount --block-device /dev/nvme0n1p7 -t ntfs3 -o ro" ) ]] Hier wird die Partition schreibgeschützt eingebunden. Die Angabe des Dateisystemtreibers oder spezieller Mount-Optionen funktioniert so natürlich nur bei Verwendung von `udisksctl` auf einer Kommandozeile. Beim Aufruf entsprechender Funktionen von UDisks über GUI-Programme kann man so nicht vorgehen; vielmehr muss man entweder mit den eingebauten Optionen leben oder eine Konfiguration über die im Kapitel [#Konfiguration Konfiguration] angegebenen Methoden versuchen. == unmount == Ein Dateisystem aushängen geht einfach: [[Vorlage(Befehl, "udisksctl unmount --block-device /dev/nvme0n1p7" ) ]] Man muss allerdings darauf achten, die Quelle des eingehängten Dateisystems als Blockgerät anzugeben. Eine Angabe des Einhängepunktes, wie bei [:mount:] und [:mount/#umount:umount] möglich, funktioniert hier nicht. = Konfiguration = In der Regel benötigt UDisks keine Konfiguration durch den Anwender, eine solche ist aber durch die hier beschriebenen Methoden möglich. Es gibt drei wichtige Klassen von Aufgaben, in denen eine Konfiguration durch den Anwender doch sinnvoll ist: 1. [[Anker ( Aufgabe-Treiber ) ]]Man verwendet ein Dateisystem, für das Ubuntu mehrere mögliche Dateisystemtreiber kennt und man will sicherstellen, dass bei der Einbindung immer der durch den Anwender ausgewählte Treiber benutzt wird. Diese Situation trifft beispielsweise bei den Dateisystemen NTFS und [:exfat:] zu. 1. [[Anker ( Aufgabe-Option ) ]]Man möchte beim Einbinden bestimmte Mount-Optionen verwenden oder die in UDisks eingebauten Vorgaben übersteuern. Diese Situation ist beispielsweise beim NTFS-Dateisystem bzgl. der Option `windows_names` gegeben. 1. [[Anker ( Aufgabe-Darstellung ) ]]Nicht der Vorgang der Einbindung, sondern die Sichtbarkeit des jeweiligen Geräts in der Desktop-Umgebung oder die Bedienung soll beeinflusst werden; dies betrifft z.B. die Ein-/Ausblendung bestimmter Geräte, die Auswahl des das Gerät darstellende Icons, aber auch die Erfordernis einer Autorisierung durch eine Passwortabfrage. Die Möglichkeiten zur Konfiguration hängen von der Version von UDisks ab. Die Eingriffe können an mehreren Stellen im System erfolgen, deren Details und Reihenfolge in folgender Tabelle dargestellt sind. Die im eigenen System benutzte Version von UDisks lässt sich mit diesem Befehl ermitteln: [[Vorlage(Befehl,"udisksctl dump | grep -m1 Version" ) ]] {{{#!vorlage Warnung Die Vorgaben für die Mount-Optionen für den als `root` laufenden Dienst UDisks wurden von den Entwicklern sorgfältig gewählt, weil die Einbindung eines Dateisystems immer ein Risiko für die Sicherheit des Systems bedeutet. Eingriffe müssen daher immer besonders sorgfältig bedacht und vor der Freigabe nicht nur auf Funktionssicherheit, sondern auch ihre Systemsicherheit getestet werden! }}} {{{#!vorlage Tabelle <-6 tableclass="zebra_start3" rowclass="titel" :>Konfigurationsmöglichkeiten +++ Ebene <:>Stelle Version[[BR]]UDisks Version[[BR]]Ubuntu Beschreibung [#Konfiguration Aufgabe] +++ <:>[#Interne-Vorgaben I] intern festgelegt <-2:>alle Interne Vorgaben können nicht konfiguriert, aber durch folgende Ebenen überschrieben werden. Die Vorgaben können der Dokumentation von UDisks entnommen werden und entsprechen inhaltlich der unten gezeigten Beispieldatei für '''/etc/udisks2/mount_options.conf''', die aber selbst nicht als Datei existiert und auch erst ab Version 2.9.0 benutzt werden kann. +++ <|3:>[#Konfigurationsdatei II] <|3:>mount_options.conf vor 2.9.0 vor [:22.04:] Eine Datei '''/etc/udisks2/mount_options.conf''' wird bei Ubuntu [:20.04:] und allen weiteren Versionen vor 22.04 ignoriert. +++ ab 2.9.0 ab [:22.04:] Die Konfiguration erfolgt über eine selbst anzulegende Datei '''/etc/udisks2/mount_options.conf'''. Details siehe [#interne-Vorgaben Beispieldatei für die internen Vorgaben] und im Kapitel [#Beispiele Beispiele]. Die Schlüsselworte erlauben sowohl Angaben für alle als auch individuelle Angaben für spezifische Dateisystemtypen. [#Aufgabe-Option 2] +++ ab 2.10.0 ab [:23.10:] Die Syntax für Schlüsselworte wurde erweitert. Jetzt sind auch für Dateisystemtyp/Treiber spezifische Angaben möglich und man kann für alternative Treiber eine Rangfolge festlegen. [#Aufgabe-Option 2], [#Aufgabe-Treiber 1] +++ <|3:>[#Regeln-fuer-udev III] <|3:>[:udev:] Regeln <-2:>alle Es können Angaben zur Darstellung der Dateisysteme in der grafischen Oberfläche erfolgen. Zu Mount-Optionen siehe folgende Zeilen. [#Aufgabe-Darstellung 3] +++ ab 2.9.0 ab 22.04 Es sind zusätzlich Mount-Optionen angebbar, auch spezifisch für Dateisysteme. [#Aufgabe-Darstellung 3], [#Aufgabe-Option 2] +++ ab 2.10.0 ab [:23.10:] Es können auch Mount-Optionen spezifisch für Dateisystemtyp und -treiber angegeben werden. [#Aufgabe-Darstellung 3], [#Aufgabe-Option 2], [#Aufgabe-Treiber 1] +++ <:>[#Zeilen-in-fstab IV] <:>[:fstab:] <-2:>alle Konkrete Angaben in dieser Datei haben immer Vorrang vor Konfigurationen von UDisks. [#Aufgabe-Option 2], [#Aufgabe-Treiber 1] }}} Die Regeln für eine Ersetzung von Werten sind kompliziert, da man sowohl innerhalb einer Ebene als auch durch eine höhere Ebene die Einstellungen überschreiben kann: * Wenn für das einzubindende Blockgerät in der Datei '''/etc/fstab''' Angaben existieren, so werden diese für einen Einbindeversuch benutzt und die eigenen Konfigurationen werden vollständig ignoriert. * Die Werte für die internen Variablen `allow`, `defaults` und `drivers` werden werden für jeden einzelnen Einbindeversuch neu berechnet. * Generell können auf jeder Ebene ererbte Werte nur vollständig überschrieben, nicht selektiv gelöscht und nicht ergänzt werden. * Der Dateisystemtyp des einzubindenden Blockgerätes wird ermittelt und auf jeder Ebene wird der für diesen Dateisystemtyp geltende Liste für `drivers` gesucht. Auf Ebene I gilt die interne Liste, auf Ebene II ergibt sich die gesuchte Liste aus der Konfigurationsdatei oder wird aus Ebene I vererbt, auf Ebene III ist ebenfalls ein Einstellung oder eine Vererbung möglich. * Für jeden Wert aus der Liste für `drivers` wird später in der angegebenen Reihenfolge eine Einbindung versucht, nachdem für diese Situation die Werte der Variablen `allow` und `defaults` ermittelt wurden. * Für die Variablen `allow` und `defaults` werden die Werte zunächst auf jeder Ebene ermittelt, dann wird auf Ebene III geprüft, ob leere Werte durch Angaben von Ebene II oder I ersetzt werden können. Bei den vorläufigen Berechnungen der Variablen haben Werte aus für das Blockgerät spezifischen Abschnitt (sofern ein solcher existiert) vor dem allgemeinen Abschnitt `[defaults]` bevorzugt. Generell werden die allgemeinen, für alle Dateisystemtypen gültigen Mount-Optionen und die für den jeweiligen Dateisystemtreiber spezifischen Mount-Optionen separat betrachtet und erst im endgültigen Ergebnis vereinigt. Danach werden die per Kommandozeile übergebenen Mount-Optionen noch zu `defaults` hinzugefügt. * Es wird geprüft, ob jede im endgültigen Ergebnis für `defaults` enthaltene Mount-Option auch im endgültigen Ergebnis für `allow` enthalten ist. Wenn dies nicht zutrifft, scheitert der Einbindeversuch und es wird mit dem nächsten Wert aus der Liste für `drivers` fortgesetzt. * Der Wert für `defaults` wird noch um die Optionen `nosuid,nodev,uhelper=udisks2` ergänzt. Mit den neuen Optionen wird eine Einbindung versucht. Wenn diese gelingt, endet der Aufruf erfolgreich, sonst wird mit dem nächsten Wert aus der Liste für `drivers` fortgesetzt. * Wenn die Liste für `drivers` vollständig ohne Erfolg abgearbeitet wurde, scheitert der Einbindeprozess mit einer Fehlermeldung. == Interne Vorgaben == Diese Vorgaben auf Ebene I sind fest in den Programmcode eingearbeitet und können selbst nicht verändert werden. Ihre Werte entsprechen denjenigen, als wäre auf Ebene II die unten angegebene Beispieldatei wirksam. [[Anker( interne-Vorgaben ) ]] === Beispieldatei === Diese Beispieldatei für '''/etc/udisks2/mount_options.conf''' aus der [#Links offiziellen Dokumentation] zeigt die internen Vorgaben ab UDisks Version 2.10.0, welche auch als Kommentare in der Datei '''/etc/udisks2/mount_options.conf.example''' stehen.. {{{ [defaults] allow=exec,noexec,nodev,nosuid,atime,noatime,nodiratime,relatime,strictatime,lazytime,ro,rw,sync,dirsync,noload,acl,nosymfollow vfat_defaults=uid=$UID,gid=$GID,shortname=mixed,utf8=1,showexec,flush vfat_allow=uid=$UID,gid=$GID,flush,utf8,shortname,umask,dmask,fmask,codepage,iocharset,usefree,showexec # common options for both the native kernel driver and exfat-fuse exfat_defaults=uid=$UID,gid=$GID,iocharset=utf8,errors=remount-ro exfat_allow=uid=$UID,gid=$GID,dmask,errors,fmask,iocharset,namecase,umask # 'ntfs' signature, definitions for the legacy ntfs kernel driver and the ntfs-3g fuse driver ntfs:ntfs_defaults=uid=$UID,gid=$GID,windows_names ntfs:ntfs_allow=uid=$UID,gid=$GID,umask,dmask,fmask,locale,norecover,ignore_case,windows_names,compression,nocompression,big_writes # 'ntfs' signature, the new 'ntfs3' kernel driver ntfs:ntfs3_defaults=uid=$UID,gid=$GID ntfs:ntfs3_allow=uid=$UID,gid=$GID,umask,dmask,fmask,iocharset,discard,nodiscard,sparse,nosparse,hidden,nohidden,sys_immutable,nosys_immutable,showmeta,noshowmeta,prealloc,noprealloc,hide_dot_files,nohide_dot_files,windows_names,nocase,case # define order of filesystem driver priorities for the actual mount call, # required definition for non-matching driver names ntfs_drivers=ntfs3,ntfs iso9660_defaults=uid=$UID,gid=$GID,iocharset=utf8,mode=0400,dmode=0500 iso9660_allow=uid=$UID,gid=$GID,norock,nojoliet,iocharset,mode,dmode udf_defaults=uid=$UID,gid=$GID,iocharset=utf8 udf_allow=uid=$UID,gid=$GID,iocharset,utf8,umask,mode,dmode,unhide,undelete hfsplus_defaults=uid=$UID,gid=$GID,nls=utf8 hfsplus_allow=uid=$UID,gid=$GID,creator,type,umask,session,part,decompose,nodecompose,force,nls btrfs_allow=compress,compress-force,datacow,nodatacow,datasum,nodatasum,autodefrag,noautodefrag,degraded,device,discard,nodiscard,subvol,subvolid,space_cache f2fs_allow=discard,nodiscard,compress_algorithm,compress_log_size,compress_extension,alloc_mode xfs_allow=discard,nodiscard,inode32,largeio,wsync reiserfs_allow=hashed_relocation,no_unhashed_relocation,noborder,notail ext2_defaults=errors=remount-ro ext2_allow=errors=remount-ro ext3_defaults=errors=remount-ro ext3_allow=errors=remount-ro ext4_defaults=errors=remount-ro ext4_allow=errors=remount-ro }}} === Interne Vorgaben bei Version 2.9.x === Entsprechen im wesentlichen den oben gezeigten für 2.10.0, lediglich bzgl. NTFS gibt es Abweichungen: * Die Schlüssel `ntfs:ntfs_defaults,ntfs:ntfs_allow, ntfs:ntfs3_defaults, ntfs:ntfs3_allow` und `ntfs_drivers` sind so noch nicht möglich. Man hat nur: \\ {{{ ntfs_defaults=uid=$UID,gid=$GID,windows_names ntfs_allow=uid=$UID,gid=$GID,umask,dmask,fmask,locale,norecover,ignore_case,windows_names,compression,nocompression,big_writes }}} === Interne Vorgaben vor Version 2.9.0 === Entsprechen wahrscheinlich denen für Version 2.9.0. Die Mount-Option `windows_names` bei `ntfs_defaults` wurde mit Version 2.8.2 eingeführt. == Konfigurationsdatei == Auf Ebene II erfolgt die Konfiguration durch eine optionale [wikipedia:Initialisierungsdatei:INI-Datei] '''/etc/udisks2/mount_options.conf'''. In dieser Datei muss es einen Abschnitt mit dem Titel `[defaults]` geben; in diesem stehen Angaben, die für jedes von UDisks betreute Gerät gelten. Zusätzlich kann es noch weitere Abschnitte geben, die individuell nur für ein benanntes Blockgerät gelten. Diese Methode spielt in der Praxis keine Rolle, denn wenn man das Dateisystem (durch [:Labels:Label], [:UUID:] etc.) benennen kann, ist es viel einfacher, die Konfiguration in der Datei [:fstab:] vorzunehmen. In jedem Abschnitt kann man die Schlüsselworte `allow` und `defaults` sowie ab Version 2.10.0 `drivers` verwenden: * Mit `allow` legt man fest, welche Mount-Optionen grundsätzlich mittels UDisks benutzt werden dürfen. * Mit `defaults` definiert man, welche Mount-Optionen bei der Einbindung benutzt werden. Man kann diese Liste beim Aufruf noch ergänzen, aber per `defaults` aktivierte Optionen lassen sich nicht beim Aufruf deaktivieren. Ein Ausnahme davon ist eine Angabe in der Datei `fstab`, die immer Vorrang vor `defaults` hat. Allerdings gelten auch in diesem Modus die Einschränkungen von `allow`. * Mit `drivers` gibt man eine Liste vor, welche(n) alternativen Treiber für einen Dateisystemtyp verwendet werden soll. Wenn man diese Schlüsselworte alleinstehend verwendet, gelten ihre Werte für alle Dateisystemtypen und alle Dateisystemtreiber. Man kann sie aber auch durch vorangestellte Angaben spezifisch für einen Dateisystemtyp und ab 2.10.0 für einen Dateisystemtyp und -treiber verwenden. Beispielsweise gelten für ein NTFS-Dateisystem alle diese Zeilen aus obiger Beispieldatei: {{{ [defaults] allow=exec,noexec,nodev,nosuid,atime,noatime,nodiratime,relatime,strictatime,lazytime,ro,rw,sync,dirsync,noload,acl,nosymfollow ntfs:ntfs_defaults=uid=$UID,gid=$GID,windows_names ntfs:ntfs_allow=uid=$UID,gid=$GID,umask,dmask,fmask,locale,norecover,ignore_case,windows_names,compression,nocompression,big_writes ntfs:ntfs3_defaults=uid=$UID,gid=$GID ntfs:ntfs3_allow=uid=$UID,gid=$GID,umask,dmask,fmask,iocharset,discard,nodiscard,sparse,nosparse,hidden,nohidden,sys_immutable,nosys_immutable,showmeta,noshowmeta,prealloc,noprealloc,hide_dot_files,nohide_dot_files,windows_names,nocase,case ntfs_drivers=ntfs3,ntfs }}} * Für den Kernel-Modul `ntfs3` werden die Zeile `allow=…` und die die Zeile `ntfs:ntfs3_allow=…` vereinigt. * Für den Kernel-Modul `ntfs` und den [:FUSE:]-Treiber [:NTFS-3g:`ntfs-3g`] (der ebenfalls für sich die Kennung `ntfs` okkupiert) gelten die Zeile `allow=…` und die Zeile `ntfs:ntfs_allow=…`. Generell gilt für die verwendbaren Schlüssel die Syntax: * ab 2.10.0: {{{[[DATEISYSTEMTYP[:DATEISYSTEMTREIBER]_]allow [[DATEISYSTEMTYP[:DATEISYSTEMTREIBER]_]defaults [[DATEISYSTEMTYP_]driver }}} * vorher: {{{[[DATEISYSTEMTYP_]allow [[DATEISYSTEMTYP_]defaults }}} Wer eine eigene Konfigurationsdatei verwenden möchte, kann (und soll nach Vorschlag der Entwickler) die Beispieldatei vom eigenen Rechner kopieren[4] und alle für das eigene Problem nicht relevanten Zeilen aus der Kopie löschen. Man sollte zur eigenen Erleichterung und Dokumentation die überlagerten Vorgaben als Kommentar behalten. Eine eigene Konfigurationsdatei muss auf ihre richtige Funktion __und__ möglicherweise durch sie entstehende Sicherheitslücken getestet werden! == Regeln für udev == Auf Ebene III kann zusätzlich zu den bisher besprochenen Konfigurationsaufgaben auch noch die [#Aufgabe-Darstellung Darstellung] des Blockgerätes in der grafischen Oberfläche konfiguriert werden. Für alle Aufgaben muss eine Konfigurationsdatei mit Regeln für [:udev:] erstellt werden. Empfohlen wird als Ordner '''/etc/udev/rules.d/''' und ein Dateiname mit dem Namensmuster '''99-*.rules'''. Die Datei muss [:root:] gehören und darf nur von diesem beschreibbar sein. Nach der Selektion des jeweiligen Blockgerätes in der Regel erfolgt die Konfiguration durch Setzen der jeweils zuständigen [:Umgebungsvariable:] auf den gewünschten Wert. Die folgende Tabelle listet auszugsweise die Namen der Umgebungsvariablen. {{{#!vorlage Tabelle <-6 tableclass="zebra_start3" rowclass="titel" :>Variablen für Udev-Regeln +++ Ebene II[[BR]]Schlüssel Ebene III[[BR]]Variable Beschreibung [#Konfiguration Aufgabe] +++ drivers UDISKS_MOUNT_OPTIONS_XYZ_DRIVERS Statt `XYZ` ist die Kennung des Dateisystemtyps einzutragen, z.B. `NTFS`. <:>[#Aufgabe-Treiber 1] +++ defaults UDISKS_MOUNT_OPTIONS_DEFAULTS <|3:>[#Aufgabe-Option 2] +++ allow UDISKS_MOUNT_OPTIONS_ALLOW +++ xyz UDISKS_MOUNT_OPTIONS_XYZ Generelle Regel: Ein im der Konfigurationsdatei zulässiger Schlüssel (kleingeschrieben) entspricht einer solchen Umgebungsvariablen mit dem angehängten Schlüssel in Großbuchstaben. Dabei bleibt ein Doppelpunkt ein Doppelpunkt und ein Unterstrich ein Unterstrich. +++ UDISKS_SYSTEM Sinnvolle Werte sind `1` oder `0`. Diese geben an, ob das Blockgerät als Systemlaufwerk (=1) gelten soll oder nicht (=0). Systemlaufwerke können nur von Benutzern aus der Gruppe `sudo` und `root` ein- und ausgebunden werden. <|8:>[#Aufgabe-Darstellung 3] +++ UDISKS_IGNORE Sinnvolle Werte sind `1` oder `0` und überschreiben die Eigenschaft `HintIgnore`. Ein verstecktes (=1) Blockgerät wird in der grafischen Oberfläche nicht dargestellt. +++ UDISKS_AUTO Sinnvolle Werte sind `1` oder `0` und überschreiben die Eigenschaft `HintAuto`. Ein Blockgerät mit dieser Eigenschaft (=1) wird automatisch eingebunden. +++ UDISKS_CAN_POWER_OFF Überschreibt den Wert der Eigenschaft `CanPowerOff`. Einschalten dieser Eigenschaft, wenn die Hardware es nicht auch tatsächlich unterstützt, kann unerwünschte Effekte zeigen! +++ UDISKS_NAME Mit dieser Zeichenkette wird das Blockgerät in der grafischen Oberfläche benannt. (Eigenschaft `HintName`) +++ UDISKS_ICON_NAME Mit diesem Icon wird das Blockgerät in der grafischen Oberfläche dargestellt. Der Name muss zu einem Icon-Thema entsprechend der [#Links Spezifikation von freedesktop.org] gehören. (Eigenschaft `HintIconName`) +++ UDISKS_SYMBOLIC_ICON_NAME Mit diesem Icon wird das Blockgerät in der grafischen Oberfläche dargestellt, wenn symbolische Namen verwendet werden. Der Name muss zu einem Icon-Thema entsprechend der [#Links Spezifikation von freedesktop.org] gehören. (Eigenschaft `HintSymbolicIconName`) +++ UDISKS_FILESYSTEM_SHARED Sinnvolle Werte sind `1` oder `0`. Diese geben an, ob das Blockgerät in einem für alle Benutzer (=1) benutzbaren Ordner (z.B. /media/VolumeName) oder in einem für einen einzelnen Benutzer (=0) privaten Ordner (z.B /run/media/$USER/VolumeName) eingebunden wird. }}} == Zeilen in fstab == Zeilen in der Datei [:fstab:] werden sowohl von [:mount:] wie auch von UDisks interpretiert. Die Ergebnisse einer per `mount` auf der Kommandozeile ausgelösten Einbindung, eines Aufrufs von [#mount udisksctl] und eine Bedienung in der GUI können sich aber unterscheiden. Beispiel: * Zeile in der Datei `fstab`: {{{/dev/nvme0n1p7 /media/NTFS-Test ntfs3 noauto,rw,umask=0,users 0 0 }}} * Ergebnis bei der Benutzung von `mount`: \\ {{{#!vorlage Befehl $ mount -v /dev/nvme0n1p7 mount: /dev/nvme0n1p7 ist auf /media/NTFS-Test eingehängt. $ findmnt -t ntfs,ntfs3,exfat,vfat,msdos,fuseblk TARGET SOURCE FSTYPE OPTIONS /media/NTFS-Test /dev/nvme0n1p7 ntfs3 rw,nosuid,nodev,noexec,relatime,uid=1000,gid=1000,fmask=37777600000,dmask=37777600000,iocharset=utf8 }}} * Ergebnis bei der Benutzung von `udisksctl` oder Bedienung in der GUI: \\ {{{#!vorlage Befehl $ udisksctl mount --block-device /dev/nvme0n1p7 Mounted /dev/nvme0n1p7 at /media/NTFS-Test. $ findmnt -t ntfs,ntfs3,exfat,vfat,msdos,fuseblk TARGET SOURCE FSTYPE OPTIONS /media/NTFS-Test /dev/nvme0n1p7 ntfs3 rw,nosuid,nodev,noexec,relatime,uid=0,gid=0,fmask=37777600000,dmask=37777600000,iocharset=utf }}} = Beispiele = == Laufwerke verstecken == Das geht nur mit einer Regel für [:udev:]: {{{# /etc/udev/rules.d/98-udisks.hide.rules SUBSYSTEM != "block", GOTO = "udisks-hide-end" ENV{ID_FS_LABEL} == "Ventoy|VTOYEFI", GOTO = "udisks-hide-ignore" LABEL = "udisks-hide-normal", GOTO = "udisks-hide-end" LABEL = "udisks-hide-ignore" ENV{UDISKS_IGNORE} = "1" ENV{UDISKS_AUTO} = "0" LABEL = "udisks-hide-end" }}} Die gezeigten Werte für die beiden Variablen verhindern eine Darstellung und eine automatische Einbindung von Dateisystemen mit den genannten [:Labels:Labeln], welche natürlich an die eigenen Verhältnisse anzupassen sind. == Systemschutz == Nach gleicher Vorgehensweise kann man auch über die Variable `UDISKS_SYSTEM` kontrollieren, wer bestimmte Dateisysteme ein- und ausbinden darf. Hierzu kann man eine Regel für udev nach folgender Art verwenden: {{{ # /etc/udev/rules.d/98-udisks-system-device.rules # UU 2024-03-16 # HintSystem == 1: Einbindung erfordert zusätzliche Autorisierung, # root und Mitglieder der Gruppe sudo haben diese bereits, # bei anderen erfolgt Passwortabfrage # HintSystem == 0 : Einbindung uneingeschränkt möglich, erfolgt aber nicht automatisch SUBSYSTEM != "block", GOTO = "udisks-system-device-end" ENV{ID_FS_USAGE} != "filesystem", GOTO = "udisks-system-device-end" # Auswahl der Dateisysteme ENV{ID_FS_UUID} == "1f2b7733-9ac3-465e-a47f-6f16bb10a4d8", GOTO = "set-HintSystem" ENV{ID_FS_LABEL} == "Windows_UU-Test", GOTO = "clr-HintSystem" ENV{ID_FS_TYPE} == "ntfs*", GOTO = "set-HintSystem" # Ende Auswahl der Dateisysteme GOTO = "udisks-system-device-end" LABEL = "clr-HintSystem", ENV{UDISKS_SYSTEM} = "0" ENV{UDISKS_AUTO} = "0" GOTO = "udisks-system-device-end" LABEL = "set-HintSystem", ENV{UDISKS_SYSTEM} = "1" LABEL = "udisks-system-device-end" }}} Diese Datei ist bzgl. der Dateisystemauswahl auf die eigenen Bedürfnisse anzupassen. Im Beispiel können alle NTFS-Dateisysteme und ein über seine [:UUID:] identifiziertes Dateisystem nur durch Benutzer in der Gruppe `sudo` oder `root` eingebunden werden, während ein über sein [:Labels:Label] benanntes Dateisystem von jedem eingebunden werden kann. == Schreibschutz == * entweder Konfigurationsdatei: \\ {{{ [defaults] defaults=ro }}} * oder Regel für udev: \\ {{{# /etc/udev/rules.d/99-udisks-ro.rules SUBSYSTEM == "block", ENV{UDISKS_MOUNT_OPTIONS_DEFAULTS} = "ro" }}} Das funktioniert erst ab Ubuntu 22.04 mit UDisks-Version ab 2.9.0 und schließt alle in [:fstab:] genannten Dateisysteme aus, d.h. diese werden mit den dort genannten Mount-Optionen eingebunden. == Selektiver Schreibschutz == Das funktioniert genauso wie [#Schreibschutz vorstehend] beschrieben, man muss nur in der Regel für `udev` zusätzliche Bedingungen berücksichtigen. Beispielsweise kann man für alle mit NTFS formatierten USB-Sticks einen Schreibschutz so realisieren: {{{# /etc/udev/rules.d/99-udisks-ro-selected.rules SUBSYSTEM == "block", SUBSYSTEMS == "usb", ENV{ID_FS_TYPE} == "ntfs*", ENV{UDISKS_MOUNT_OPTIONS_DEFAULTS} = "ro" }}} == Optionen für NTFS == Die von UDisks bei NTFS standardmäßig benutzte Option `windows_names` ist manchmal nachteilig oder auch nur unerwünscht. Um sie auszuschalten, muss man neue Optionslisten implementieren: * entweder Konfigurationsdatei: \\ {{{ [defaults] ntfs_defaults=uid=$UID,gid=$GID }}} * oder Regel für udev: \\ {{{# /etc/udev/rules.d/99-udisks-ntfs.rules SUBSYSTEM == "block", ENV{ID_FS_TYPE} == "ntfs*", ENV{UDISKS_MOUNT_OPTIONS_NTFS_DEFAULTS} = "uid=$UID,gid=$GID" }}} = Problembehebung = == Option windows_names == Das [:FUSE:]-Modul [:NTFS-3G:ntfs-3g] und das Kernel-Modul [:NTFS3:ntfs3] kennen die Option `windows_names`, allerdings erst seit Version 2010.8.8 bei `ntfs-3g` bzw. ab Kernel 6.2 (Feb 2023) bei `ntfs3`. UDisks hat diese Option ab Version 2.8.2 im März 2019 als Vorgabe bei NTFS übernommen, um für Endbenutzer die Interoperabilität zwischen Windows und Linux zu verbessern. Ubuntu ist seit Version 20.04 (oder 19.10?) von dieser Änderung betroffen, die zu Problemen führen kann: * Wenn die Einbindung per `ntfs-3g` scheitert, erfolgt normalerweise ein Rückfall auf das Kernel Modul `ntfs`. Dieses scheitert aber auch, weil es die Option `windows_names` gar nicht kennt und zeigt seine allgemeine Fehlermeldung: \\ {{{Falscher Dateisystemtyp, ungültige Optionen, der Superblock von /dev/nvme0n1p7 ist beschädigt, fehlende Kodierungsseite oder ein anderer Fehler. }}} (Hier trifft die zweite Möglichkeit zu.) * Da das seit Kernel Version 5.15 verfügbare `ntfs3` erst seit Kernel Version 6.2 diese Option kennt, kann bei manchen Systemen mit Ubuntu 20.04 oder 22.04 LTS die Einbindung per `ntfs3` wie bei `ntfs` scheitern, oder die Option wird bei aktuellen Patchleveln stillschweigend ignoriert. * Wenn die Einbindung gelingt, können trotzdem manche Anwendungsprogramme scheitern, weil sie eben einen nicht Windows-konformen Dateinamen verwenden wollen. * Nicht alle Linux-Anwender schätzen eine Bevormundung und den Zwang, unter Windows übliche Arbeitsweisen anwenden zu müssen. Von einem der obigen Problemen betroffene Anwender von Ubuntu 22.04 oder neuer können die Vorgaben für UDisks andern, wie oben in [#Optionen-fuer-NTFS Beispiel] beschrieben. Alternativ kann man bei allen Versionen von Ubuntu für bekannte NTFS-Dateisysteme Zeilen in der Datei [:fstab:] ohne die problematische Option vorbereiten. == Treiber bevorzugen oder sperren == Beim Dateisystemtyp NTFS gibt es mit `ntfs3` und [:ntfs-3g:] zwei leistungsfähige Treiber zur Auswahl, die sich in Implementierung, Optionen und in den für den Anwender benutzbaren Funktionalität erheblich unterscheiden. Für einen möglichst störungsfreien Betrieb sollte man sich einen (1) für die eigenen Bedürfnisse geeigneten Treiber aussuchen und konsequent nur diesen verwenden. Ab Ubuntu [:23.10:] kann man mit UDisks-Version 2.10.0 diese Strategie automatisieren; indem man in der [#Konfigurationsdatei Konfigurationsdatei] die Variable `ntfs_drivers` zweckmäßig setzt: {{{[defaults] #ntfs_drivers=ntfs3 ntfs_drivers=ntfs-3g }}} Vorstehende Datei erlaubt `ntfs-3g` und sperrt `ntfs3` für UDisks. Für die andere Wahl entferne man die Raute # vor der ersten Zuweisung und setze sie auf die letzten Zeile. Bei Ubuntu 22.04 und früheren Versionen funktioniert das vorstehende Verfahren nicht. Man kann bei allen Ubuntu-Versionen konkrete Angaben in der Datei [:fstab:] hinterlegen oder die Methoden aus den Artikeln [:ntfs-3g:] bzw. `ntfs3` verwenden. == Fehler durch Mount-Option user == Die Mount-Optionen `user` und `users` gehören standardmäßig nicht zu den per `allow` erlaubten Optionen und sind somit beim Aufruf über die Kommandozeile verboten. Eine Änderung dieses Verhaltens durch Konfiguration ist zwar möglich, wird aber als nicht zielführend ausdrücklich widerraten. UDisks selber benötigt diese Optionen nicht und wertet sie nicht aus. Technisch sind diese Optionen nur in der Datei `fstab` sinnvoll und UDisks erlaubt sie auch so selbst ohne Änderung seiner Konfiguration. Die Optionen sind nur für den Befehl `mount` relevant und von diesem aufgerufene Treiber sollten sie ignorieren; bei `ntfs-3g` wurden jedoch Fehlfunktionen beobachtet. Für Abhilfe lies den Artikel über [:Windows-Partitionen_einbinden/NTFS-3G:ntfs-3g]. Alternativ kann man auch einfach auf die Angabe dieser Optionen verzichten, da UDisks selber sie nicht benötigt und ab Ubuntu 22.04 auch das Programm [:mount:] beim Aufruf durch normale Benutzer eine solche Option bei [:FUSE:]-Programmen nicht mehr benötigt. == Fehlermeldung: Zugriff auf Ort nicht möglich == Bei manchen Versionen von UDisks erhält man beim Versuch einer Einbindung eine ähnliche Fehlermeldung wie diese: {{{#!vorlage Befehl udisksctl mount --block-device /dev/nvme0n1p7 }}} {{{Error mounting /dev/nvme0n1p7: GDBus.Error:org.freedesktop.UDisks2.Error.Failed: Error mounting /dev/nvme0n1p7 at … : Filesystem type ntfs3 not configured in kernel. }}} Diese kann auch beim Versuch einer Einbindung über die grafische Oberfläche auftreten. Ursache ist, dass der benötigte Modul (im Beispiel: `ntfs3`) noch nicht geladen wurde und auch nicht automatisch geladen werden kann. Vielleicht steht er in einer Sperrliste (blacklist) für [:Kernelmodule/#Module-laden-entladen-modprobe:modprobe]. Als Soforthilfe kann man den benötigten Modul manuell laden: [[Vorlage(Befehl,"sudo modprobe -v ntfs3" ) ]] Danach sollte der Einbindeversuch gelingen oder jedenfalls nicht mehr aus diesem Grund scheitern. Als systematische Lösung kann man den benötigten Modul beim Rechnerstart automatisch laden lassen. Dazu muss [:root:] lediglich dessen Namen in die Datei '''/etc/modules''' eintragen und ggf. aus einer Sperrliste (blacklist) im Ordner '''/etc/modprobe.d/''' entfernen. == Fehlermeldung: Dateisystemtyp unbekannt == Man kann über die Option `-t` nur dem System bekannte Dateisystemtypen angeben oder erhält eine Fehlermeldung wie im folgendem Beispiel: [[Vorlage(Befehl, "udisksctl mount --block-device /dev/ntfs/Musiksammlung -t ntfs-3g" ) ]] {{{Error mounting /dev/sda7: GDBus.Error:org.freedesktop.UDisks2.Error.OptionNotPermitted: Requested filesystem type `ntfs-3g' is neither well-known nor in /proc/filesystems nor in /etc/filesystems }}} In diesem Fall kann ein [:Administrator:] leicht abhelfen durch Anlegen einer Datei '''/etc/filesystems''': {{{# /etc/filesystems ntfs-3g * }}} Die Datei sollte mit einem einsamen Stern `*` auf der letzten Zeile enden, damit nach dieser Datei noch die Datei '''/proc/filesystems''' mit den geladenen Modulen durchsucht wird. Natürlich muss unabhängig von dieser Datei die jeweilige Software installiert sein. = Links = * [:DeviceKit:] * [http://storaged.org/doc/udisks2-api/ UDisks Reference Manual] {en} -- (Diese Seite leitet nach wenigen Sekunden weiter auf die Dokumentation der letzten Version. Wer die Dokumentation einer bestimmten Version lesen möchte, muss schnell genug auf die angezeigte Versionsnummer klicken.) * [https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html Icon Naming Specification] {en} #tag: System, Desktop,