firmware/common/file.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Björn Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <stdbool.h>
  24 #include "file.h"
  25 #include "fat.h"
  26 #include "dir_uncached.h"
  27 #include "debug.h"
  28 #include "dircache.h"
  29 #include "filefuncs.h"
  30 #include "system.h"
  31
  32 /*
  33   These functions provide a roughly POSIX-compatible file IO API.
  34
  35   Since the fat32 driver only manages sectors, we maintain a one-sector
  36   cache for each open file. This way we can provide byte access without
  37   having to re-read the sector each time.
  38   The penalty is the RAM used for the cache and slightly more complex code.
  39 */
  40
  41 struct filedesc {
  42     unsigned char cache[SECTOR_SIZE] CACHEALIGN_ATTR;
  43     int cacheoffset; /* invariant: 0 <= cacheoffset <= SECTOR_SIZE */
  44     long fileoffset;
  45     long size;
  46     int attr;
  47     struct fat_file fatfile;
  48     bool busy;
  49     bool write;
  50     bool dirty;
  51     bool trunc;
  52 } CACHEALIGN_ATTR;
  53
  54 static struct filedesc openfiles[MAX_OPEN_FILES] CACHEALIGN_ATTR;
  55
  56 static int flush_cache(int fd);
  57
  58 int file_creat(const char *pathname)
  59 {
  60     return open(pathname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
  61 }
  62
  63 static int open_internal(const char* pathname, int flags, bool use_cache)
  64 {
  65     DIR_UNCACHED* dir;
  66     struct dirent_uncached* entry;
  67     int fd;
  68     int pathnamesize = strlen(pathname) + 1;
  69     char pathnamecopy[pathnamesize];
  70     char* name;
  71     struct filedesc* file = NULL;
  72     int rc;
  73 #ifndef HAVE_DIRCACHE
  74     (void)use_cache;
  75 #endif
  76
  77     LDEBUGF("open(\"%s\",%d)\n",pathname,flags);
  78
  79     if ( pathname[0] != '/' ) {
  80         DEBUGF("'%s' is not an absolute path.\n",pathname);
  81         DEBUGF("Only absolute pathnames supported at the moment\n");
  82         errno = EINVAL;
  83         return -1;
  84     }
  85
  86     /* find a free file descriptor */
  87     for ( fd=0; fd<MAX_OPEN_FILES; fd++ )
  88         if ( !openfiles[fd].busy )
  89             break;
  90
  91     if ( fd == MAX_OPEN_FILES ) {
  92         DEBUGF("Too many files open\n");
  93         errno = EMFILE;
  94         return -2;
  95     }
  96
  97     file = &openfiles[fd];
  98     memset(file, 0, sizeof(struct filedesc));
  99
 100     if (flags & (O_RDWR | O_WRONLY)) {
 101         file->write = true;
 102
 103         if (flags & O_TRUNC)
 104             file->trunc = true;
 105     }
 106     file->busy = true;
 107
 108 #ifdef HAVE_DIRCACHE
 109     if (dircache_is_enabled() && !file->write && use_cache)
 110     {
 111         const struct dircache_entry *ce;
 112 # ifdef HAVE_MULTIVOLUME
 113         int volume = strip_volume(pathname, pathnamecopy);
 114 # endif
 115
 116         ce = dircache_get_entry_ptr(pathname);
 117         if (!ce)
 118         {
 119             errno = ENOENT;
 120             file->busy = false;
 121             return -7;
 122         }
 123
 124         fat_open(IF_MV2(volume,)
 125                  ce->startcluster,
 126                  &(file->fatfile),
 127                  NULL);
 128         file->size = ce->info.size;
 129         file->attr = ce->info.attribute;
 130         file->cacheoffset = -1;
 131         file->fileoffset = 0;
 132
 133         return fd;
 134     }
 135 #endif
 136
 137     strlcpy(pathnamecopy, pathname, pathnamesize);
 138
 139     /* locate filename */
 140     name=strrchr(pathnamecopy+1,'/');
 141     if ( name ) {
 142         *name = 0;
 143         dir = opendir_uncached(pathnamecopy);
 144         *name = '/';
 145         name++;
 146     }
 147     else {
 148         dir = opendir_uncached("/");
 149         name = pathnamecopy+1;
 150     }
 151     if (!dir) {
 152         DEBUGF("Failed opening dir\n");
 153         errno = EIO;
 154         file->busy = false;
 155         return -4;
 156     }
 157
 158     if(name[0] == 0) {
 159         DEBUGF("Empty file name\n");
 160         errno = EINVAL;
 161         file->busy = false;
 162         closedir_uncached(dir);
 163         return -5;
 164     }
 165
 166     /* scan dir for name */
 167     while ((entry = readdir_uncached(dir))) {
 168         if ( !strcasecmp(name, entry->d_name) ) {
 169             fat_open(IF_MV2(dir->fatdir.file.volume,)
 170                      entry->startcluster,
 171                      &(file->fatfile),
 172                      &(dir->fatdir));
 173             file->size = file->trunc ? 0 : entry->info.size;
 174             file->attr = entry->info.attribute;
 175             break;
 176         }
 177     }
 178
 179     if ( !entry ) {
 180         LDEBUGF("Didn't find file %s\n",name);
 181         if ( file->write && (flags & O_CREAT) ) {
 182             rc = fat_create_file(name,
 183                                  &(file->fatfile),
 184                                  &(dir->fatdir));
 185             if (rc < 0) {
 186                 DEBUGF("Couldn't create %s in %s\n",name,pathnamecopy);
 187                 errno = EIO;
 188                 file->busy = false;
 189                 closedir_uncached(dir);
 190                 return rc * 10 - 6;
 191             }
 192 #ifdef HAVE_DIRCACHE
 193             dircache_add_file(pathname, file->fatfile.firstcluster);
 194 #endif
 195             file->size = 0;
 196             file->attr = 0;
 197         }
 198         else {
 199             DEBUGF("Couldn't find %s in %s\n",name,pathnamecopy);
 200             errno = ENOENT;
 201             file->busy = false;
 202             closedir_uncached(dir);
 203             return -7;
 204         }
 205     } else {
 206         if(file->write && (file->attr & FAT_ATTR_DIRECTORY)) {
 207             errno = EISDIR;
 208             file->busy = false;
 209             closedir_uncached(dir);
 210             return -8;
 211         }
 212     }
 213     closedir_uncached(dir);
 214
 215     file->cacheoffset = -1;
 216     file->fileoffset = 0;
 217
 218     if (file->write && (flags & O_APPEND)) {
 219         rc = lseek(fd,0,SEEK_END);
 220         if (rc < 0 )
 221             return rc * 10 - 9;
 222     }
 223
 224 #ifdef HAVE_DIRCACHE
 225     if (file->write)
 226         dircache_bind(fd, pathname);
 227 #endif
 228
 229     return fd;
 230 }
 231
 232 int file_open(const char* pathname, int flags)
 233 {
 234     /* By default, use the dircache if available. */
 235     return open_internal(pathname, flags, true);
 236 }
 237
 238 int close(int fd)
 239 {
 240     struct filedesc* file = &openfiles[fd];
 241     int rc = 0;
 242
 243     LDEBUGF("close(%d)\n", fd);
 244
 245     if (fd < 0 || fd > MAX_OPEN_FILES-1) {
 246         errno = EINVAL;
 247         return -1;
 248     }
 249     if (!file->busy) {
 250         errno = EBADF;
 251         return -2;
 252     }
 253     if (file->write) {
 254         rc = fsync(fd);
 255         if (rc < 0)
 256             return rc * 10 - 3;
 257 #ifdef HAVE_DIRCACHE
 258         dircache_update_filesize(fd, file->size, file->fatfile.firstcluster);
 259         dircache_update_filetime(fd);
 260 #endif
 261     }
 262
 263     file->busy = false;
 264     return 0;
 265 }
 266
 267 int fsync(int fd)
 268 {
 269     struct filedesc* file = &openfiles[fd];
 270     int rc = 0;
 271
 272     LDEBUGF("fsync(%d)\n", fd);
 273
 274     if (fd < 0 || fd > MAX_OPEN_FILES-1) {
 275         errno = EINVAL;
 276         return -1;
 277     }
 278     if (!file->busy) {
 279         errno = EBADF;
 280         return -2;
 281     }
 282     if (file->write) {
 283         /* flush sector cache */
 284         if ( file->dirty ) {
 285             rc = flush_cache(fd);
 286             if (rc < 0)
 287             {
 288                 /* when failing, try to close the file anyway */
 289                 fat_closewrite(&(file->fatfile), file->size, file->attr);
 290                 return rc * 10 - 3;
 291             }
 292         }
 293
 294         /* truncate? */
 295         if (file->trunc) {
 296             rc = ftruncate(fd, file->size);
 297             if (rc < 0)
 298             {
 299                 /* when failing, try to close the file anyway */
 300                 fat_closewrite(&(file->fatfile), file->size, file->attr);
 301                 return rc * 10 - 4;
 302             }
 303         }
 304
 305         /* tie up all loose ends */
 306         rc = fat_closewrite(&(file->fatfile), file->size, file->attr);
 307         if (rc < 0)
 308             return rc * 10 - 5;
 309     }
 310     return 0;
 311 }
 312
 313 int remove(const char* name)
 314 {
 315     int rc;
 316     struct filedesc* file;
 317     /* Can't use dircache now, because we need to access the fat structures. */
 318     int fd = open_internal(name, O_WRONLY, false);
 319     if ( fd < 0 )
 320         return fd * 10 - 1;
 321
 322     file = &openfiles[fd];
 323 #ifdef HAVE_DIRCACHE
 324     dircache_remove(name);
 325 #endif
 326     rc = fat_remove(&(file->fatfile));
 327     if ( rc < 0 ) {
 328         DEBUGF("Failed removing file: %d\n", rc);
 329         errno = EIO;
 330         return rc * 10 - 3;
 331     }
 332
 333     file->size = 0;
 334
 335     rc = close(fd);
 336     if (rc<0)
 337         return rc * 10 - 4;
 338
 339     return 0;
 340 }
 341
 342 int rename(const char* path, const char* newpath)
 343 {
 344     int rc, fd;
 345     DIR_UNCACHED* dir;
 346     char* nameptr;
 347     char* dirptr;
 348     struct filedesc* file;
 349     char newpath2[MAX_PATH];
 350
 351     /* verify new path does not already exist */
 352     /* If it is a directory, errno == EISDIR if the name exists */
 353     fd = open(newpath, O_RDONLY);
 354     if ( fd >= 0 || errno == EISDIR) {
 355         close(fd);
 356         errno = EBUSY;
 357         return -1;
 358     }
 359     close(fd);
 360
 361     fd = open_internal(path, O_RDONLY, false);
 362     if ( fd < 0 ) {
 363         errno = EIO;
 364         return fd * 10 - 2;
 365     }
 366
 367     /* extract new file name */
 368     nameptr = strrchr(newpath,'/');
 369     if (nameptr)
 370         nameptr++;
 371     else {
 372         close(fd);
 373         return - 3;
 374     }
 375
 376     /* Extract new path */
 377     strcpy(newpath2, newpath);
 378
 379     dirptr = strrchr(newpath2,'/');
 380     if(dirptr)
 381         *dirptr = 0;
 382     else {
 383         close(fd);
 384         return - 4;
 385     }
 386
 387     dirptr = newpath2;
 388
 389     if(strlen(dirptr) == 0) {
 390         dirptr = "/";
 391     }
 392
 393     dir = opendir_uncached(dirptr);
 394     if(!dir) {
 395         close(fd);
 396         return - 5;
 397     }
 398
 399     file = &openfiles[fd];
 400
 401     rc = fat_rename(&file->fatfile, &dir->fatdir, nameptr,
 402                     file->size, file->attr);
 403 #ifdef HAVE_MULTIVOLUME
 404     if ( rc == -1) {
 405         close(fd);
 406         closedir_uncached(dir);
 407         DEBUGF("Failed renaming file across volumnes: %d\n", rc);
 408         errno = EXDEV;
 409         return -6;
 410     }
 411 #endif
 412     if ( rc < 0 ) {
 413         close(fd);
 414         closedir_uncached(dir);
 415         DEBUGF("Failed renaming file: %d\n", rc);
 416         errno = EIO;
 417         return rc * 10 - 7;
 418     }
 419
 420 #ifdef HAVE_DIRCACHE
 421     dircache_rename(path, newpath);
 422 #endif
 423
 424     rc = close(fd);
 425     if (rc<0) {
 426         closedir_uncached(dir);
 427         errno = EIO;
 428         return rc * 10 - 8;
 429     }
 430
 431     rc = closedir_uncached(dir);
 432     if (rc<0) {
 433         errno = EIO;
 434         return rc * 10 - 9;
 435     }
 436
 437     return 0;
 438 }
 439
 440 int ftruncate(int fd, off_t size)
 441 {
 442     int rc, sector;
 443     struct filedesc* file = &openfiles[fd];
 444
 445     sector = size / SECTOR_SIZE;
 446     if (size % SECTOR_SIZE)
 447         sector++;
 448
 449     rc = fat_seek(&(file->fatfile), sector);
 450     if (rc < 0) {
 451         errno = EIO;
 452         return rc * 10 - 1;
 453     }
 454
 455     rc = fat_truncate(&(file->fatfile));
 456     if (rc < 0) {
 457         errno = EIO;
 458         return rc * 10 - 2;
 459     }
 460
 461     file->size = size;
 462 #ifdef HAVE_DIRCACHE
 463     dircache_update_filesize(fd, size, file->fatfile.firstcluster);
 464 #endif
 465
 466     return 0;
 467 }
 468
 469 static int flush_cache(int fd)
 470 {
 471     int rc;
 472     struct filedesc* file = &openfiles[fd];
 473     long sector = file->fileoffset / SECTOR_SIZE;
 474
 475     DEBUGF("Flushing dirty sector cache\n");
 476
 477     /* make sure we are on correct sector */
 478     rc = fat_seek(&(file->fatfile), sector);
 479     if ( rc < 0 )
 480         return rc * 10 - 3;
 481
 482     rc = fat_readwrite(&(file->fatfile), 1, file->cache, true );
 483
 484     if ( rc < 0 ) {
 485         if(file->fatfile.eof)
 486             errno = ENOSPC;
 487
 488         return rc * 10 - 2;
 489     }
 490
 491     file->dirty = false;
 492
 493     return 0;
 494 }
 495
 496 static int readwrite(int fd, void* buf, long count, bool write)
 497 {
 498     long sectors;
 499     long nread=0;
 500     struct filedesc* file;
 501     int rc;
 502 #ifdef STORAGE_NEEDS_ALIGN
 503     long i;
 504     int rc2;
 505 #endif
 506
 507     if (fd < 0 || fd > MAX_OPEN_FILES-1) {
 508         errno = EINVAL;
 509         return -1;
 510     }
 511
 512     file = &openfiles[fd];
 513
 514     if ( !file->busy ) {
 515         errno = EBADF;
 516         return -1;
 517     }
 518
 519     if(file->attr & FAT_ATTR_DIRECTORY) {
 520         errno = EISDIR;
 521         return -1;
 522     }
 523
 524     LDEBUGF( "readwrite(%d,%lx,%ld,%s)\n",
 525              fd,(long)buf,count,write?"write":"read");
 526
 527     /* attempt to read past EOF? */
 528     if (!write && count > file->size - file->fileoffset)
 529         count = file->size - file->fileoffset;
 530
 531     /* any head bytes? */
 532     if ( file->cacheoffset != -1 ) {
 533         int offs = file->cacheoffset;
 534         int headbytes = MIN(count, SECTOR_SIZE - offs);
 535
 536         if (write) {
 537             memcpy( file->cache + offs, buf, headbytes );
 538             file->dirty = true;
 539         }
 540         else {
 541             memcpy( buf, file->cache + offs, headbytes );
 542         }
 543
 544         if (offs + headbytes == SECTOR_SIZE) {
 545             if (file->dirty) {
 546                 rc = flush_cache(fd);
 547                 if ( rc < 0 ) {
 548                     errno = EIO;
 549                     return rc * 10 - 2;
 550                 }
 551             }
 552             file->cacheoffset = -1;
 553         }
 554         else {
 555             file->cacheoffset += headbytes;
 556         }
 557
 558         nread = headbytes;
 559         count -= headbytes;
 560     }
 561
 562     /* If the buffer has been modified, either it has been flushed already
 563      * (if (offs+headbytes == SECTOR_SIZE)...) or does not need to be (no
 564      * more data to follow in this call). Do NOT flush here. */
 565
 566     /* read/write whole sectors right into/from the supplied buffer */
 567     sectors = count / SECTOR_SIZE;
 568     rc = 0;
 569     if ( sectors ) {
 570 #ifdef STORAGE_NEEDS_ALIGN
 571         if (((uint32_t)buf + nread) & (CACHEALIGN_SIZE - 1))
 572             for (i = 0; i < sectors; i++)
 573             {
 574                 if (write) memcpy(file->cache, buf+nread+i*SECTOR_SIZE, SECTOR_SIZE);
 575                 rc2 = fat_readwrite(&(file->fatfile), 1, file->cache, write );
 576                 if (rc2 < 0)
 577                 {
 578                     rc = rc2;
 579                     break;
 580                 }
 581                 else rc += rc2;
 582                 if (!write) memcpy(buf+nread+i*SECTOR_SIZE, file->cache, SECTOR_SIZE);
 583             }
 584         else
 585 #endif
 586             rc = fat_readwrite(&(file->fatfile), sectors, (unsigned char*)buf+nread, write );
 587         if ( rc < 0 ) {
 588             DEBUGF("Failed read/writing %ld sectors\n",sectors);
 589             errno = EIO;
 590             if(write && file->fatfile.eof) {
 591                 DEBUGF("No space left on device\n");
 592                 errno = ENOSPC;
 593             } else {
 594                 file->fileoffset += nread;
 595             }
 596             file->cacheoffset = -1;
 597             /* adjust file size to length written */
 598             if ( write && file->fileoffset > file->size )
 599             {
 600                 file->size = file->fileoffset;
 601 #ifdef HAVE_DIRCACHE
 602                 dircache_update_filesize(fd, file->size, file->fatfile.firstcluster);
 603 #endif
 604             }
 605             return nread ? nread : rc * 10 - 4;
 606         }
 607         else {
 608             if ( rc > 0 ) {
 609                 nread += rc * SECTOR_SIZE;
 610                 count -= sectors * SECTOR_SIZE;
 611
 612                 /* if eof, skip tail bytes */
 613                 if ( rc < sectors )
 614                     count = 0;
 615             }
 616             else {
 617                 /* eof */
 618                 count=0;
 619             }
 620
 621             file->cacheoffset = -1;
 622         }
 623     }
 624
 625     /* any tail bytes? */
 626     if ( count ) {
 627         if (write) {
 628             if ( file->fileoffset + nread < file->size ) {
 629                 /* sector is only partially filled. copy-back from disk */
 630                 LDEBUGF("Copy-back tail cache\n");
 631                 rc = fat_readwrite(&(file->fatfile), 1, file->cache, false );
 632                 if ( rc < 0 ) {
 633                     DEBUGF("Failed writing\n");
 634                     errno = EIO;
 635                     file->fileoffset += nread;
 636                     file->cacheoffset = -1;
 637                     /* adjust file size to length written */
 638                     if ( file->fileoffset > file->size )
 639                     {
 640                         file->size = file->fileoffset;
 641 #ifdef HAVE_DIRCACHE
 642                         dircache_update_filesize(fd, file->size, file->fatfile.firstcluster);
 643 #endif
 644                     }
 645                     return nread ? nread : rc * 10 - 5;
 646                 }
 647                 /* seek back one sector to put file position right */
 648                 rc = fat_seek(&(file->fatfile),
 649                               (file->fileoffset + nread) /
 650                               SECTOR_SIZE);
 651                 if ( rc < 0 ) {
 652                     DEBUGF("fat_seek() failed\n");
 653                     errno = EIO;
 654                     file->fileoffset += nread;
 655                     file->cacheoffset = -1;
 656                     /* adjust file size to length written */
 657                     if ( file->fileoffset > file->size )
 658                     {
 659                         file->size = file->fileoffset;
 660 #ifdef HAVE_DIRCACHE
 661                         dircache_update_filesize(fd, file->size, file->fatfile.firstcluster);
 662 #endif
 663                     }
 664                     return nread ? nread : rc * 10 - 6;
 665                 }
 666             }
 667             memcpy( file->cache, (unsigned char*)buf + nread, count );
 668             file->dirty = true;
 669         }
 670         else {
 671             rc = fat_readwrite(&(file->fatfile), 1, file->cache,false);
 672             if (rc < 1 ) {
 673                 DEBUGF("Failed caching sector\n");
 674                 errno = EIO;
 675                 file->fileoffset += nread;
 676                 file->cacheoffset = -1;
 677                 return nread ? nread : rc * 10 - 7;
 678             }
 679             memcpy( (unsigned char*)buf + nread, file->cache, count );
 680         }
 681
 682         nread += count;
 683         file->cacheoffset = count;
 684     }
 685
 686     file->fileoffset += nread;
 687     LDEBUGF("fileoffset: %ld\n", file->fileoffset);
 688
 689     /* adjust file size to length written */
 690     if ( write && file->fileoffset > file->size )
 691     {
 692         file->size = file->fileoffset;
 693 #ifdef HAVE_DIRCACHE
 694         dircache_update_filesize(fd, file->size, file->fatfile.firstcluster);
 695 #endif
 696     }
 697
 698     return nread;
 699 }
 700
 701 ssize_t write(int fd, const void* buf, size_t count)
 702 {
 703     if (!openfiles[fd].write) {
 704         errno = EACCES;
 705         return -1;
 706     }
 707     return readwrite(fd, (void *)buf, count, true);
 708 }
 709
 710 ssize_t read(int fd, void* buf, size_t count)
 711 {
 712     return readwrite(fd, buf, count, false);
 713 }
 714
 715
 716 off_t lseek(int fd, off_t offset, int whence)
 717 {
 718     off_t pos;
 719     long newsector;
 720     long oldsector;
 721     int sectoroffset;
 722     int rc;
 723     struct filedesc* file = &openfiles[fd];
 724
 725     LDEBUGF("lseek(%d,%ld,%d)\n",fd,offset,whence);
 726
 727     if (fd < 0 || fd > MAX_OPEN_FILES-1) {
 728         errno = EINVAL;
 729         return -1;
 730     }
 731     if ( !file->busy ) {
 732         errno = EBADF;
 733         return -1;
 734     }
 735
 736     switch ( whence ) {
 737         case SEEK_SET:
 738             pos = offset;
 739             break;
 740
 741         case SEEK_CUR:
 742             pos = file->fileoffset + offset;
 743             break;
 744
 745         case SEEK_END:
 746             pos = file->size + offset;
 747             break;
 748
 749         default:
 750             errno = EINVAL;
 751             return -2;
 752     }
 753     if ((pos < 0) || (pos > file->size)) {
 754         errno = EINVAL;
 755         return -3;
 756     }
 757
 758     /* new sector? */
 759     newsector = pos / SECTOR_SIZE;
 760     oldsector = file->fileoffset / SECTOR_SIZE;
 761     sectoroffset = pos % SECTOR_SIZE;
 762
 763     if ( (newsector != oldsector) ||
 764          ((file->cacheoffset==-1) && sectoroffset) ) {
 765
 766         if ( newsector != oldsector ) {
 767             if (file->dirty) {
 768                 rc = flush_cache(fd);
 769                 if (rc < 0)
 770                     return rc * 10 - 5;
 771             }
 772
 773             rc = fat_seek(&(file->fatfile), newsector);
 774             if ( rc < 0 ) {
 775                 errno = EIO;
 776                 return rc * 10 - 4;
 777             }
 778         }
 779         if ( sectoroffset ) {
 780             rc = fat_readwrite(&(file->fatfile), 1, file->cache ,false);
 781             if ( rc < 0 ) {
 782                 errno = EIO;
 783                 return rc * 10 - 6;
 784             }
 785             file->cacheoffset = sectoroffset;
 786         }
 787         else
 788             file->cacheoffset = -1;
 789     }
 790     else
 791         if ( file->cacheoffset != -1 )
 792             file->cacheoffset = sectoroffset;
 793
 794     file->fileoffset = pos;
 795
 796     return pos;
 797 }
 798
 799 off_t filesize(int fd)
 800 {
 801     struct filedesc* file = &openfiles[fd];
 802
 803     if (fd < 0 || fd > MAX_OPEN_FILES-1) {
 804         errno = EINVAL;
 805         return -1;
 806     }
 807     if ( !file->busy ) {
 808         errno = EBADF;
 809         return -1;
 810     }
 811
 812     return file->size;
 813 }
 814
 815
 816 /* release all file handles on a given volume "by force", to avoid leaks */
 817 int release_files(int volume)
 818 {
 819     struct filedesc* pfile = openfiles;
 820     int fd;
 821     int closed = 0;
 822     for ( fd=0; fd<MAX_OPEN_FILES; fd++, pfile++)
 823     {
 824 #ifdef HAVE_MULTIVOLUME
 825         if (pfile->fatfile.volume == volume)
 826 #else
 827         (void)volume;
 828 #endif
 829         {
 830             pfile->busy = false; /* mark as available, no further action */
 831             closed++;
 832         }
 833     }
 834     return closed; /* return how many we did */
 835 }