Changeset ed903174 in mainline for uspace/app

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/app

Files:

• bdsh/cmds/modules/bdd/bdd.c (modified) (1 diff)
• bdsh/cmds/modules/cat/cat.c (modified) (1 diff)
• bdsh/cmds/modules/cp/cp.c (modified) (1 diff)
• mkfat/mkfat.c (modified) (3 diffs)
• taskdump/elf_core.c (modified) (5 diffs)
• taskdump/include/elf_core.h (modified) (1 diff)
• taskdump/symtab.c (modified) (4 diffs)

uspace/app/bdsh/cmds/modules/bdd/bdd.c

@@ -73 +73 @@
         size_t block_size;
         int rc;
-        bn_t ba;
+        aoff64_t ba;
         uint8_t b;
 

uspace/app/bdsh/cmds/modules/cat/cat.c

@@ -85 +85 @@
 {
         int fd, bytes = 0, count = 0, reads = 0;
-        off_t total = 0;
+        off64_t total = 0;
         char *buff = NULL;
 

uspace/app/bdsh/cmds/modules/cp/cp.c

@@ -74 +74 @@
 {
         int fd1, fd2, bytes = 0;
-        off_t total = 0;
+        off64_t total = 0;
         int64_t copied = 0;
         char *buff = NULL;

uspace/app/mkfat/mkfat.c

@@ -98 +98 @@
         size_t block_size;
         char *endptr;
-        bn_t dev_nblocks;
+        aoff64_t dev_nblocks;
 
         cfg.total_sectors = 0;
@@ -160 +160 @@
                 printf(NAME ": Warning, failed to obtain block device size.\n");
         } else {
-                printf(NAME ": Block device has %" PRIuBN " blocks.\n",
+                printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
                     dev_nblocks);
                 cfg.total_sectors = dev_nblocks;
@@ -236 +236 @@
 static int fat_blocks_write(struct fat_params const *par, dev_handle_t handle)
 {
-        bn_t addr;
+        aoff64_t addr;
         uint8_t *buffer;
         int i;

uspace/app/taskdump/elf_core.c

@@ -62 +62 @@
 #include "include/elf_core.h"
 
-static off_t align_foff_up(off_t foff, uintptr_t vaddr, size_t page_size);
+static off64_t align_foff_up(off64_t foff, uintptr_t vaddr, size_t page_size);
 static int write_all(int fd, void *data, size_t len);
 static int write_mem_area(int fd, as_area_info_t *area, int phoneid);
@@ -79 +79 @@
  *                      ENOMEM on out of memory, EIO on write error.
  */
-int elf_core_save(const char *file_name, as_area_info_t *ainfo, int n, int phoneid)
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid)
 {
         elf_header_t elf_hdr;
-        off_t foff;
+        off64_t foff;
         size_t n_ph;
         elf_word flags;
@@ -89 +89 @@
         int fd;
         int rc;
-        int i;
+        unsigned int i;
 
         n_ph = n;
@@ -184 +184 @@
 
         for (i = 0; i < n_ph; ++i) {
-                if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off_t) -1) {
+                if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off64_t) -1) {
                         printf("Failed writing memory data.\n");
                         free(p_hdr);
@@ -202 +202 @@
 
 /** Align file offset up to be congruent with vaddr modulo page size. */
-static off_t align_foff_up(off_t foff, uintptr_t vaddr, size_t page_size)
-{
-        off_t rfo, rva;
-        off_t advance;
-
-        rva = vaddr % page_size;
-        rfo = foff % page_size;
-
-        advance = (rva >= rfo) ? rva - rfo : (page_size + rva - rfo);
-        return foff + advance;
+static off64_t align_foff_up(off64_t foff, uintptr_t vaddr, size_t page_size)
+{
+        off64_t rva = vaddr % page_size;
+        off64_t rfo = foff % page_size;
+        
+        if (rva >= rfo)
+                return (foff + (rva - rfo));
+        
+        return (foff + (page_size + (rva - rfo)));
 }
 

uspace/app/taskdump/include/elf_core.h

@@ -36 +36 @@
 #define ELF_CORE_H_
 
-int elf_core_save(const char *file_name, as_area_info_t *ainfo, int n, int phoneid);
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid);
 
 #endif

uspace/app/taskdump/symtab.c

@@ -49 +49 @@
 static int section_hdr_load(int fd, const elf_header_t *ehdr, int idx,
     elf_section_header_t *shdr);
-static int chunk_load(int fd, off_t start, off_t size, void **ptr);
+static int chunk_load(int fd, off64_t start, size_t size, void **ptr);
 static int read_all(int fd, void *buf, size_t len);
 
@@ -65 +65 @@
         elf_header_t elf_hdr;
         elf_section_header_t sec_hdr;
-        off_t shstrt_start, shstrt_size;
+        off64_t shstrt_start;
+        size_t shstrt_size;
         char *shstrt, *sec_name;
         void *data;
@@ -307 +308 @@
         rc = lseek(fd, elf_hdr->e_shoff + idx * sizeof(elf_section_header_t),
             SEEK_SET);
-        if (rc == (off_t) -1)
+        if (rc == (off64_t) -1)
                 return EIO;
 
@@ -328 +329 @@
  * @return              EOK on success or EIO on failure.
  */
-static int chunk_load(int fd, off_t start, off_t size, void **ptr)
+static int chunk_load(int fd, off64_t start, size_t size, void **ptr)
 {
         int rc;
 
         rc = lseek(fd, start, SEEK_SET);
-        if (rc == (off_t) -1) {
+        if (rc == (off64_t) -1) {
                 printf("failed seeking chunk\n");
                 *ptr = NULL;