Changeset ed903174 in mainline for uspace/srv/fs/fat

Timestamp:

2010-02-10T23:51:23Z (16 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e70edd1

Parents:

b32c604f

Message:

implement support for 64bit file offsets

• the libc API is a small deviation from standard, but we have no reason to keep a strict backward compatibility with ancient code so far
  • the basic signed 64bit offset type is called off64_t
    • lseek() and fseek() take off64_t arguments (since the argument represents a relative offset)
    • ftell() returns off64_t values (since it is a wrapper of lseek())
    • vfs_seek() implementation supports negative offsets when SEEK_CUR and SEEK_END is used
  • aoff64_t is used for internal unsigned representation of sizes (in bytes, blocks, etc.) and absolute offsets
    • mmap() and ftruncate() take aoff64_t arguments (since the full range of the absolute file offset should be used here)
    • struct stat stores the file size as aoff64_t
  • in both cases the explicit range of the types shown in the names is helpful for proper filesystem and IPC interaction
  • note: size_t should be used only for representing in-memory sizes and offsets, not device and file-related information, and vice versa
    • the code base still needs a thorough revision with respect to this rule
  • PRIdOFF64 and PRIuOFF64 can be used for printing the offsets
• VFS_OUT_LOOKUP returns the 64bit file size in two IPC arguments
  • since all 5 IPC arguments have already been taken, the fs_handle is returned as the return value (fs_handle has only 16 bits, thus the return value can be used for both indicating errors as negative values and returning positive handles)
• VFS_OUT_READ and VFS_OUT_WRITE use aoff64_t absolute offsets split into two IPC arguments

replace bn_t with aoff64_t as a generic 64bit bytes/block counter type

note: filesystem drivers need to be revised with respect to make sure that all out-of-range checks are correct (especially w.r.t. file and block offsets)

Location:

uspace/srv/fs/fat

Files:

• fat.h (modified) (3 diffs)
• fat_dentry.c (modified) (1 diff)
• fat_fat.c (modified) (3 diffs)
• fat_fat.h (modified) (2 diffs)
• fat_ops.c (modified) (11 diffs)

uspace/srv/fs/fat/fat.h

@@ -89 +89 @@
                         uint16_t        signature;
                 } __attribute__ ((packed));
-                struct fat32 {
+                struct {
                         /* FAT32 only */
                         /** Sectors per FAT. */
@@ -119 +119 @@
                         /** Signature. */
                         uint16_t        signature;
-                } __attribute__ ((packed));
-        }; 
+                } fat32 __attribute__ ((packed));
+        };
 } __attribute__ ((packed)) fat_bs_t;
 
@@ -194 +194 @@
         /** FAT in-core node free list link. */
         link_t                  ffn_link;
-        size_t                  size;
+        aoff64_t                size;
         unsigned                lnkcnt;
         unsigned                refcnt;

uspace/srv/fs/fat/fat_dentry.c

@@ -82 +82 @@
 bool fat_dentry_name_verify(const char *name)
 {
-        unsigned i, dot;
+        unsigned int i;
+        unsigned int dot = 0;
         bool dot_found = false;
         

uspace/srv/fs/fat/fat_fat.c

@@ -93 +93 @@
 
         while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
-                bn_t fsec;      /* sector offset relative to FAT1 */
+                aoff64_t fsec;  /* sector offset relative to FAT1 */
                 unsigned fidx;  /* FAT1 entry index */
 
@@ -135 +135 @@
 int
 _fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
-    fat_cluster_t firstc, bn_t bn, int flags)
+    fat_cluster_t firstc, aoff64_t bn, int flags)
 {
         unsigned bps;
@@ -196 +196 @@
  * @return              EOK on success or a negative error code.
  */
-int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
+int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
 {
         uint16_t bps;
         unsigned spc;
         block_t *b;
-        off_t o, boundary;
+        aoff64_t o, boundary;
         int rc;
 

uspace/srv/fs/fat/fat_fat.h

@@ -69 +69 @@
 
 extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
-    fat_cluster_t, bn_t, int);
-  
+    fat_cluster_t, aoff64_t, int);
+
 extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
     fat_cluster_t);
@@ -85 +85 @@
     fat_cluster_t, fat_cluster_t);
 extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
-    off_t);
+    aoff64_t);
 extern int fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
 extern int fat_sanity_check(struct fat_bs *, dev_handle_t);

uspace/srv/fs/fat/fat_ops.c

@@ -45 +45 @@
 #include <ipc/services.h>
 #include <ipc/devmap.h>
+#include <macros.h>
 #include <async.h>
 #include <errno.h>
@@ -79 +80 @@
 static int fat_has_children(bool *, fs_node_t *);
 static fs_index_t fat_index_get(fs_node_t *);
-static size_t fat_size_get(fs_node_t *);
+static aoff64_t fat_size_get(fs_node_t *);
 static unsigned fat_lnkcnt_get(fs_node_t *);
 static char fat_plb_get_char(unsigned);
@@ -738 +739 @@
                         goto skip_dots;
                 }
-                d = (fat_dentry_t *)b->data;
-                if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-                    str_cmp(d->name, FAT_NAME_DOT) == 0) {
+                d = (fat_dentry_t *) b->data;
+                if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
+                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
                         memset(d, 0, sizeof(fat_dentry_t));
-                        str_cpy(d->name, 8, FAT_NAME_DOT);
-                        str_cpy(d->ext, 3, FAT_EXT_PAD);
+                        str_cpy((char *) d->name, 8, FAT_NAME_DOT);
+                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
                         d->attr = FAT_ATTR_SUBDIR;
                         d->firstc = host2uint16_t_le(childp->firstc);
@@ -749 +750 @@
                 }
                 d++;
-                if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-                    str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
+                if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
+                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
                         memset(d, 0, sizeof(fat_dentry_t));
-                        str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
-                        str_cpy(d->ext, 3, FAT_EXT_PAD);
+                        str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
+                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
                         d->attr = FAT_ATTR_SUBDIR;
                         d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
@@ -915 +916 @@
 }
 
-size_t fat_size_get(fs_node_t *fn)
+aoff64_t fat_size_get(fs_node_t *fn)
 {
         return FAT_NODE(fn)->size;
@@ -1157 +1158 @@
 void fat_read(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        off_t pos = (off_t)IPC_GET_ARG3(*request);
+        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t pos =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;
@@ -1223 +1225 @@
         } else {
                 unsigned bnum;
-                off_t spos = pos;
+                aoff64_t spos = pos;
                 char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
                 fat_dentry_t *d;
@@ -1239 +1241 @@
                 bnum = (pos * sizeof(fat_dentry_t)) / bps;
                 while (bnum < nodep->size / bps) {
-                        off_t o;
+                        aoff64_t o;
 
                         rc = fat_block_get(&b, bs, nodep, bnum,
@@ -1295 +1297 @@
 void fat_write(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        off_t pos = (off_t)IPC_GET_ARG3(*request);
+        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t pos =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;
@@ -1306 +1309 @@
         unsigned spc;
         unsigned bpc;           /* bytes per cluster */
-        off_t boundary;
+        aoff64_t boundary;
         int flags = BLOCK_FLAGS_NONE;
         int rc;
@@ -1452 +1455 @@
 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        size_t size = (off_t)IPC_GET_ARG3(*request);
+        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t size =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;