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