FAT

This page is a translated version of the page FAT and the translation is 46% complete.

Outdated translations are marked like this.

Other languages:

Resources

Il File Allocation Table (FAT) - filesystem originalmente creato per l'uso con MS-DOS (e successivamente Microsoft Windows pre-NT). Attualmente una revisione successiva di FAT (FAT32) viene utilizzata per chiavette USB. ^[1] Esso è entrato a far parte dei sistemi Linux ed ha supporto ufficiale nel kernel Linux.

Anche se FAT32 è carente delle molte caratteristiche dei filesystem moderni, lo si può comunque trovare nei computer moderni, ad esempio quando si usa una Partizione di sistema EFI. Nel 2006 Microsoft ha sviluppato una nuova versione di FAT (exFAT) che non è retrocompatibile con le versioni precedenti. Vedi l'articolo exFAT per ulteriori informazioni.

Installazione

Kernel

KERNEL Abilitare supporto FAT (CONFIG_VFAT_FS)

File systems  --->
   DOS/FAT/NT Filesystems  --->
      < > MSDOS fs support
      <*> VFAT (Windows-95) fs support
      (437) Default codepage for FAT
      (iso8859-1) Default iocharset for FAT
      [ ]   Enable FAT UTF-8 option by default
   -*- Native language support  --->
      (iso8859-1) Default NLS Option
      <*>   Codepage 437 (United States, Canada)
      <*>   NLS ISO 8859-1  (Latin 1; Western European Languages)
      -*-   NLS UTF-8

Snippet

FILE /etc/kernel/config.d/esp-linux6-1-111.config

CONFIG_FAT_FS=y
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_FAT_DEFAULT_CODEPAGE=437
CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"

Quando si pianifica di mountare partizioni FAT, gli utenti potrebbero dover specificare un'opzione codepage= per mount. Nell'esempio soprastante la codepage per Stati Uniti e Canada è in uso, tuttavia altre possono essere abilitate se necessario. Opzionalmente, gli utenti possono impostare una codepage predefinita per FAT nella configurazione del kernel. Siate sicuri che ogni valore per le codepage da usare sia stato abilitato nel kernel

Nota
Usando l'opzione codepage via mount non si considererà opzione usata nel kernel.

Evitate di impostare code>Default iocharset for fat a UTF-8; non è consigliato. Invece, passate l'opzione utf8=true quando si mounta partizioni FAT (questo richiede l'abilitazione nel kernel di CONFIG_NLS_UTF8). Per ulteriori informazioni vedere la pagina di manuale mount(8) o l'appropriata documentazione del kernel a /usr/src/linux/Documentation/filesystems/vfat.rst

Emerge

Il pacchetto sys-fs/dosfstools per strumenti FAT nello spazio utente:

root #emerge --ask sys-fs/dosfstools

Utilizzo

Formattazione

Per creare un filesystem FAT, usare mkfs.fat:

user $mkfs.fat

mkfs.fat 4.2 (2021-01-31)
No device specified.
Usage: mkfs.fat [OPTIONS] TARGET [BLOCKS]
Create FAT filesystem in TARGET, which can be a block device or file. Use only
up to BLOCKS 1024 byte blocks if specified. With the -C option, file TARGET will be
created with a size of 1024 bytes times BLOCKS, which must be specified.
 
Options:
  -a              Disable alignment of data structures
  -A              Toggle Atari variant of the filesystem
  -b SECTOR       Select SECTOR as location of the FAT32 backup boot sector
  -c              Check device for bad blocks before creating the filesystem
  -C              Create file TARGET then create filesystem in it
  -D NUMBER       Write BIOS drive number NUMBER to boot sector
  -f COUNT        Create COUNT file allocation tables
  -F SIZE         Select FAT size SIZE (12, 16 or 32)
  -g GEOM         Select disk geometry: heads/sectors_per_track
  -h NUMBER       Write hidden sectors NUMBER to boot sector
  -i VOLID        Set volume ID to VOLID (a 32 bit hexadecimal number)
  -I              Ignore and disable safety checks
  -l FILENAME     Read bad blocks list from FILENAME
  -m FILENAME     Replace default error message in boot block with contents of FILENAME
  -M TYPE         Set media type in boot sector to TYPE
  --mbr[=y|n|a]   Fill (fake) MBR table with one partition which spans whole disk
  -n LABEL        Set volume name to LABEL (up to 11 characters long)
  --codepage=N    use DOS codepage N to encode label (default: 850)
  -r COUNT        Make room for at least COUNT entries in the root directory
  -R COUNT        Set minimal number of reserved sectors to COUNT
  -s COUNT        Set number of sectors per cluster to COUNT
  -S SIZE         Select a sector size of SIZE (a power of two, at least 512)
  -v              Verbose execution
  --variant=TYPE  Select variant TYPE of filesystem (standard or Atari)
  --invariant     Use constants for randomly generated or time based values
  --offset=SECTOR Write the filesystem at a specific sector into the device file.
  --help          Show this help message and exit

Per formattare la partizione /dev/sdx9 con filesystem FAT32 ed etichetta "ESP" ed uscita verbosa.

