summaryrefslogtreecommitdiff
path: root/fatfs/fat.c
diff options
context:
space:
mode:
Diffstat (limited to 'fatfs/fat.c')
-rw-r--r--fatfs/fat.c744
1 files changed, 744 insertions, 0 deletions
diff --git a/fatfs/fat.c b/fatfs/fat.c
new file mode 100644
index 00000000..4d3ba3da
--- /dev/null
+++ b/fatfs/fat.c
@@ -0,0 +1,744 @@
+/* fat.c - Support for FAT filesystems.
+ Copyright (C) 2002 Free Software Foundation, Inc.
+ Written by Marcus Brinkmann.
+
+ This file is part of the GNU Hurd.
+
+ The GNU Hurd is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ The GNU Hurd is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. */
+
+#include <string.h>
+#include <error.h>
+#include <limits.h>
+#include <errno.h>
+#include <assert.h>
+#include <ctype.h>
+#include <time.h>
+
+#include <hurd/store.h>
+#include <hurd/diskfs.h>
+
+#include "fatfs.h"
+
+/* Unprocessed superblock. */
+struct boot_sector *sblock;
+
+/* Processed sblock info. */
+fat_t fat_type;
+size_t bytes_per_sector;
+size_t log2_bytes_per_sector;
+size_t sectors_per_cluster;
+size_t bytes_per_cluster;
+unsigned int log2_bytes_per_cluster;
+size_t sectors_per_fat;
+size_t total_sectors;
+size_t nr_of_root_dir_sectors;
+size_t first_root_dir_byte;
+size_t first_data_sector;
+vm_offset_t first_data_byte;
+size_t first_fat_sector;
+cluster_t nr_of_clusters;
+
+/* Hold this lock while converting times using gmtime. */
+spin_lock_t epoch_to_time_lock = SPIN_LOCK_INITIALIZER;
+
+/* Hold this lock while allocating a new cluster in the FAT. */
+spin_lock_t allocate_free_cluster_lock = SPIN_LOCK_INITIALIZER;
+
+/* Where to look for the next free cluster. This is meant to avoid
+ searching through a nearly full file system from the beginning at
+ every request. It would be better to use the field of the same
+ name in the fs_info block. 2 is the first data cluster in any
+ FAT. */
+cluster_t next_free_cluster = 2;
+
+
+/* Read the superblock. */
+void
+fat_read_sblock (void)
+{
+ int read;
+
+ sblock = malloc (sizeof (struct boot_sector));
+ store_read (store, 0, sizeof (struct boot_sector), (void **) &sblock, &read);
+
+ if (read_word(sblock->id) != BOOT_SECTOR_ID)
+ error (1, 0, "Could not find valid superblock");
+
+ /* Parse some important bits of the superblock. */
+
+ bytes_per_sector = read_word (sblock->bytes_per_sector);
+ switch (bytes_per_sector)
+ {
+ case 512:
+ log2_bytes_per_sector = 9;
+ break;
+
+ case 1024:
+ log2_bytes_per_sector = 10;
+ break;
+
+ case 2048:
+ log2_bytes_per_sector = 11;
+ break;
+
+ case 4096:
+ log2_bytes_per_sector = 12;
+ break;
+
+ default:
+ error (1, 0, "Invalid number of bytes per sector");
+ };
+
+ sectors_per_cluster = sblock->sectors_per_cluster;
+ if (sectors_per_cluster != 1 && sectors_per_cluster != 2
+ && sectors_per_cluster != 4 && sectors_per_cluster != 8
+ && sectors_per_cluster != 16 && sectors_per_cluster != 32
+ && sectors_per_cluster != 64 && sectors_per_cluster != 128)
+ error (1, 0, "Invalid number of sectors per cluster");
+
+ bytes_per_cluster = sectors_per_cluster << log2_bytes_per_sector;
+ switch (bytes_per_cluster)
+ {
+ case 512:
+ log2_bytes_per_cluster = 9;
+ break;
+
+ case 1024:
+ log2_bytes_per_cluster = 10;
+ break;
+
+ case 2048:
+ log2_bytes_per_cluster = 11;
+ break;
+
+ case 4096:
+ log2_bytes_per_cluster = 12;
+ break;
+
+ case 8192:
+ log2_bytes_per_cluster = 13;
+ break;
+
+ case 16384:
+ log2_bytes_per_cluster = 14;
+ break;
+
+ case 32768:
+ log2_bytes_per_cluster = 15;
+ break;
+
+ default:
+ error (1, 0, "Invalid number of bytes per cluster");
+ };
+
+ total_sectors = read_word (sblock->total_sectors_16)
+ ?: read_word (sblock->total_sectors_32);
+ if (total_sectors * bytes_per_sector > store->size)
+ error (1, 0, "Store is smaller then implied by metadata");
+ if (total_sectors == 0)
+ error (1, 0, "Number of total sectors is zero");
+
+ if (bytes_per_sector & (store->block_size - 1))
+ error (1, 0, "Block size of filesystem is not a multiple of the block size "
+ "of the store");
+
+ if (read_word (sblock->reserved_sectors) == 0)
+ error (1, 0, "Number of reserved sectors is zero");
+ if (sblock->nr_of_fat_tables == 0)
+ error (1, 0, "Number of FATs is zero");
+
+ sectors_per_fat = read_word (sblock->sectors_per_fat_16)
+ ?: read_word (sblock->compat.fat32.sectors_per_fat_32);
+ if (sectors_per_fat == 0)
+ error (1, 0, "Number of sectors per fat is zero");
+
+ nr_of_root_dir_sectors = ((read_word (sblock->nr_of_root_dirents) * FAT_DIR_REC_LEN)
+ - 1) / bytes_per_sector + 1;
+ if (nr_of_root_dir_sectors & (sectors_per_cluster - 1))
+ error (1, 0, "Number of root dir sectors is not a multiple of sectors_per_cluster");
+
+ first_root_dir_byte = (read_word (sblock->reserved_sectors)
+ + (sblock->nr_of_fat_tables * sectors_per_fat)) << log2_bytes_per_sector;
+ first_data_sector = (first_root_dir_byte >> log2_bytes_per_sector) + nr_of_root_dir_sectors;
+ first_data_byte = first_data_sector << log2_bytes_per_sector;
+
+ nr_of_clusters = (total_sectors - first_data_sector) / sectors_per_cluster;
+
+ if (nr_of_clusters < FAT12_MAX_NR_OF_CLUSTERS)
+ fat_type = FAT12;
+ else
+ {
+ if (nr_of_clusters < FAT16_MAX_NR_OF_CLUSTERS)
+ fat_type = FAT16;
+ else
+ fat_type = FAT32;
+ }
+
+ if (fat_type == FAT32 && read_word (sblock->compat.fat32.fs_version) != 0)
+ error (1, 0, "Incompatible file system version");
+
+ first_fat_sector = 0;
+ if (fat_type == FAT32 && read_word (sblock->compat.fat32.extension_flags) & 1<<7)
+ {
+ first_fat_sector = (read_word (sblock->compat.fat32.extension_flags) & 0x0f);
+ if (first_fat_sector > sblock->nr_of_fat_tables)
+ error (1, 0, "Active FAT table does not exist");
+ first_fat_sector *= sectors_per_fat;
+ }
+ first_fat_sector += read_word (sblock->reserved_sectors);
+}
+
+
+/* Write NEXT_CLUSTER in the FAT at position CLUSTER.
+ You must call this from inside diskfs_catch_exception.
+ Returns 0 (always succeeds). */
+error_t
+fat_write_next_cluster(cluster_t cluster, cluster_t next_cluster)
+{
+ loff_t fat_entry_offset;
+ cluster_t data;
+
+ /* First data cluster is cluster 2. */
+ assert (cluster >= 2 && cluster < nr_of_clusters + 2);
+
+ switch (fat_type)
+ {
+ case FAT12:
+ if (next_cluster == FAT_BAD_CLUSTER)
+ next_cluster = FAT12_BAD_CLUSTER;
+ else if (next_cluster == FAT_EOC)
+ next_cluster = FAT12_EOC;
+
+ fat_entry_offset = (cluster * 3) / 2;
+ data = read_word (fat_image + fat_entry_offset);
+ if (cluster & 1)
+ data = (data & 0xf) | ((next_cluster & 0xfff) << 4);
+ else
+ data = (data & 0xf000) | (next_cluster & 0xfff);
+
+ write_word (fat_image + fat_entry_offset, data);
+ break;
+
+ case FAT16:
+ if (next_cluster == FAT_BAD_CLUSTER)
+ next_cluster = FAT16_BAD_CLUSTER;
+ else if (next_cluster == FAT_EOC)
+ next_cluster = FAT16_EOC;
+
+ fat_entry_offset = cluster * 2;
+ write_word (fat_image + fat_entry_offset, next_cluster);
+ break;
+
+ case FAT32:
+ default: /* To silence gcc warning. */
+ if (next_cluster == FAT_BAD_CLUSTER)
+ next_cluster = FAT32_BAD_CLUSTER;
+ else if (next_cluster == FAT_EOC)
+ next_cluster = FAT32_EOC;
+
+ fat_entry_offset = cluster * 4;
+ write_dword (fat_image + fat_entry_offset, next_cluster & 0x0fffffff);
+ }
+
+ return 0;
+}
+
+/* Read the FAT entry at position CLUSTER into NEXT_CLUSTER.
+ You must call this from inside diskfs_catch_exception.
+ Returns 0 (always succeeds). */
+error_t
+fat_get_next_cluster(cluster_t cluster, cluster_t *next_cluster)
+{
+ loff_t fat_entry_offset;
+
+ /* First data cluster is cluster 2. */
+ assert (cluster >= 2 && cluster < nr_of_clusters + 2);
+
+ switch (fat_type)
+ {
+ case FAT12:
+ fat_entry_offset = (cluster * 3) / 2;
+ *next_cluster = read_word (fat_image + fat_entry_offset);
+ if (cluster & 1)
+ *next_cluster = *next_cluster >> 4;
+ else
+ *next_cluster &= 0xfff;
+
+ if (*next_cluster == FAT12_BAD_CLUSTER)
+ *next_cluster = FAT_BAD_CLUSTER;
+ else if (*next_cluster >= FAT12_EOC)
+ *next_cluster = FAT_EOC;
+ break;
+
+ case FAT16:
+ fat_entry_offset = cluster * 2;
+ *next_cluster = read_word (fat_image + fat_entry_offset);
+ if (*next_cluster == FAT16_BAD_CLUSTER)
+ *next_cluster = FAT_BAD_CLUSTER;
+ else if (*next_cluster >= FAT16_EOC)
+ *next_cluster = FAT_EOC;
+ break;
+
+ case FAT32:
+ default: /* To silence gcc warning. */
+ fat_entry_offset = cluster * 4;
+ *next_cluster = read_dword (fat_image + fat_entry_offset);
+ *next_cluster &= 0x0fffffff;
+ if (*next_cluster == FAT32_BAD_CLUSTER)
+ *next_cluster = FAT_BAD_CLUSTER;
+ else if (*next_cluster >= FAT32_EOC)
+ *next_cluster = FAT_EOC;
+ }
+
+ return 0;
+}
+
+/* Allocate a new cluster, write CONTENT into the FAT at this new
+ clusters position. At success, 0 is returned and CLUSTER contains
+ the cluster number allocated. Otherwise, ENOSPC is returned if the
+ filesystem is full.
+ You must call this from inside diskfs_catch_exception. */
+error_t
+fat_allocate_cluster (cluster_t content, cluster_t *cluster)
+{
+ error_t err = 0;
+ cluster_t old_next_free_cluster;
+ int wrapped = 0;
+ cluster_t found_cluster = FAT_FREE_CLUSTER;
+
+ assert (content != FAT_FREE_CLUSTER);
+
+ spin_lock (&allocate_free_cluster_lock);
+ old_next_free_cluster = next_free_cluster;
+
+ /* Loop over all clusters, starting from next_free_cluster and
+ wrapping if reaching the end of the FAT, until we either find an
+ unallocated cluster, or we have to give up because all clusters
+ are allocated. */
+ do
+ {
+ cluster_t next_free_content;
+
+ fat_get_next_cluster (next_free_cluster, &next_free_content);
+
+ if (next_free_content == FAT_FREE_CLUSTER)
+ found_cluster = next_free_cluster;
+
+ if (++next_free_cluster == nr_of_clusters + 2)
+ {
+ next_free_cluster = 2;
+ wrapped = 1;
+ }
+ }
+ while (found_cluster == FAT_FREE_CLUSTER
+ && !(wrapped && next_free_cluster == old_next_free_cluster));
+
+ if (found_cluster != FAT_FREE_CLUSTER)
+ {
+ *cluster = found_cluster;
+ fat_write_next_cluster(found_cluster, content);
+ }
+ else
+ err = ENOSPC;
+
+ spin_unlock(&allocate_free_cluster_lock);
+ return err;
+}
+
+/* Extend the cluster chain to maximum size or new_last_cluster,
+ whatever is less. If we reach the end of the file, and CREATE is
+ true, allocate new blocks until there is either no space on the
+ device or new_last_cluster are allocated. (new_last_cluster: 0 is
+ the first cluster of the file). */
+error_t
+fat_extend_chain (struct node *node, cluster_t new_last_cluster, int create)
+{
+ error_t err = 0;
+ struct disknode *dn = node->dn;
+ struct cluster_chain *table;
+ int offs;
+ cluster_t left, prev_cluster, cluster;
+
+ error_t allocate_new_table(struct cluster_chain **table)
+ {
+ struct cluster_chain *t;
+
+ t = *table;
+ *table = malloc (sizeof (struct cluster_chain));
+ if (!*table)
+ return ENOMEM;
+ (*table)->next = 0;
+ if (t)
+ dn->last = t->next = *table;
+ else
+ dn->last = dn->first = *table;
+ return 0;
+ }
+
+ spin_lock(&dn->chain_extension_lock);
+
+ /* If we already have what we need, or we have all clusters that are
+ available without allocating new ones, go out. */
+ if (new_last_cluster < dn->length_of_chain
+ || (!create && dn->chain_complete))
+ return 0;
+
+ left = new_last_cluster + 1 - dn->length_of_chain;
+
+ table = dn->last;
+ if (table)
+ {
+ offs = (dn->length_of_chain - 1) & (CLUSTERS_PER_TABLE - 1);
+ prev_cluster = table->cluster[offs];
+ }
+ else
+ {
+ offs = CLUSTERS_PER_TABLE - 1;
+ prev_cluster = FAT_FREE_CLUSTER;
+ }
+
+ while (left)
+ {
+ if (dn->chain_complete)
+ {
+ err = fat_allocate_cluster(FAT_EOC, &cluster);
+ if (err)
+ break;
+ if (prev_cluster)
+ fat_write_next_cluster(prev_cluster, cluster);
+ else
+ /* XXX: Also write this to dirent structure! */
+ dn->start_cluster = cluster;
+ }
+ else
+ {
+ if (prev_cluster != FAT_FREE_CLUSTER)
+ err = fat_get_next_cluster(prev_cluster, &cluster);
+ else
+ cluster = dn->start_cluster;
+ if (cluster == FAT_EOC || cluster == FAT_FREE_CLUSTER)
+ {
+ dn->chain_complete = 1;
+ if (create)
+ continue;
+ else
+ break;
+ }
+ }
+ prev_cluster = cluster;
+ offs++;
+ if (offs == CLUSTERS_PER_TABLE)
+ {
+ offs = 0;
+ err = allocate_new_table(&table);
+ if (err)
+ break;
+ }
+ table->cluster[offs] = cluster;
+ dn->length_of_chain++;
+ left--;
+ }
+
+ if (dn->length_of_chain << log2_bytes_per_cluster > node->allocsize)
+ node->allocsize = dn->length_of_chain << log2_bytes_per_cluster;
+
+ spin_unlock(&dn->chain_extension_lock);
+ return err;
+}
+
+/* Returns in DISK_CLUSTER the disk cluster corresponding to cluster
+ CLUSTER in NODE. If there is no such cluster yet, but CREATE is
+ true, then it is created, otherwise EINVAL is returned. */
+error_t
+fat_getcluster (struct node *node, cluster_t cluster, int create,
+ cluster_t *disk_cluster)
+{
+ error_t err = 0;
+ cluster_t chains_to_go = cluster >> LOG2_CLUSTERS_PER_TABLE;
+ cluster_t offs = cluster & (CLUSTERS_PER_TABLE - 1);
+ struct cluster_chain *chain;
+
+ if (cluster >= node->dn->length_of_chain)
+ {
+ err = fat_extend_chain (node, cluster, create);
+ if (err)
+ return err;
+ if (cluster >= node->dn->length_of_chain)
+ {
+ assert (!create);
+ return EINVAL;
+ }
+ }
+ chain = node->dn->first;
+ while (chains_to_go--)
+ {
+ assert (chain);
+ chain = chain->next;
+ }
+ assert (chain);
+ *disk_cluster = chain->cluster[offs];
+ return 0;
+}
+
+void
+fat_truncate_node (struct node *node, cluster_t clusters_to_keep)
+{
+ struct cluster_chain *next;
+ cluster_t count;
+ cluster_t offs;
+ cluster_t pos;
+
+ /* The root dir of a FAT12/16 fs is of fixed size, while the root
+ dir of a FAT32 fs must never decease to exist. */
+ assert (! (((fat_type == FAT12 || fat_type == FAT16) && node == diskfs_root_node)
+ || (fat_type == FAT32 && node == diskfs_root_node && clusters_to_keep == 0)));
+
+ /* Expand the cluster chain, because we have to know the complete tail. */
+ fat_extend_chain (node, FAT_EOC, 0);
+ if (clusters_to_keep == node->dn->length_of_chain)
+ return;
+ assert (clusters_to_keep < node->dn->length_of_chain);
+
+ /* Truncation happens here. */
+ next = node->dn->first;
+ if (clusters_to_keep == 0)
+ {
+ /* Deallocate the complete file. */
+ node->dn->start_cluster = 0;
+ pos = count = offs = 0;
+ }
+ else
+ {
+ count = (clusters_to_keep - 1) >> LOG2_CLUSTERS_PER_TABLE;
+ offs = (clusters_to_keep - 1) & (CLUSTERS_PER_TABLE - 1);
+ while (count-- > 0)
+ {
+ assert (next);
+ next = next->next;
+ }
+ assert (next);
+ fat_write_next_cluster (next->cluster[offs++], FAT_EOC);
+ pos = clusters_to_keep;
+ }
+
+ /* Purge dangling clusters. If we die here, scandisk will have to
+ clean up the remains. */
+ while (pos < node->dn->length_of_chain)
+ {
+ if (offs == CLUSTERS_PER_TABLE)
+ {
+ offs = 0;
+ next = next->next;
+ assert(next);
+ }
+ fat_write_next_cluster(next->cluster[offs++], 0);
+ pos++;
+ }
+
+ /* Free now unused tables. (Could be done in one run with the above.) */
+ next = node->dn->first;
+ if (clusters_to_keep != 0)
+ {
+ count = (clusters_to_keep - 1) >> LOG2_CLUSTERS_PER_TABLE;
+ offs = (clusters_to_keep - 1) & (CLUSTERS_PER_TABLE - 1);
+ while (count-- > 0)
+ {
+ assert (next);
+ next = next->next;
+ }
+ assert (next);
+ next = next->next;
+ }
+ while (next)
+ {
+ struct cluster_chain *next_next = next->next;
+ free (next);
+ next = next_next;
+ }
+}
+
+
+/* Count the number of free clusters in the FAT. */
+int
+fat_get_freespace (void)
+{
+ int free_clusters = 0;
+ cluster_t curr_cluster;
+ cluster_t next_cluster;
+ error_t err;
+
+ err = diskfs_catch_exception ();
+ if (!err)
+ {
+ /* First cluster is the 3rd entry in the FAT table. */
+ for (curr_cluster = 2; curr_cluster < nr_of_clusters + 2;
+ curr_cluster++)
+ {
+ fat_get_next_cluster (curr_cluster, &next_cluster);
+ if (next_cluster == FAT_FREE_CLUSTER)
+ free_clusters++;
+ }
+ }
+ diskfs_end_catch_exception ();
+
+ return free_clusters;
+}
+
+
+/* FILE must be a buffer with 13 characters. */
+void fat_to_unix_filename(const char *name, char *file)
+{
+ int npos;
+ int fpos = 0;
+ int ext = 0;
+
+ for (npos = 0; npos < 11; npos++)
+ {
+ if (name[npos] == ' ')
+ {
+ if (ext)
+ {
+ break;
+ }
+ else
+ {
+ file[fpos] = '.';
+ fpos++;
+ ext = 1;
+ while (npos < 7 && name[npos+1] == ' ') npos++;
+ }
+ }
+ else
+ {
+ file[fpos] = name[npos];
+ fpos++;
+ if (npos == 7)
+ {
+ file[fpos] = '.';
+ fpos++;
+ ext = 1;
+ }
+ }
+ }
+ if (ext && file[fpos-1] == '.')
+ file[fpos-1] = '\0';
+ else
+ file[fpos] = '\0';
+}
+
+void
+fat_from_unix_filename(char *fn, const char *un, int ul)
+{
+ int fp = 0;
+ int up = 0;
+ int ext = 0;
+
+ while (fp < 11)
+ {
+ if (up == ul)
+ {
+ /* We parsed the complete unix filename. */
+ while (fp < 11)
+ fn[fp++] = ' ';
+ }
+ else
+ {
+ if (!ext)
+ {
+ if (un[up] == '.')
+ {
+ while (fp < 8)
+ fn[fp++] = ' ';
+ ext = 1;
+ un++;
+ }
+ else if (fp == 8)
+ {
+ while (un[up++] != '.' && up < ul);
+ ext = 1;
+ }
+ else
+ fn[fp++] = toupper(un[ul++]);
+ }
+ else
+ {
+ if (un[up] == '.')
+ {
+ while (fp < 11)
+ fn[fp++] = ' ';
+ }
+ else
+ fn[fp++] = toupper(un[up++]);
+ }
+ }
+ }
+}
+
+
+/* Return Epoch-based time from a MSDOS time/date pair. */
+void
+fat_to_epoch (char *date, char *time, struct timespec *ts)
+{
+ struct tm tm;
+
+ /* Date format:
+ Bits 0-4: Day of month (1-31).
+ Bits 5-8: Month of year (1-12).
+ Bits 9-15: Count of years from 1980 (0-127).
+
+ Time format:
+ Bits 0-4: 2-second count (0-29).
+ Bits 5-10: Minutes (0-59).
+ Bits 11-15: Hours (0-23).
+ */
+
+ tm.tm_year = (read_word (date) >> 9) + 80;
+ tm.tm_mon = ((read_word (date) & 0x1ff) >> 5) - 1;
+ tm.tm_mday = read_word (date) & 0x1f;
+ tm.tm_hour = (read_word (time) >> 11);
+ tm.tm_min = (read_word (time) & 0x7ff) >> 5;
+ tm.tm_sec = read_word (time) & 0x1f;
+ tm.tm_isdst = 0;
+
+ ts->tv_sec = timegm (&tm);
+ ts->tv_nsec = 0;
+}
+
+/* Return MSDOS time/date pair from Epoch-based time. */
+void
+fat_from_epoch (char *date, char *time, time_t *tp)
+{
+ struct tm *tm;
+
+ spin_lock(&epoch_to_time_lock);
+ tm = gmtime (tp);
+
+ /* Date format:
+ Bits 0-4: Day of month (1-31).
+ Bits 5-8: Month of year (1-12).
+ Bits 9-15: Count of years from 1980 (0-127).
+
+ Time format:
+ Bits 0-4: 2-second count (0-29).
+ Bits 5-10: Minutes (0-59).
+ Bits 11-15: Hours (0-23).
+ */
+
+ write_word(date, tm->tm_mday | ((tm->tm_mon + 1) << 5)
+ | ((tm->tm_year - 80) << 9));
+ write_word(time, (tm->tm_hour << 11) | (tm->tm_min << 5)
+ | (tm->tm_sec >> 1));
+ spin_unlock(&epoch_to_time_lock);
+}