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