root #mkfs.fat -v -F 32 -n "ESP" /dev/sdx9

Dovrebbe essere possibile montare filesystem FAT con il comando mount. Ridimensionare sarebbe fattibile con sys-fs/fatresize.

Case sensitivity

In the original FAT file system only short filenames (8.3 or SFN) are possible, and they are being stored in all upper case only. The systems using the original FAT file system were not case-sensitive (like MS-DOS). As extension to FAT, VFAT not only allows long filenames (LFN) but also lower case letters in filenames. VFAT is case-preserving, but for compatibility reasons existing operating systems (such as Microsoft Windows 95 and Windows NT) were still treating filenames case-insensitive. On the other hand, Unix traditionally was strictly case-sensitive.

In Linux vfat defaults to treating names case-insensitive (mount option check=r for relaxed). VFAT can, however, also be mounted with strict case-checking, mount option check=s, but this can cause problems.

Manual mount options

Attenzione
Using anything other than the default options will cause problems! You have been warned! See section Problem cases for details.

For short names of directories and files (8.3, i.e. "short filenames" or SFN) the behavior of how the name is stored in the filesystem and how it is displayed can be changed using mount option shortname, which defaults to mixed since Linux kernel 2.6.32 (December 2009).^[2]

file system	mount option	display short name	short name example	store long name	long name example
FAT12 FAT16 FAT32 VFAT			`FILENAME.EXT`		–
	`shortname=lower`	always forced to lower case	`filename.ext`	when the short name is not all upper case	–
	`shortname=win95`	upper case	`FILENAME.EXT`	when the short name is not all upper case	–
	`shortname=winnt`	as is (original)	`FILENAME.EXT`	when the short name is not all lower case or all upper case	–
	`shortname=mixed`	as is (original)	`FILENAME.EXT`	when the short name is not all upper case	–
VFAT			`FILENA~1.EXT`		`FileName.Ext`
	`shortname=lower`	always forced to lower case	–	when the short name is not all upper case	`FileName.Ext`
	`shortname=win95`	upper case	–	when the short name is not all upper case	`FileName.Ext`
	`shortname=winnt`	as is (original)	–	when the short name is not all lower case or all upper case	`FileName.Ext`
	`shortname=mixed`	as is (original)	–	when the short name is not all upper case	`FileName.Ext`
VFAT			`LONGNA~1.EXT`		`long name.ext`
	`shortname=lower`	always forced to lower case	–	when the short name is not all upper case	`long name.ext`
	`shortname=win95`	upper case	–	when the short name is not all upper case	`long name.ext`
	`shortname=winnt`	as is (original)	–	when the short name is not all lower case or all upper case	`long name.ext`
	`shortname=mixed`	as is (original)	–	when the short name is not all upper case	`long name.ext`

A special case is an all lower case short filename, e.g. filename.ext. If it is created with shortname=winnt, no LFN VFAT entry will be created.

file system	mount option	store long name	long name example	display short name	short name example
VFAT			`filename.ext`	→	`FILENAME.EXT`
	`shortname=winnt`	when the short name is not all lower case or all upper case	–	as is (short name)	`FILENAME.EXT`
	`shortname=lower`	–	–	always forced to lower case	`filename.ext`
	`shortname=win95`	–	–	upper case	`FILENAME.EXT`
	`shortname=mixed`	–	–	as is	`FILENAME.EXT`

If the file is created with shortname=lower|win95|mixed however, there will be a VFAT entry (LFN) and a short filename as well, e.g. FILENA~2.EXT. Whenever there is an LFN, VFAT will display the LFN, not the SFN. This is particularly tricky since the LFN entry might look like an 8.3 SFN, as in the example filename.ext.

file system	mount option	long name example	display short name	short name example
VFAT		`filename.ext`		`FILENA~2.EXT`
	`shortname=lower`	`filename.ext`	lower case	–
	`shortname=win95`	`filename.ext`	upper case	–
	`shortname=winnt`	`filename.ext`	as is	–
	`shortname=mixed`	`filename.ext`	as is	~

Problem cases

With the default settings existing file systems will just work.^[3] Firstly, VFAT currently defaults to relaxed case-checking (mount option check=r). This means that names for directories and files below the mount point will always work as long as they otherwise match in any possible combination of upper and lower case spelling, e.g. filename.ext will be found even when e.g. FILENAME.EXT or FileName.Ext is actually present, because the difference is only in case.

And secondly, short names (8.3, SFN) that are not all upper case will get an additional long filename entry to store the case correctly i.e. making VFAT case-preserving (mount option shortname=mixed).

Importante
On platforms with UEFI this is especially important for compatibility with existing directories and files on the EFI System Partition (ESP), which is vital for the boot configuration. Systems using FAT and VFAT traditionally haven't been case-sensitive, hence it is to be expected that existing directories and filenames differ slightly in their use of upper and lower case letters. With the default settings for vfat, Linux is adapting to this convention and treats the whole mount point case-insensitive as well, i.e. /efi/EFI/boot/bootx64.efi (assuming the ESP is mounted under /efi) and other EFI bootloader paths will always work as expected.

