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