From kevin at tyndur.org Tue Sep 7 21:34:12 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Tue, 7 Sep 2010 21:34:12 +0200 Subject: [cdi-devel] [PATCH] doc: Add text to doxygen main page Message-ID: <1283888052-1793-1-git-send-email-kevin@tyndur.org> If we want to point people at the CDI documentation, we should have some helpful content on the main page. This is a beginning, with a short introduction to CDI, and some links to the most important doxygen pages as well as to the git repo, mailing list and IRC. I already used this patch for generating new documentation, you can take a look at the usual URL (http://lpt.tyndur.org/cdi/english) Signed-off-by: Kevin Wolf --- doc/doc.h | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 71 insertions(+), 0 deletions(-) diff --git a/doc/doc.h b/doc/doc.h index 94c4ccc..24a2198 100644 --- a/doc/doc.h +++ b/doc/doc.h @@ -1,6 +1,77 @@ /** * \mainpage + * \german + * Die CDI-Dokumentation ist auch auf englisch verf??gbar.
+ * The CDI documentation is also available in English. + * + * \section main_introduction Einf??hrung + * Das Common Driver Interface (oder kurz CDI) ist ein Standardinterface, + * das es erm??glicht, betriebssystemunabh??ngige Treiber zu schreiben. + * + * Dies funktioniert mithilfe einer Bibliothek, die die Br??cke zwischen + * Treiber und Betriebssystem bildet. CDI definiert die Datenstrukturen und + * Funktionsprotoypen dieser Bibliothek, w??hrend ihre Implementierung + * OS-spezifisch ist. CDI-komforme Treiber k??nnen ohne ??nderungen gegen diese + * Bibliothek gebaut werden und stehen damit jedem Betriebssystem zur + * Verf??gung, das CDI implementiert. + * + * Die folgenden Seiten seien zum Einstieg in die technischen Details + * empfohlen: * - \ref general_interface + * - \ref core "Das Modul Core" + * + * \section main_resources Ressourcen + * Der Quellcode der Treiber und die Headerdatei des Interfaces k??nnen aus dem + * git-Repository heruntergeladen werden: + * - http://git.tyndur.org/?p=cdi.git;a=tree + * - git://git.tyndur.org/cdi.git + * + * F??r CDI existiert eine Mailingliste, auf der die Weiterentwicklung + * diskutiert wird. Patches k??nnen ebenfalls an diese Mailingliste gesendet + * werden. F??r die Mailingliste bitte bevorzugt Englisch verwenden. + * - cdi-devel at tyndur.org + * - http://list.tyndur.org/cgi-bin/mailman/listinfo/cdi-devel + * + * Auch im IRC sind CDI-Entwickler und -Benutzer vertreten: + * - \#tyndur auf irc.euirc.net + * \endgerman + * \english + * Die CDI-Dokumentation ist auch auf deutsch verf??gbar.
+ * The CDI documentation is also available in German. + * + * \section main_introduction Introduction + * The Common Driver Interface (or CDI) is a standard interface that allows to + * write OS independent drivers. + * + * To achieve this it employs a library that works as a bridge between + * drivers and the OS. CDI defines things like data structures and function + * prototypes of this library, whereas its implementation is OS specific. + * Drivers conforming to the CDI can be built against this library without any + * changes, so they can be used in any operating system implementing CDI. + * + * The following pages are recommended for an introduction into the technical + * details: + * - \ref general_interface + * - \ref core "The module Core" + * + * \section main_resources Resources + * The source code of drivers and the header files of the interface can be + * downloaded from the git repository: + * - http://git.tyndur.org/?p=cdi.git;a=tree + * - git://git.tyndur.org/cdi.git + * + * For CDI there is a mailing list on which the further development is + * discussed. It's also the right place to send patches to. + * - cdi-devel at tyndur.org + * - http://list.tyndur.org/cgi-bin/mailman/listinfo/cdi-devel + * + * You'll also find CDI developers and users on IRC: + * - \#tyndur on irc.euirc.net + * \endenglish */ /** -- 1.6.0.2 From redelman at gmail.com Tue Sep 7 23:17:00 2010 From: redelman at gmail.com (Rich Edelman) Date: Tue, 7 Sep 2010 16:17:00 -0500 Subject: [cdi-devel] [PATCH] doc: Add text to doxygen main page In-Reply-To: <1283888052-1793-1-git-send-email-kevin@tyndur.org> References: <1283888052-1793-1-git-send-email-kevin@tyndur.org> Message-ID: Looks good to me. Acked-by: Rich Edelman On Tue, Sep 7, 2010 at 2:34 PM, Kevin Wolf wrote: > If we want to point people at the CDI documentation, we should have some > helpful content on the main page. This is a beginning, with a short > introduction to CDI, and some links to the most important doxygen pages > as well as to the git repo, mailing list and IRC. > > I already used this patch for generating new documentation, you can > take a look at the usual URL (http://lpt.tyndur.org/cdi/english) > > Signed-off-by: Kevin Wolf > --- > ?doc/doc.h | ? 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > ?1 files changed, 71 insertions(+), 0 deletions(-) > > diff --git a/doc/doc.h b/doc/doc.h > index 94c4ccc..24a2198 100644 > --- a/doc/doc.h > +++ b/doc/doc.h > @@ -1,6 +1,77 @@ > ?/** > ?* \mainpage > + * \german > + * Die CDI-Dokumentation ist auch auf + * href="http://lpt.tyndur.org/cdi/english/">englisch verf?gbar.
> + * The CDI documentation is also available in + * href="http://lpt.tyndur.org/cdi/english/">English. > + * > + * \section main_introduction Einf?hrung > + * Das Common Driver Interface (oder kurz CDI) ist ein Standardinterface, > + * das es erm?glicht, betriebssystemunabh?ngige Treiber zu schreiben. > + * > + * Dies funktioniert mithilfe einer Bibliothek, die die Br?cke zwischen > + * Treiber und Betriebssystem bildet. CDI definiert die Datenstrukturen und > + * Funktionsprotoypen dieser Bibliothek, w?hrend ihre Implementierung > + * OS-spezifisch ist. CDI-komforme Treiber k?nnen ohne ?nderungen gegen diese > + * Bibliothek gebaut werden und stehen damit jedem Betriebssystem zur > + * Verf?gung, das CDI implementiert. > + * > + * Die folgenden Seiten seien zum Einstieg in die technischen Details > + * empfohlen: > ?* - \ref general_interface > + * - \ref core "Das Modul Core" > + * > + * \section main_resources Ressourcen > + * Der Quellcode der Treiber und die Headerdatei des Interfaces k?nnen aus dem > + * git-Repository heruntergeladen werden: > + * - http://git.tyndur.org/?p=cdi.git;a=tree > + * - git://git.tyndur.org/cdi.git > + * > + * F?r CDI existiert eine Mailingliste, auf der die Weiterentwicklung > + * diskutiert wird. Patches k?nnen ebenfalls an diese Mailingliste gesendet > + * werden. F?r die Mailingliste bitte bevorzugt Englisch verwenden. > + * - cdi-devel at tyndur.org > + * - http://list.tyndur.org/cgi-bin/mailman/listinfo/cdi-devel > + * > + * Auch im IRC sind CDI-Entwickler und -Benutzer vertreten: > + * - \#tyndur auf irc.euirc.net > + * \endgerman > + * \english > + * Die CDI-Dokumentation ist auch auf + * href="http://lpt.tyndur.org/cdi/">deutsch verf?gbar.
> + * The CDI documentation is also available in + * href="http://lpt.tyndur.org/cdi/">German. > + * > + * \section main_introduction Introduction > + * The Common Driver Interface (or CDI) is a standard interface that allows to > + * write OS independent drivers. > + * > + * To achieve this it employs a library that works as a bridge between > + * drivers and the OS. CDI defines things like data structures and function > + * prototypes of this library, whereas its implementation is OS specific. > + * Drivers conforming to the CDI can be built against this library without any > + * changes, so they can be used in any operating system implementing CDI. > + * > + * The following pages are recommended for an introduction into the technical > + * details: > + * - \ref general_interface > + * - \ref core "The module Core" > + * > + * \section main_resources Resources > + * The source code of drivers and the header files of the interface can be > + * downloaded from the git repository: > + * - http://git.tyndur.org/?p=cdi.git;a=tree > + * - git://git.tyndur.org/cdi.git > + * > + * For CDI there is a mailing list on which the further development is > + * discussed. It's also the right place to send patches to. > + * - cdi-devel at tyndur.org > + * - http://list.tyndur.org/cgi-bin/mailman/listinfo/cdi-devel > + * > + * You'll also find CDI developers and users on IRC: > + * - \#tyndur on irc.euirc.net > + * \endenglish > ?*/ > > ?/** > -- > 1.6.0.2 > > > _______________________________________________ > cdi-devel mailing list > cdi-devel at tyndur.org > http://list.tyndur.org/cgi-bin/mailman/listinfo/cdi-devel > > From kevin at tyndur.org Sat Sep 11 18:21:27 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sat, 11 Sep 2010 18:21:27 +0200 Subject: [cdi-devel] [RFC][PATCH v2] fat: Beginnings of a FAT file system driver Message-ID: <1284222087-11585-1-git-send-email-kevin@tyndur.org> This adds a FAT driver for FAT12/16/32. Long file names are not yet supported. Signed-off-by: Kevin Wolf --- So we're getting closer... This one adds some basic write support. Before merging it we still need to add: * Error handling in a lot of places * Support for yet unimplemented cdi/fs functions (e.g. truncate) * Documentation! Currently the only documented functions are those of the CDI interface (and the documentation is a straight copy of the German-only cdi/fs.h comments) * Some additional tests, especially for FAT 32 Anyway, if you handle it carefully this version of the driver actually works r/w on tyndur. fat/include | 1 + fat/libfat/dir.c | 536 ++++++++++++++++++++++++++++++++++++++ fat/libfat/file.c | 641 ++++++++++++++++++++++++++++++++++++++++++++++ fat/libfat/fs.c | 80 ++++++ fat/libfat/include/fat.h | 287 +++++++++++++++++++++ fat/main.c | 498 +++++++++++++++++++++++++++++++++++ 6 files changed, 2043 insertions(+), 0 deletions(-) create mode 120000 fat/include create mode 100644 fat/libfat/dir.c create mode 100644 fat/libfat/file.c create mode 100644 fat/libfat/fs.c create mode 100644 fat/libfat/include/fat.h create mode 100644 fat/main.c diff --git a/fat/include b/fat/include new file mode 120000 index 0000000..6f62628 --- /dev/null +++ b/fat/include @@ -0,0 +1 @@ +libfat/include/ \ No newline at end of file diff --git a/fat/libfat/dir.c b/fat/libfat/dir.c new file mode 100644 index 0000000..28926d2 --- /dev/null +++ b/fat/libfat/dir.c @@ -0,0 +1,536 @@ +#include +#include +#include +#include +#include "fat.h" + +static int fat_rootdir_open(struct fat_fs* fs, struct fat_dir* dir) +{ + int64_t rootdir_offset = fs->bpb.reserved_sectors + + (fs->bpb.num_fats * fs->bpb.fat_sectors); + + uint32_t rootdir_sectors = + (fs->bpb.rootdir_length * sizeof(struct fat_disk_dir_entry) + 511) + / 512; + + void* buf = malloc(512 * rootdir_sectors); + + // Wurzelverzeichnis einlesen + if (!fs->dev_read(rootdir_offset * 512, rootdir_sectors * 512, buf, + fs->dev_private)) + { + goto fail; + } + + // Rueckgabestruktur befuellen + dir->entries = buf; + dir->fs = fs; + dir->i = 0; + dir->first_cluster = 0; + dir->num = rootdir_sectors * 512 / sizeof(struct fat_disk_dir_entry); + + return 0; + +fail: + free(buf); + return -1; +} + +static int fat_rootdir32_open(struct fat_fs* fs, struct fat_dir* dir) +{ + struct fat_file file; + struct fat32_extended_bpb* ext = &fs->bpb.extended.fat32; + struct fat_dir_entry dentry = { + .size = 0, + .first_cluster = ext->rootdir_cluster, + }; + int ret; + void* buf; + + ret = fat_file_open_by_dir_entry(fs, &dentry, &file); + if (ret < 0) { + return ret; + } + + buf = malloc(file.size); + + ret = fat_file_read(&file, buf, 0, file.size); + fat_file_close(&file); + if (ret < 0) { + free(buf); + return ret; + } + + /* Rueckgabestruktur befuellen */ + dir->entries = buf; + dir->fs = fs; + dir->i = 0; + dir->first_cluster = 0; + dir->num = file.size / sizeof(struct fat_disk_dir_entry); + + return 0; +} + +static int fat_subdir_open_by_dir_entry(struct fat_fs* fs, + struct fat_dir_entry* dentry, struct fat_dir* subdir) +{ + struct fat_file file; + void* buf; + int first_cluster; + int ret; + + ret = fat_file_open_by_dir_entry(fs, dentry, &file); + if (ret < 0) { + return ret; + } + + /* + * Ein Verzeichnis ohne Cluster ist ein korruptes FS, fehlschlagen ist also + * in Ordnung. Wir sollten nur nicht auf file.blocklist[0] zugreifen. + */ + if (file.blocklist == NULL) { + fat_file_close(&file); + return -FAT_ENOENT; + } + + buf = malloc(file.size); + first_cluster = file.blocklist[0]; + + ret = fat_file_read(&file, buf, 0, file.size); + fat_file_close(&file); + if (ret < 0) { + free(buf); + return ret; + } + + /* Rueckgabestruktur befuellen */ + subdir->entries = buf; + subdir->fs = fs; + subdir->i = 0; + subdir->first_cluster = first_cluster; + subdir->num = file.size / sizeof(struct fat_disk_dir_entry); + + return 0; +} + +int fat_subdir_open(struct fat_fs* fs, struct fat_dir* dir, const char* path, + struct fat_dir* subdir) +{ + struct fat_dir_entry dentry; + int ret; + + /* Vaterverzeichnis nach Unterverzeichnis durchsuchen */ + do { + ret = fat_dir_read(dir, &dentry); + if (ret < 0) { + return ret; + } + + if ((ret >= 0) && !strcmp(dentry.name, path)) { + goto found; + } + } while (ret >= 0); + + return -FAT_ENOENT; + + /* Verzeichnis als Datei oeffnen und Eintraege laden */ +found: + return fat_subdir_open_by_dir_entry(fs, &dentry, subdir); +} + +int fat_dir_open(struct fat_fs* fs, const char* _path, struct fat_dir* dir) +{ + int ret; + char* path = strdup(_path); + char* p; + struct fat_dir subdir; + + if (fs->type == FS_TYPE_FAT32) { + ret = fat_rootdir32_open(fs, dir); + } else { + ret = fat_rootdir_open(fs, dir); + } + + if (ret < 0) { + goto out; + } + + /* Pfade muessen mit einem Slash anfangen */ + if (*path != '/') { + ret = -FAT_EINVAL; + goto out; + } + + /* Jetzt die Unterverzeichnisse parsen */ + p = strtok(path + 1, "/"); + while (p != NULL) { + ret = fat_subdir_open(fs, dir, p, &subdir); + fat_dir_close(dir); + if (ret < 0) { + goto out; + } + *dir = subdir; + p = strtok(NULL, "/"); + } + + ret = 0; +out: + free(path); + return ret; +} + +static void short_fn_to_string(struct fat_disk_dir_entry* entry, char* buf) +{ + int i; + int pos = -1; + int ext_start; + + // 8 Zeichen Name in Kleinbuchstaben + for (i = 0; i < 8; i++) { + buf[i] = tolower(entry->name[i]); + if (!isspace(buf[i])) { + pos = i; + } + } + + // Punkt + buf[++pos] = '.'; + + // 3 Zeichen Erweiterung in Kleinbuchstaben + ext_start = pos + 1; + for (i = 0; i < 3; i++) { + buf[ext_start + i] = tolower(entry->ext[i]); + if (!isspace(buf[ext_start + i])) { + pos = ext_start + i + 1; + } + } + + // Nullterminieren + buf[pos] = '\0'; +} + +static void string_to_short_fn(struct fat_disk_dir_entry* entry, + const char* buf) +{ + int i; + const char* p; + + for (i = 0; i < 8; i++) { + switch (buf[i]) { + case '.': + memset(&entry->name[i], ' ', 8 - i); + p = &buf[i + 1]; + goto parse_ext; + case '\0': + memset(&entry->name[i], ' ', 8 - i); + p = &buf[i]; + goto parse_ext; + default: + entry->name[i] = toupper(buf[i]); + break; + } + } + + p = strchr(&buf[8], '.'); +parse_ext: + if (!p || !*p) { + memset(entry->ext, ' ', 3); + return; + } + + for (i = 0; i < 3; i++) { + if (p[i] == '\0') { + memset(&entry->ext[i], ' ', 3 - i); + return; + } + entry->ext[i] = toupper(p[i]); + } +} + +static int is_free_entry(struct fat_disk_dir_entry* entry) +{ + // Die Datei existiert nicht + if (entry->name[0] == '\0') { + return 1; + } + + // Die Datei ist geloescht + if (entry->name[0] == (char) 0xE5) { + return 1; + } + + return 0; +} + +static int is_valid_entry(struct fat_disk_dir_entry* entry) +{ + // Die Datei existiert nicht oder ist geloescht + if (is_free_entry(entry)) { + return 0; + } + + // Die Datentraegerbezeichnung interessiert uns nicht + if (entry->attrib & FAT_ATTRIB_VOLUME) { + return 0; + } + + // . und .. werden ignoriert + if (entry->name[0] == '.') { + return 0; + } + + return 1; +} + +static void dir_entry_from_disk(struct fat_dir_entry* entry, + struct fat_disk_dir_entry* disk_entry) +{ + short_fn_to_string(disk_entry, entry->name); + + entry->first_cluster = disk_entry->first_cluster; + entry->size = disk_entry->size; + entry->attrib = disk_entry->attrib; +} + +static void dir_entry_to_disk(struct fat_file* file, + struct fat_disk_dir_entry* disk_entry) +{ + string_to_short_fn(disk_entry, file->dir_entry.name); + + disk_entry->first_cluster = file->dir_entry.first_cluster; + disk_entry->size = file->size; + disk_entry->attrib = file->dir_entry.attrib; +} + +int fat_dir_read(struct fat_dir* dir, struct fat_dir_entry* entry) +{ + if (dir->i < 0 || dir->i >= dir->num) { + return -1; + } + + // Ungueltige Eintraege ueberspringen + while (dir->i < dir->num && !is_valid_entry(&dir->entries[dir->i])) { + short_fn_to_string(&dir->entries[dir->i], entry->name); + dir->i++; + } + + // Fertig? + if (dir->i >= dir->num) { + return -1; + } + + dir_entry_from_disk(entry, &dir->entries[dir->i]); + entry->dir_first_cluster = dir->first_cluster; + entry->index_in_dir = dir->i; + + dir->i++; + + return 0; +} + +int fat_dir_update_rootdir_entry(struct fat_file* file) +{ + struct fat_fs* fs = file->fs; + struct fat_disk_dir_entry dentry; + +#if 0 + if (i < 0 ||i >= dir->num) { + return -FAT_EINVAL; + } +#endif + + int64_t rootdir_offset = fs->bpb.reserved_sectors + + (fs->bpb.num_fats * fs->bpb.fat_sectors); + uint32_t offset = rootdir_offset * 512 + + file->dir_entry.index_in_dir * sizeof(struct fat_disk_dir_entry); + + if (!fs->dev_read(offset, sizeof(struct fat_disk_dir_entry), &dentry, + fs->dev_private)) + { + return -FAT_EIO; + } + + dir_entry_to_disk(file, &dentry); + + if (!fs->dev_write(offset, sizeof(struct fat_disk_dir_entry), &dentry, + fs->dev_private)) + { + return -FAT_EIO; + } + + return 0; +} + +int fat_dir_update_subdir_entry(struct fat_file* file) +{ + struct fat_fs* fs = file->fs; + struct fat_dir_entry dentry = { + .first_cluster = file->dir_entry.dir_first_cluster, + .size = 0, + .attrib = FAT_ATTRIB_DIR, + }; + struct fat_disk_dir_entry file_dentry; + struct fat_file dir; + int ret; + +#if 0 + if (i < 0 ||i >= dir->num) { + return -FAT_EINVAL; + } +#endif + + uint32_t offset = + file->dir_entry.index_in_dir * sizeof(struct fat_disk_dir_entry); + + + ret = fat_file_open_by_dir_entry(fs, &dentry, &dir); + if (ret < 0) { + return ret; + } + + /* Bisherigen Verzeichniseintrag laden, falls vorhanden */ + if (offset < file->size) { + ret = fat_file_read(&dir, &file_dentry, offset, + sizeof(struct fat_disk_dir_entry)); + if (ret < 0) { + return ret; + } + } else { + memset(&file_dentry, 0, sizeof(file_dentry)); + } + + /* Felder aktualisieren */ + dir_entry_to_disk(file, &file_dentry); + + ret = fat_file_write(&dir, &file_dentry, offset, + sizeof(struct fat_disk_dir_entry)); + if (ret < 0) { + return ret; + } + + fat_file_close(&dir); + + return 0; +} + +int fat_dir_update_entry(struct fat_file* file) +{ + if (file->dir_entry.dir_first_cluster == 0) { + return fat_dir_update_rootdir_entry(file); + } else { + return fat_dir_update_subdir_entry(file); + } +} + +/* FIXME Verzeichnis lesen nach create_entry + * FIXME Zwei vergroessernde Aufrufe ueberschreiben sich gegenseitig + * FIXME Verzeichnis erweitern auf neuen nicht genullten Cluster */ +int fat_dir_create_entry(struct fat_dir* dir, const char* name, int attr, + struct fat_dir_entry* dir_entry) +{ + int i; + int ret; + + /* Dateistruktur faken, deren Verzeichniseintrag "geaendert" werden soll */ + struct fat_file file = { + .fs = dir->fs, + .size = 0, + .dir_entry = { + .dir_first_cluster = dir->first_cluster, + .index_in_dir = 0, + .first_cluster = 0, + .attrib = attr, + }, + }; + + /* Freien Index im Verzeichnis suchen */ + for (i = 0; i < dir->num; i++) { + if (is_free_entry(&dir->entries[i])) { + goto found; + } + } + + /* Ausser dem Wurzelverzeichnis koennen wir alles vergroessern */ + if (dir->first_cluster != 0) { + i = dir->num; + goto found; + } + + return -FAT_ENOENT; + +found: + strncpy(file.dir_entry.name, name, sizeof(file.dir_entry.name)); + file.dir_entry.name[sizeof(file.dir_entry.name) - 1] = '\0'; + file.dir_entry.index_in_dir = i; + + if (attr & FAT_ATTRIB_DIR) { + fat_file_alloc_first_cluster(&file); + } + + /* Ins Verzeichnis eintragen */ + ret = fat_dir_update_entry(&file); + if (ret < 0) { + return ret; + } + + if (dir_entry) { + *dir_entry = file.dir_entry; + } + + return 0; +} + +int fat_dir_create(struct fat_dir* dir, const char* name, + struct fat_dir_entry* dir_entry) +{ + struct fat_file dir_file; + struct fat_dir_entry dentry; + int ret; + uint32_t cluster_size = dir->fs->bpb.cluster_sectors * 512; + uint8_t buf[cluster_size]; + struct fat_disk_dir_entry* disk_dentry; + + /* Verzeichnis anlegen */ + ret = fat_dir_create_entry(dir, name, FAT_ATTRIB_DIR, &dentry); + if (ret < 0) { + return ret; + } + + /* Und einen genullten Cluster reservieren */ + ret = fat_file_open_by_dir_entry(dir->fs, &dentry, &dir_file); + if (ret < 0) { + return ret; + } + + disk_dentry = (struct fat_disk_dir_entry*) buf; + memset(buf, 0, cluster_size); + disk_dentry[0] = (struct fat_disk_dir_entry) { + .name = ". ", + .ext = " ", + .attrib = FAT_ATTRIB_DIR, + .first_cluster = dentry.first_cluster, + .size = 0, + }; + disk_dentry[1] = (struct fat_disk_dir_entry) { + .name = ".. ", + .ext = " ", + .attrib = FAT_ATTRIB_DIR, + .first_cluster = dir->first_cluster, + .size = 0, + }; + + ret = fat_file_write(&dir_file, buf, 0, cluster_size); + fat_file_close(&dir_file); + + if (dir_entry) { + *dir_entry = dentry; + } + + return ret; +} + +int fat_dir_close(struct fat_dir* dir) +{ + free(dir->entries); + return 0; +} diff --git a/fat/libfat/file.c b/fat/libfat/file.c new file mode 100644 index 0000000..84644f5 --- /dev/null +++ b/fat/libfat/file.c @@ -0,0 +1,641 @@ +#include +#include + +#include "fat.h" + +#define NUM_CLUSTERS(x, cluster_size) \ + (((x) + (cluster_size) - 1) / (cluster_size)) +#define SECTOR_BITS (512 * 8) + +#define MIN(a,b) ((a) < (b) ? (a) : (b)) + +// FIXME Sektorgroesse != 512 + +static uint8_t fat_buf[1024]; +static struct fat_fs* fat_buf_fs = NULL; +static uint32_t fat_buf_sector = 0; +static int fat_buf_changed = 0; + +static uint32_t get_next_cluster(struct fat_fs* fs, uint32_t cluster); + + +static uint8_t* get_fat_buffer(struct fat_fs* fs, uint32_t sector) +{ + sector += fs->bpb.reserved_sectors; + + if (fs == fat_buf_fs && sector == fat_buf_sector) { + return fat_buf; + } + + /* FIXME Write back changed entries before overwriting them */ + /* TODO Evtl. reicht memcpy und lesen nur eines Sektors */ + if (!fs->dev_read(sector * 512, 1024, fat_buf, fs->dev_private)) { + fat_buf_fs = NULL; + return NULL; + } + + fat_buf_fs = fs; + fat_buf_sector = sector; + fat_buf_changed = 0; + + return fat_buf; +} + +static int commit_fat_buffer(struct fat_fs* fs) +{ + int i; + uint32_t sector; + + if (fs != fat_buf_fs) { + return 0; + } + + sector = fat_buf_sector; + for (i = 0; i < fs->bpb.num_fats; i++) { + /* TODO Evtl. reicht schreiben nur eines Sektors */ + if (!fs->dev_write(sector * 512, 1024, fat_buf, fs->dev_private)) { + return -FAT_EIO; + } + + if (fs->type == FS_TYPE_FAT32) { + sector += fs->bpb.extended.fat32.fat_sectors; + } else { + sector += fs->bpb.fat_sectors; + } + } + + fat_buf_changed = 0; + + return 0; +} + +static uint32_t get_next_cluster_fat12(struct fat_fs* fs, uint32_t cluster) +{ + uint8_t* buf; + uint32_t fat_bit_offset = (cluster * 12ULL); + uint32_t fat_sector = fat_bit_offset / SECTOR_BITS; + uint32_t value; + + fat_bit_offset %= SECTOR_BITS; + + buf = get_fat_buffer(fs, fat_sector); + if (buf == NULL) { + return 0; + } + + value = *((uint16_t*) &buf[fat_bit_offset / 8]); + + if ((fat_bit_offset & 7) == 0) { + value &= 0xFFF; + } else { + value >>= 4; + } + + if (value > 0xff5) { + value |= 0xfffff000; + } + + return value; +} + +static uint32_t get_next_cluster_fat16(struct fat_fs* fs, uint32_t cluster) +{ + uint8_t* buf; + uint32_t fat_sector = (cluster * sizeof(uint16_t)) / 512; + uint32_t fat_offset = (cluster * sizeof(uint16_t)) % 512; + uint32_t value; + + buf = get_fat_buffer(fs, fat_sector); + if (buf == NULL) { + return 0; + } + + value = *((uint16_t*) &buf[fat_offset]); + + if (value > 0xfff5) { + value |= 0xffff0000; + } + + return value; +} + +static uint32_t get_next_cluster_fat32(struct fat_fs* fs, uint32_t cluster) +{ + uint8_t* buf; + uint32_t fat_sector = (cluster * sizeof(uint32_t)) / 512; + uint32_t fat_offset = (cluster * sizeof(uint32_t)) % 512; + uint32_t value; + + buf = get_fat_buffer(fs, fat_sector); + if (buf == NULL) { + return 0; + } + + value = *((uint32_t*) &buf[fat_offset]); + + if (value > 0xffffff5) { + value |= 0xf0000000; + } + + return value; +} + +static int set_next_cluster_fat12(struct fat_fs* fs, uint32_t cluster, + uint32_t value) +{ + uint8_t* buf; + uint32_t fat_bit_offset = (cluster * 12ULL); + uint32_t fat_sector = fat_bit_offset / SECTOR_BITS; + uint16_t* pvalue; + + fat_bit_offset %= SECTOR_BITS; + + buf = get_fat_buffer(fs, fat_sector); + if (buf == NULL) { + return 0; + } + + pvalue = ((uint16_t*) &buf[fat_bit_offset / 8]); + value &= 0xFFF; + + if ((fat_bit_offset & 7) == 0) { + *pvalue &= ~0xFFF; + *pvalue |= value; + } else { + *pvalue &= ~0xFFF0; + *pvalue |= (value << 4); + } + fat_buf_changed = 1; + + get_next_cluster_fat12(fs, cluster); + + return 0; +} + +static int set_next_cluster_fat16(struct fat_fs* fs, uint32_t cluster, + uint32_t value) +{ + uint8_t* buf; + uint32_t fat_sector = (cluster * sizeof(uint16_t)) / 512; + uint32_t fat_offset = (cluster * sizeof(uint16_t)) % 512; + + buf = get_fat_buffer(fs, fat_sector); + if (buf == NULL) { + return -FAT_EIO; + } + + *((uint16_t*) &buf[fat_offset]) = value; + fat_buf_changed = 1; + + return 0; +} + +static int set_next_cluster(struct fat_fs* fs, uint32_t cluster, + uint32_t value) +{ + if (fs->type == FS_TYPE_FAT12) { + return set_next_cluster_fat12(fs, cluster, value); + } else if (fs->type == FS_TYPE_FAT16) { + return set_next_cluster_fat16(fs, cluster, value); + } else { + return -FAT_EINVAL; + } +} + +int fat_file_alloc_first_cluster(struct fat_file* file) +{ + struct fat_fs* fs = file->fs; + uint32_t num_data_clusters = NUM_CLUSTERS( + fs->total_sectors - fs->first_data_cluster, + fs->bpb.cluster_sectors); + uint32_t j; + int ret; + + /* Freien Cluster suchen und einhaengen */ + for (j = 0; j < num_data_clusters; j++) { + if (get_next_cluster(fs, j) == 0) { + goto found; + } + } + + return -FAT_ENOSPC; + + /* EOF-Markierung in die FAT eintragen */ +found: + ret = set_next_cluster(fs, j, 0xffffffff); + if (ret < 0) { + return ret; + } + + commit_fat_buffer(fs); + + /* Cluster der Datei zuordnen */ + file->dir_entry.first_cluster = j; + + return 0; +} + +static int fat_extend_file(struct fat_file* file, uint32_t new_size) +{ + struct fat_fs* fs = file->fs; + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + size_t old_blocklist_size = file->blocklist_size; + size_t new_blocklist_size = NUM_CLUSTERS(new_size, cluster_size); + int ret; + + /* Ersten Cluster der Kette allozieren */ + if (file->blocklist == NULL) { + fat_file_alloc_first_cluster(file); + + old_blocklist_size = 1; + file->blocklist_size = 1; + file->blocklist = malloc(sizeof(*file->blocklist)); + file->blocklist[0] = file->dir_entry.first_cluster; + } + + /* Wenn noetig, neue Cluster allozieren */ + if (new_blocklist_size != old_blocklist_size) { + uint32_t i; + uint32_t num_data_clusters = NUM_CLUSTERS( + fs->total_sectors - fs->first_data_cluster, + fs->bpb.cluster_sectors); + uint32_t free_index = 0; + + /* Blockliste vergroessern */ + file->blocklist = realloc(file->blocklist, + new_blocklist_size * sizeof(uint32_t)); + file->blocklist_size = new_blocklist_size; + + /* Neue Eintraege der Blockliste befuellen */ + for (i = old_blocklist_size; i < new_blocklist_size; i++) { + uint32_t j; + + /* Freien Cluster suchen und einhaengen */ + for (j = free_index; j < num_data_clusters; j++) { + if (get_next_cluster(fs, j) == 0) { + + /* Neue EOF-Markierung */ + file->blocklist[i] = j; + ret = set_next_cluster(fs, file->blocklist[i], 0xffffffff); + if (ret < 0) { + return ret; + } + + /* In die Clusterkette einhaengen */ + ret = set_next_cluster(fs, file->blocklist[i - 1], j); + if (ret < 0) { + return ret; + } + + free_index = j; + goto found; + } + } + + return -FAT_ENOSPC; + found: + /* Weiter mit naechstem Cluster */; + } + + /* Und zuletzt veraenderte Eintraege zurueckschreiben */ + commit_fat_buffer(fs); + } + + /* Dateigroesse anpassen und ggf. neuen ersten Cluster eintragen */ + file->size = new_size; + if ((file->dir_entry.attrib & FAT_ATTRIB_DIR) == 0) { + fat_dir_update_entry(file); + } + + return 0; +} + +static uint32_t get_next_cluster(struct fat_fs* fs, uint32_t cluster) +{ + switch (fs->type) { + case FS_TYPE_FAT12: + return get_next_cluster_fat12(fs, cluster); + + case FS_TYPE_FAT16: + return get_next_cluster_fat16(fs, cluster); + + case FS_TYPE_FAT32: + return get_next_cluster_fat32(fs, cluster); + + default: + return -FAT_EINVAL; + } +} + + +int fat_file_open_by_dir_entry(struct fat_fs* fs, struct fat_dir_entry* entry, + struct fat_file* file) +{ + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint32_t cluster; + uint32_t i; + + /* Dateistruktur anlegen */ + file->fs = fs; + file->size = entry->size; + file->dir_entry = *entry; + + /* Eine leere Datei braucht keine Blockliste */ + if (entry->first_cluster == 0) { + file->blocklist = NULL; + file->blocklist_size = 0; + return 0; + } + + /* + * Blockliste anlegen und einlesen. Bei Groesse 0 (z.B. Verzeichnisse gehen + * wir von unbekannter Dateigroesse aus und lassen die Blockliste dynamisch + * wachsen. + */ + if (file->size > 0) { + file->blocklist_size = NUM_CLUSTERS(file->size, cluster_size); + } else { + file->blocklist_size = 1; + } + + file->blocklist = malloc(file->blocklist_size * sizeof(uint32_t)); + file->blocklist[0] = entry->first_cluster; + + cluster = 0; + i = 1; + while (1) { + cluster = get_next_cluster(fs, file->blocklist[i - 1]); + + /* Fehler und Dateiende */ + if (cluster == 0) { + goto fail; + } else if (cluster >= 0xfffffff8) { + break; + } + + /* Blocklist vergroessern, falls noetig */ + if (file->blocklist_size <= i) { + file->blocklist_size *= 2; + file->blocklist = realloc(file->blocklist, + file->blocklist_size * sizeof(uint32_t)); + } + + /* In die Blockliste eintragen */ + file->blocklist[i] = cluster; + + i++; + } + + /* Dateigroesse anpassen, wenn sie unbekannt war */ + if (file->size == 0) { + file->size = i * cluster_size; + } + + return 0; + +fail: + free(file->blocklist); + return -FAT_EIO; +} + +int fat_file_open(struct fat_fs* fs, const char* path, struct fat_file* file) +{ + struct fat_dir dir; + struct fat_dir_entry dentry; + int ret; + char* p; + + /* Letzten Pfadtrenner suchen */ + p = strrchr(path, '/'); + if (p == NULL) { + return -FAT_EINVAL; + } + + /* Verzeichnis oeffnen */ + int len = p - path + 1; + char dirname[len + 1]; + + memcpy(dirname, path, len); + dirname[len] = '\0'; + + ret = fat_dir_open(fs, dirname, &dir); + if (ret< 0) { + return ret; + } + + /* Alles vor dem Dateinamen wegwerfen */ + path = p + 1; + + /* Verzeichnis nach Dateinamen durchsuchen */ + do { + ret = fat_dir_read(&dir, &dentry); + if (ret >= 0 && !strcmp(dentry.name, path)) { + break; + } + } while (ret >= 0); + + /* Datei oeffnen oder -ENOENT zurueckgeben, wenn sie nicht existiert */ + if (ret < 0) { + return -FAT_ENOENT; + } + + /* Verzeichnis wieder schliessen */ + ret = fat_dir_close(&dir); + if (ret < 0) { + return ret; + } + + return fat_file_open_by_dir_entry(fs, &dentry, file); +} + +static uint32_t file_get_cluster(struct fat_file* file, uint32_t file_cluster) +{ + if (file_cluster >= file->blocklist_size) { + return 0; + } + + return file->blocklist[file_cluster]; +} + +static int64_t get_data_cluster_offset(struct fat_fs* fs, uint32_t cluster_idx) +{ + uint32_t sector = fs->bpb.cluster_sectors * (cluster_idx - 2); + + return (fs->first_data_cluster + sector) * 512; +} + +static int read_cluster(struct fat_fs* fs, void* buf, uint32_t cluster_idx) +{ + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint32_t cluster_offset = get_data_cluster_offset(fs, cluster_idx); + + if (!fs->dev_read(cluster_offset, cluster_size, buf, fs->dev_private)) { + return -FAT_EIO; + } + + return 0; +} + +static int read_cluster_part(struct fat_fs* fs, void* buf, + uint32_t cluster_idx, size_t offset, size_t len) +{ + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint8_t cluster[cluster_size]; + int ret; + + assert (offset + len <= cluster_size); + + ret = read_cluster(fs, cluster, cluster_idx); + if (ret < 0) { + return ret; + } + + memcpy(buf, cluster + offset, len); + return 0; +} + +static int write_cluster(struct fat_fs* fs, void* buf, uint32_t cluster_idx) +{ + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint32_t cluster_offset = get_data_cluster_offset(fs, cluster_idx); + + if (!fs->dev_write(cluster_offset, cluster_size, buf, fs->dev_private)) { + return -FAT_EIO; + } + + return 0; +} + +static int write_cluster_part(struct fat_fs* fs, void* buf, + uint32_t cluster_idx, size_t offset, size_t len) +{ + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint8_t cluster[cluster_size]; + int ret; + + assert (offset + len <= cluster_size); + + ret = read_cluster(fs, cluster, cluster_idx); + if (ret < 0) { + return ret; + } + + memcpy(cluster + offset, buf, len); + + ret = write_cluster(fs, cluster, cluster_idx); + if (ret < 0) { + return ret; + } + + return 0; +} + +int32_t fat_file_rw(struct fat_file* file, void* buf, uint32_t offset, + size_t len, int is_write) +{ + struct fat_fs* fs = file->fs; + uint32_t cluster_size = fs->bpb.cluster_sectors * 512; + uint8_t* p = buf; + size_t n = len; + int ret; + uint32_t file_cluster = offset / cluster_size; + uint32_t disk_cluster; + uint32_t offset_in_cluster; + + /* Funktionspointer fuer Lesen/Schreiben von Clustern */ + int (*rw_cluster)(struct fat_fs* fs, void* buf, uint32_t cluster_idx); + int (*rw_cluster_part)(struct fat_fs* fs, void* buf, uint32_t cluster_idx, + size_t offset, size_t len); + + if (is_write) { + rw_cluster = write_cluster; + rw_cluster_part = write_cluster_part; + } else { + rw_cluster = read_cluster; + rw_cluster_part = read_cluster_part; + } + + /* Angefangener Cluster am Anfang */ + offset_in_cluster = offset & (cluster_size - 1); + if (offset_in_cluster) { + uint32_t count = MIN(n, cluster_size - offset_in_cluster); + + disk_cluster = file_get_cluster(file, file_cluster++); + if (disk_cluster == 0) { + return -FAT_EIO; + } + + ret = rw_cluster_part(fs, p, disk_cluster, offset_in_cluster, count); + if (ret < 0) { + return ret; + } + + p += count; + n -= count; + } + + /* Eine beliebige Anzahl von ganzen Clustern in der Mitte */ + while (n >= cluster_size) { + disk_cluster = file_get_cluster(file, file_cluster++); + if (disk_cluster == 0) { + return -FAT_EIO; + } + + ret = rw_cluster(fs, p, disk_cluster); + if (ret < 0) { + return ret; + } + + p += cluster_size; + n -= cluster_size; + } + + /* Und wieder ein angefangener Cluster am Ende */ + if (n) { + disk_cluster = file_get_cluster(file, file_cluster); + if (disk_cluster == 0) { + return -FAT_EIO; + } + + ret = rw_cluster_part(fs, p, disk_cluster, 0, n); + if (ret < 0) { + return ret; + } + } + + return 0; +} + +int32_t fat_file_read(struct fat_file* file, void* buf, uint32_t offset, + size_t len) +{ + + /* Bei Ueberlaenge Fehler zurueckgeben */ + if (offset + len > file->size) { + return -FAT_EIO; + } + + return fat_file_rw(file, buf, offset, len, 0); +} + +int32_t fat_file_write(struct fat_file* file, const void* buf, uint32_t offset, + size_t len) +{ + int ret; + + /* Datei erweitern, falls noetig */ + if (offset + len > file->size) { + ret = fat_extend_file(file, offset + len); + if (ret < 0) { + return ret; + } + } + + return fat_file_rw(file, (void*) buf, offset, len, 1); +} + +int fat_file_close(struct fat_file* file) +{ + free(file->blocklist); + return 0; +} diff --git a/fat/libfat/fs.c b/fat/libfat/fs.c new file mode 100644 index 0000000..5fcf583 --- /dev/null +++ b/fat/libfat/fs.c @@ -0,0 +1,80 @@ +#include +#include "fat.h" + +/** + * fat-Dateisystem einbinden. Dafuer muessen dev_read, dev_write und + * dev_private (falls notwendig) initialisiert sein. + * + * @return 1 bei Erfolg, im Fehlerfall 0 + */ +int fat_fs_mount(struct fat_fs* fs) +{ + // BPB einlesen + if (!fs->dev_read(0, 512, &fs->bpb, fs->dev_private)) { + return 0; + } + + // Magic pruefen + if (fs->bpb.magic != 0xaa55) { + return 0; + } + + // FAT-Variante bestimmen + uint32_t total_sectors; + uint32_t rootdir_sectors; + uint32_t data_sectors; + uint32_t data_clusters; + + if (fs->bpb.total_sectors != 0) { + total_sectors = fs->bpb.total_sectors; + } else { + // TODO Hier ist auf jeden Fall FAT32, egal wie viele Cluster + total_sectors = fs->bpb.total_sectors_large; + } + + rootdir_sectors = + (fs->bpb.rootdir_length * sizeof(struct fat_disk_dir_entry) + 511) + / 512; + + // TODO fat_sectors ungueltig fuer FAT32 + data_sectors = total_sectors + - fs->bpb.reserved_sectors + - (fs->bpb.num_fats * fs->bpb.fat_sectors) + - rootdir_sectors; + data_clusters = data_sectors / fs->bpb.cluster_sectors; + + if (data_clusters < 4085) { + fs->type = FS_TYPE_FAT12; + } else if (data_clusters < 65525) { + fs->type = FS_TYPE_FAT16; + } else { + fs->type = FS_TYPE_FAT32; + data_sectors -= + (fs->bpb.num_fats * fs->bpb.extended.fat32.fat_sectors); + } + + + fs->total_sectors = total_sectors; + fs->first_data_cluster = total_sectors - data_sectors; + + return 1; +} + +/** + * fat-Dateisystem aushaengen. Dabei werden saemtliche gecachten Daten auf die + * Platte geschrieben. Die Member sb und cache_handle in der fs-Struktur sind + * danach NULL. + * + * @return 1 bei Erfolg, im Fehlerfall 0 + */ +int fat_fs_unmount(struct fat_fs* fs) +{ + return 0; +} + +/** + * Saetmliche gecachten Daten auf die Platte schreiben + */ +void fat_fs_sync(struct fat_fs* fs) +{ +} diff --git a/fat/libfat/include/fat.h b/fat/libfat/include/fat.h new file mode 100644 index 0000000..5b62a10 --- /dev/null +++ b/fat/libfat/include/fat.h @@ -0,0 +1,287 @@ +#ifndef _FAT_H_ +#define _FAT_H_ + +#include +#include + +#ifdef CDI_HAS_ERRNO + +#include +#define FAT_ENOENT ENOENT +#define FAT_EIO EIO +#define FAT_EINVAL EINVAL +#define FAT_ENOSPC ENOSPC + +#else + +#define FAT_ENOENT 1 +#define FAT_EIO 2 +#define FAT_EINVAL 3 +#define FAT_ENOSPC 4 + +#endif + +// TODO Nur fuer Debugging - spaeter entfernen +#include + +struct fat32_extended_bpb { + uint32_t fat_sectors; + uint16_t flags; + uint16_t version; + uint32_t rootdir_cluster; +} __attribute__((packed)); + +/** + * BIOS Parameter Block + */ +struct fat_bpb { + uint8_t jmp_code[3]; + char os_name[8]; + uint16_t sector_size; + uint8_t cluster_sectors; + uint16_t reserved_sectors; + uint8_t num_fats; + uint16_t rootdir_length; + uint16_t total_sectors; + uint8_t media_type; + + /* Nur fuer FAT12/16; FAT32 benutzt fat32_extended_bpb.fat_sectors */ + uint16_t fat_sectors; + + uint16_t sectors_per_track; + uint16_t heads; + uint32_t hidden_sectors; + uint32_t total_sectors_large; + union { + struct fat32_extended_bpb fat32; + uint8_t bytes[474]; + } extended; + uint16_t magic; +} __attribute__((packed)); + +enum fat_type { + FS_TYPE_FAT12, + FS_TYPE_FAT16, + FS_TYPE_FAT32, +}; + +/** + * Zentrale Struktur zur Verwaltung eines eingebundenen Dateisystemes + */ +struct fat_fs { + /** + * Funktionspointer der von Aufrufer gesetzt werden muss. Diese Funktion + * liest Daten vom Datentraeger ein, auf dem sich das Dateisystem befindet. + * + * @param start Position von der an gelesen werden soll + * @param size Anzahl der zu lesenden Bytes + * @param dest Pointer auf den Puffer in dem die Daten abgelegt werden + * sollen + * @param prv Private Daten zum Zugriff auf den Datentraeger (z.B. + * Dateideskriptor), aus dev_private zu entnehmen + * + * @return 1 wenn das Lesen geklappt hat, 0 sonst + */ + int (*dev_read)(uint64_t start, size_t size, void* dest, void* prv); + + /** + * Funktionspointer der von Aufrufer gesetzt werden muss. Diese Funktion + * schreibt Daten auf den Datentraeger, auf dem sich das Dateisystem + * befindet. + * + * @param start Position von der an gelesen werden soll + * @param size Anzahl der zu lesenden Bytes + * @param dest Pointer auf den Puffer, aus dem die Daten gelesen werden + * sollen. + * @param prv Private Daten zum Zugriff auf den Datentraeger (z.B. + * Dateideskriptor), aus dev_private zu entnehmen + * + * @return 1 wenn das Schreiben geklappt hat, 0 sonst + */ + int (*dev_write)(uint64_t start, size_t size, const void* source, + void* prv); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * erstellt einen neuen Cache und gibt ein Handle darauf zurueck. + * + * @param fs Pointer auf das Dateisystem fuer das der Cache + * erstellt werden soll. + * @param block_size Blockgroesse im Cache + * + * @return Handle oder NULL im Fehlerfall + */ + void* (*cache_create)(struct fat_fs* fs, size_t block_size); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * zerstoert einen mit cache_create erstellten Cache + * + * @param cache Handle + */ + void (*cache_destroy)(void* handle); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * schreibt alle veraenderten Cache-Blocks auf die Platte + * + * @param cache Handle + */ + void (*cache_sync)(void* handle); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * holt einen Block aus dem Cache und gibt einen Pointer auf ein + * Block-Handle zrueck. Dieser Pointer ist mindestens solange gueltig, wie + * das Handle nicht freigegeben wird. + * + * @param cache Cache-Handle + * @param block Blocknummer + * @param noread Wenn dieser Parameter != 0 ist, wird der Block nicht + * eingelesen. Das kann benutzt werden, wenn er eh + * vollstaendig ueberschrieben wird. + * + * @return Block-Handle + */ + struct fat_cache_block* (*cache_block)(void* cache, uint64_t block, + int noread); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * markiert den angegebenen Block als veraendert, damit er geschrieben wird, + * bevor er aus dem Cache entfernt wird. + * + * @param handle Block-Handle + */ + void (*cache_block_dirty)(struct fat_cache_block* handle); + + /** + * Funktionspointer der vom Aufrufer gesetzt werden muss. Diese Funktion + * gibt einen mit cache_block alloziierten Block wieder frei. + * + * @param handle Block-Handle + * @param dirty Wenn != 0 wird der Block auch als Dirty markiert + */ + void (*cache_block_free)(struct fat_cache_block* handle, int dirty); + + + /// Private Daten zum Zugriff auf den Datentraeger + void* dev_private; + + /// Handle fuer Blockcache + void* cache_handle; + + /// Darf vom Aufrufer benutzt werden + void* opaque; + + /// BIOS Parameter Block + struct fat_bpb bpb; + + enum fat_type type; + uint32_t total_sectors; + uint32_t first_data_cluster; +}; + +/** + * Cache-Block-Handle + */ +struct fat_cache_block { + /// Blocknummer + uint64_t number; + + /// Daten + void* data; + + /// Cache-Handle + void* cache; + + /// Daten fuer die Implementierung + void* opaque; +}; + +/** + * fat-Dateisystem einbinden. Dafuer muessen dev_read, dev_write und + * dev_private (falls notwendig) initialisiert sein. + * + * @return 1 bei Erfolg, im Fehlerfall 0 + */ +int fat_fs_mount(struct fat_fs* fs); + +/** + * fat-Dateisystem aushaengen. Dabei werden saemtliche gecachten Daten auf die + * Platte geschrieben. Die Member sb und cache_handle in der fs-Struktur sind + * danach NULL. + * + * @return 1 bei Erfolg, im Fehlerfall 0 + */ +int fat_fs_unmount(struct fat_fs* fs); + +/** + * Saetmliche gecachten Daten auf die Platte schreiben + */ +void fat_fs_sync(struct fat_fs* fs); + +#define FAT_ATTRIB_READONLY 0x01 +#define FAT_ATTRIB_HIDDEN 0x02 +#define FAT_ATTRIB_SYSTEM 0x04 +#define FAT_ATTRIB_VOLUME 0x08 +#define FAT_ATTRIB_DIR 0x10 +#define FAT_ATTRIB_ARCHIVE 0x20 + +struct fat_disk_dir_entry { + char name[8]; + char ext[3]; + uint8_t attrib; + uint8_t data[14]; + uint16_t first_cluster; + uint32_t size; +} __attribute__((packed)); + + +struct fat_dir_entry { + int index_in_dir; + int dir_first_cluster; + char name[13]; /* 8.3 plus \0 */ + int first_cluster; + int attrib; + uint32_t size; +}; + +struct fat_file; + +struct fat_dir { + struct fat_fs* fs; + struct fat_disk_dir_entry* entries; + int first_cluster; + int i; + int num; +}; + +int fat_dir_open(struct fat_fs* fs, const char* path, struct fat_dir* dir); +int fat_dir_read(struct fat_dir* dir, struct fat_dir_entry* entry); +int fat_dir_create_entry(struct fat_dir* dir, const char* name, int attr, + struct fat_dir_entry* dir_entry); +int fat_dir_create(struct fat_dir* dir, const char* name, + struct fat_dir_entry* dir_entry); +int fat_dir_update_entry(struct fat_file* file); +int fat_dir_close(struct fat_dir* dir); + +struct fat_file { + struct fat_fs* fs; + uint32_t size; + size_t blocklist_size; + uint32_t* blocklist; + struct fat_dir_entry dir_entry; +}; + +int fat_file_open(struct fat_fs* fs, const char* path, struct fat_file* file); +int fat_file_open_by_dir_entry(struct fat_fs* fs, struct fat_dir_entry* entry, + struct fat_file* file); +int fat_file_alloc_first_cluster(struct fat_file* file); +int32_t fat_file_read(struct fat_file* file, void* buf, uint32_t offset, + size_t len); +int32_t fat_file_write(struct fat_file* file, const void* buf, uint32_t offset, + size_t len); +int fat_file_close(struct fat_file* file); + +#endif diff --git a/fat/main.c b/fat/main.c new file mode 100644 index 0000000..c329ce4 --- /dev/null +++ b/fat/main.c @@ -0,0 +1,498 @@ +/* + * Copyright (c) 2010 The tyndur Project. All rights reserved. + * + * This code is derived from software contributed to the tyndur Project + * by Kevin Wolf. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include +#include + +#include "fat.h" + +#define DRIVER_NAME "fat" + +struct fat_res { + struct cdi_fs_res cdi; + char* path; /* TODO Remove this */ + struct fat_dir_entry dir_entry; + struct fat_file file; +}; + +static int fat_res_load(struct cdi_fs_stream* s); +static int64_t fat_res_meta_read(struct cdi_fs_stream* s, cdi_fs_meta_t meta); +static cdi_list_t fat_dir_list(struct cdi_fs_stream* s); +static size_t fat_file_op_read(struct cdi_fs_stream* s, uint64_t start, + size_t size, void* buffer); +static size_t fat_file_op_write(struct cdi_fs_stream* stream, uint64_t start, + size_t size, const void* buffer); +static int fat_dir_create_child(struct cdi_fs_stream* stream, + const char* name, struct cdi_fs_res* parent); +static int fat_res_assign_class(struct cdi_fs_stream* s, + cdi_fs_res_class_t class); +static int fat_file_op_truncate(struct cdi_fs_stream* s, uint64_t size); + +static struct cdi_fs_driver fat_driver; + +static struct cdi_fs_res_res fat_res_ops = { + .load = fat_res_load, + .meta_read = fat_res_meta_read, + .assign_class = fat_res_assign_class, +}; + +static struct cdi_fs_res_dir fat_dir_ops = { + .list = fat_dir_list, + .create_child = fat_dir_create_child, +}; + +static struct cdi_fs_res_file fat_file_ops = { + .read = fat_file_op_read, + .write = fat_file_op_write, + .truncate = fat_file_op_truncate, +}; + +static int fat_data_read(uint64_t start, size_t size, void* dest, void* prv) +{ + int ret; + ret = cdi_fs_data_read(prv, start, size, dest); + return ret == size; +} + +static int fat_data_write(uint64_t start, size_t size, const void* source, + void* prv) +{ + int ret; + ret = cdi_fs_data_write(prv, start, size, source); + return ret == size; +} + +/** + * Initialisiert die Datenstrukturen fuer den fat-Treiber + */ +static int fat_driver_init(void) +{ + cdi_fs_driver_init(&fat_driver); + return 0; +} + +/** + * Deinitialisiert die Datenstrukturen fuer den fat-Treiber + */ +static int fat_driver_destroy(void) +{ + cdi_fs_driver_destroy(&fat_driver); + return 0; +} + +/** + * Neues Dateisystem initialisieren; Diese Funktion muss das root_object in + * der Dateisystemstruktur eintragen. + * + * @return Wenn das Dateisystem erfolgreich initialisiert wurde 1, sonst + * 0. Falls ein Fehler auftritt, muss das error-Feld in der + * Dateisystemstruktur gesetzt werden. + */ +static int fat_fs_init(struct cdi_fs_filesystem* fs) +{ + struct fat_res* root; + struct fat_fs* fat_fs; + + /* Initialize root node */ + root = malloc(sizeof(*root)); + *root = (struct fat_res) { + .cdi = { + .name = "/", + .res = &fat_res_ops, + }, + .path = "/", + .dir_entry = { + .attrib = FAT_ATTRIB_DIR, + }, + }; + + /* Mount file system */ + fat_fs = malloc(sizeof(*fat_fs)); + fat_fs->dev_read = fat_data_read; + fat_fs->dev_write = fat_data_write; + fat_fs->dev_private = fs; + + if (!fat_fs_mount(fat_fs)) { + goto fail; + } + + /* Initialize fs structure */ + fs->root_res = &root->cdi; + fs->opaque = fat_fs; + + return 1; + +fail: + free(root); + free(fat_fs); + return 0; +} + +/** + * Dateisystem deinitialisieren + * + * @return Wenn das Dateisystem erfolgreich deinitialisiert wurde 1, 0 + * sonst. Falls ein Fehler auftritt, muss das error-Feld in der + * Dateisystemstruktur gesetzt werden. + */ +static int fat_fs_destroy(struct cdi_fs_filesystem* fs) +{ + return 1; +} + +static int fat_res_load_dir(struct fat_fs* fs, struct fat_res* res) +{ + struct fat_dir dir; + struct fat_dir_entry dentry; + struct fat_res* child; + int ret; + + res->cdi.children = cdi_list_create(); + + ret = fat_dir_open(fs, res->path, &dir); + if (ret < 0) { + goto fail; + } + + while(1) { + ret = fat_dir_read(&dir, &dentry); + if (ret < 0) { + break; + } + + child = calloc(1, sizeof(*child)); + child->cdi.res = &fat_res_ops; + child->cdi.name = strdup(dentry.name); + asprintf(&child->path, "%s/%s", res->path, dentry.name); + child->dir_entry = dentry; + + cdi_list_push(res->cdi.children, child); + } + + fat_dir_close(&dir); + + res->cdi.dir = &fat_dir_ops; + res->cdi.flags.browse = 1; + res->cdi.flags.create_child = 1; + + return 1; + +fail: + cdi_list_destroy(res->cdi.children); + return 0; +} + +static int fat_res_load_file(struct fat_fs* fs, struct fat_res* res) +{ + int ret; + + ret = fat_file_open_by_dir_entry(fs, &res->dir_entry, &res->file); + if (ret < 0) { + return 0; + } + + res->cdi.file = &fat_file_ops; + res->cdi.flags.read = 1; + res->cdi.flags.write = 1; + res->cdi.flags.execute = 1; + + return 1; +} + +/** + * Ressource laden + * + * @param stream Stream + * + * @return Falls die Ressource erfolgreich geladen wurde 1, sonst 0 + */ +static int fat_res_load(struct cdi_fs_stream* s) +{ + struct fat_res* res = (struct fat_res*) s->res; + int ret; + + if (res->dir_entry.attrib & FAT_ATTRIB_DIR) { + ret = fat_res_load_dir(s->fs->opaque, res); + } else { + ret = fat_res_load_file(s->fs->opaque, res); + } + + if (!ret) { + goto fail; + } + + s->res->loaded = 1; + + return 1; + +fail: + return 0; +} + +/** + * Metaeigenschaft lesen + * + * @param stream Stream + * @param meta Konstante fuer die gewuenschte Metaeigenschaft + * + * @return Wert der Metaeigenschaft + */ +static int64_t fat_res_meta_read(struct cdi_fs_stream* s, cdi_fs_meta_t meta) +{ + struct fat_res* res = (struct fat_res*) s->res; + struct fat_fs* fs = s->fs->opaque; + + switch (meta) { + case CDI_FS_META_SIZE: + return res->dir_entry.size; + + case CDI_FS_META_BLOCKSZ: + case CDI_FS_META_BESTBLOCKSZ: + return fs->bpb.sector_size * fs->bpb.cluster_sectors; + + default: + return -1; + } +} + +/** + * Diese Ressource einer neuen Klasse zuweisen. Diese Funktion wird nur + * aufgerufen, wenn die Ressource nicht bereits dieser Klasse zugewiesen + * ist. + * + * @param stream Stream + * @param class Konstante fuer den Typ der klasse, der die Ressource + * zugewiesen werden soll. + * + * @return 1 falls die Ressource erfolgreich der Klasse zugewiesen wurde, 0 + * sonst + */ +static int fat_res_assign_class(struct cdi_fs_stream* s, + cdi_fs_res_class_t class) +{ + struct fat_res* res = (struct fat_res*) s->res; + struct fat_res* parent_res = (struct fat_res*) res->cdi.parent; + int ret; + + /* Allow only one class */ + if (res->cdi.file || res->cdi.dir || res->cdi.link || res->cdi.special) { + s->error = CDI_FS_ERROR_ONS; + return 0; + } + + /* Create the dir entry */ + struct fat_dir dir; + + ret = fat_dir_open(s->fs->opaque, parent_res->path, &dir); + if (ret < 0) { + return 0; + } + + s->error = CDI_FS_ERROR_NONE; + switch (class) { + case CDI_FS_CLASS_FILE: + ret = fat_dir_create_entry(&dir, res->cdi.name, 0, + &res->dir_entry); + if (ret < 0) { + s->error = CDI_FS_ERROR_UNKNOWN; + goto out; + } + res->cdi.file = &fat_file_ops; + break; + + case CDI_FS_CLASS_DIR: + ret = fat_dir_create(&dir, res->cdi.name, &res->dir_entry); + if (ret < 0) { + s->error = CDI_FS_ERROR_UNKNOWN; + goto out; + } + res->cdi.dir = &fat_dir_ops; + break; + + default: + s->error = CDI_FS_ERROR_NOT_IMPLEMENTED; + goto out; + } + + if (!fat_res_load(s)) { + s->error = CDI_FS_ERROR_UNKNOWN; + } + +out: + fat_dir_close(&dir); + return s->error == CDI_FS_ERROR_NONE ? 1 : 0; +} + +/** + * Diese Funktion gibt einen Pointer auf die Liste mit den Eintraegen + * zurueck. Hier wird nicht einfach fix der Pointer in fs_res genommen, + * damit dort auch "versteckte" Eintraege vorhanden sein koennten. (Ich + * meine hier nicht irgend ein versteckt-Flag dass die Dateien vor dem + * Benutzer Verstecken soll, sondern eher von fuer den Internen gebrauch + * angelegten Eintraegen. + * Diese Liste muss nicht vom Aufrufer freigegeben werden, da einige + * Treiber hier direkt children aus fs_res benutzen, und andere dafuer eine + * eigene Liste erstellen, die sie intern abspeichern. + * + * @param stream Stream + * + * @return Pointer auf eine Liste mit den Untereintraegen vom Typ + * cdi_fs_res. + */ +static cdi_list_t fat_dir_list(struct cdi_fs_stream* s) +{ + return s->res->children; +} + +/** + * Neue Ressource in der Aktuellen erstellen. Diese wird erstmal noch + * keiner Klasse zugewiesen. Diese Funktion wird mit einem NULL-Pointer als + * Ressource im Stream aufgerufen. Dieser NULL-Pointer muss bei + * Erfolgreichem Beenden durch einen Pointer auf die neue Ressource ersetzt + * worden sein. + * + * @param stream Mit NULL-Pointer als Ressource + * @param name Name der neuen Ressource + * @param parent Ressource, der die neue Ressource als Kindressource + * zugeordnet werden soll. + * + * @return Falls die Ressource erfolgreich erstellt wurde 1, sonst 0 + */ +static int fat_dir_create_child(struct cdi_fs_stream* stream, + const char* name, struct cdi_fs_res* _parent) +{ + struct fat_res* parent = (struct fat_res*) _parent; + struct fat_res* res; + + res = malloc(sizeof(*res)); + *res = (struct fat_res) { + .cdi = { + .name = strdup(name), + .res = &fat_res_ops, + .parent = &parent->cdi, + .loaded = 1, + }, + }; + + asprintf(&res->path, "%s/%s", parent->path, name); + + stream->res = &res->cdi; + return 1; +} + +/** + * Daten aus dieser Datei lesen. Wird nur aufgerufen, wenn es durch die + * Flags oder Berechtigungen nicht verhindert wird. + * + * Im Fehlerfall wird je nach Fehler die Fehlernummer im Handle und die im + * Device gesetzt. + * + * @param stream Stream + * @param start Position von der an gelesen werden soll + * @param size Groesse der zu lesenden Daten + * @param buffer Puffer in den die Daten gelsen werden sollen + * + * @return Gelesene Bytes, oder 0 im Fehlerfall + */ +static size_t fat_file_op_read(struct cdi_fs_stream* s, uint64_t start, + size_t size, void* buffer) +{ + struct fat_res* res = (struct fat_res*) s->res; + int32_t ret; + + ret = fat_file_read(&res->file, buffer, start, size); + if (ret < 0) { + /* TODO Set error */ + return 0; + } else { + return size; + } +} + +/** + * Daten in diese Datei schreiben. Wird nur aufgerufen, wenn es durch die + * Flags oder Berechtigungen nicht verhindert wird. + * + * Im Fehlerfall wird je nach Fehler die Fehlernummer im Handle und die im + * Device gesetzt. + * + * @param stream Stream + * @param start Position an die geschrieben werden soll + * @param size Groesse der zu schreibenden Daten + * @param buffer Puffer aus dem die Daten gelesen werden sollen + * + * @return Geschriebene Bytes oder 0 im Fehlerfall + */ +static size_t fat_file_op_write(struct cdi_fs_stream* s, uint64_t start, + size_t size, const void* buffer) +{ + struct fat_res* res = (struct fat_res*) s->res; + int32_t ret; + + ret = fat_file_write(&res->file, buffer, start, size); + if (ret < 0) { + /* TODO Set error */ + return 0; + } else { + return size; + } +} + +/** + * Groesse der Datei anpassen. Diese Funktion kann sowohl fuers + * Vergroessern, als auch fuers Verkleinern benutzt werden. + * + * Im Fehlerfall wird je nach Fehler die Fehlernummer im Handle und die im + * Device gesetzt. + * + * @param stream Stream + * @param size Neue Groesse der Datei + * + * @return 1 bei Erfolg, im Fehlerfall 0 + */ +static int fat_file_op_truncate(struct cdi_fs_stream* s, uint64_t size) +{ + /* TODO */ + return 1; +} + +static struct cdi_fs_driver fat_driver = { + .drv = { + .type = CDI_FILESYSTEM, + .name = DRIVER_NAME, + .init = fat_driver_init, + .destroy = fat_driver_destroy, + }, + .fs_init = fat_fs_init, + .fs_destroy = fat_fs_destroy, +}; + +CDI_DRIVER(DRIVER_NAME, fat_driver) -- 1.6.0.2