If only Linux is installed and all file references remain exactly the same, everything should also work with strict case-checking (mount option check=s). However, since the VFAT file system stores two filenames in some but not all cases, one short (8.3, SFN) and one long name (LFN), conventions regarding the management of those names can cause additional problems. The obvious example is the use of shortname=winnt, which will convert a short filename in all lower case to a standard FAT filename in all upper case, and skip creating an LFN counterpart. For example, the filename bootx64.efi would be stored as traditional 8.3 short filename (SFN) BOOTX64.EFI only. Additionally, shortname=winnt will display short filenames as is, so the originally written bootx64.efi doesn't exist, and together with strict case-checking this will cause big problems under Linux.

Risoluzione dei problemi

Bassa velocità di trasferimento dei file

Se la velocità di trasferimento dei file è bassa (visibile con iotop), assicurarsi che il filesystem sia montato con l'opzione async. Modificare i file di sistema /etc/fstab (o /etc/autofs/auto.misc quando si usa autofs) come richiesto, possibilmente rimuovendo l'opzione sync. DI predefinito, i filesystem vengono montati con l'opzione async.

Nota
L'opzione di filesystem sync diminuisce la velocità di trasferimento rispetto ad async. L'opzione sync inoltre può ridurre l'aspettativa di vita delle memorie volatili! Vedi la spiegazione dell'opzione sync man mount.

Se velocità di trasferimento sono comunque basse, provare a rimontare il filesystem con l'opzione flush:

root #mount -o remount,flush /path/to/mountpoint

Filesystem compatibili con altri sistemi operativi

Prova il filesystem UDF usando UDFTools, richiedente sys-fs/udftools e relativo driver del kernel di Linux. Di recente codice è stato aggiunto ad mkudffs per correggere la creazione di partizioni false aumentando la compatibilità con sistemi operativi Microsoft. Se si usa un kernel di Linux più datato, assicurarsi che la grandezza di blocco sia impostata a 512 per maggiore compatibilità, eccetto per il richiesto --bootarea=mbr creando la falsa partizione.

root #mkudffs --bootarea=mbr --label=tua_etichetta /dev/device_file

Prova il filesystem F2FS di Samsung.

Errori hardware riguardanti caratteri UTF-8/UTF-16

A volte errori riguardanti il firmware dell'hardware possono capitare su sistemi integrati (ad esempio radio d'auto) quando leggono filesystem FAT/FAT32 contenenti caratteri UTF-8. Una soluzione è l'assicurarsi di montare il filesystem FAT usando le (ora predefinite) opzioni codepage=437,iocharset=iso8859-1,shortname=mixed,errors=remount-ro.

Per nomi di documenti brevi, codepage=437 sono i caratteri IBM-PC, in pratica ASCII. Per nomi lunghi iocharset=iso8859-1 specifica ASCII. L'opzione shortname=mixed è predefinita, e si può provare ancheshortname=win95. Dei quali, sono tutti ora predefiniti. Inoltre, per porre rimedio ai caratteri UTF-8/UTF-16 incompatibili, usare un loop con sed per sostituirli con altri caratteri ASCII. (Vedi questo script replace_chars.sh.)

Per riferimento, questo errore fu riscontrato in una radio per auto Sony. Il modello MEX-GS610BT si resetterebbe nel tentativo di lettura di una chiavetta USB contenente caratteri UTF-8/UTF-16.

Come prima detto, vedi /usr/src/linux/Documentation/filesystems/vfat.txt, la documentazione vfat per il codice sorgente del kernel di Linux, per ulteriori spiegazioni su quando usare le opzioni di montaggio codepage, iocharset od utf8.

Documenti e cartelle disordinati

Quando si scrive su filesystem FAT/FAT32, i dispositivi utilizzati nella lettura potrebbero mostrare cartelle e documenti in modo disordinato. Solitamente, l'utente li vedrebbe in ordine alfabetico. Installare sys-fs/fatsort, ed eseguire il seguente comando:

root #fatsort /dev/device_file

Vedi anche

ExFAT — a Microsoft file system optimized for flash memory storage
ext4 — un open source filesystem e la versione più recente della serie estesa di filesystem.
btrfs — un filesystem CoW (copy-on-write, copia-in-scrittura) adatto a Linux che mira ad implementare funzionalità avanzate, concentrandosi sulla tolleranza agli errori, la riparazione e la facilità di amministrazione.
removable media — any media that is easily removed from a system.
/etc/fstab — un file di configurazione che è usato per configurare come e dove i filesystem devono essere montati, specialmente durante il boot., a configuration file that defines how and where the main filesystems are to be mounted, especially at boot time.

Risorse esterne

/usr/src/linux/Documentation/filesystems/vfat.txt - Documentazione sul filesystem VFAT incluso con le sorgenti del kernel Linux.
FAT filesystem e Linux - da Wikipedia

Referimenti

[1] ttps://it.wikipedia.org/wiki/File_Allocation_Table

[2] FreeDesktop.org Bug 24129: please mount vfat disks with shortname=mixed

[3] ttps://www.kernel.org/doc/html/v6.0/filesystems/vfat.html

[1]

[2]

[3]