1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Björn Stenberg
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
26 #include "dir_uncached.h"
29 #include "filefuncs.h"
33 These functions provide a roughly POSIX-compatible file IO API.
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.
42 unsigned char cache
[SECTOR_SIZE
];
43 int cacheoffset
; /* invariant: 0 <= cacheoffset <= SECTOR_SIZE */
47 struct fat_file fatfile
;
54 static struct filedesc openfiles
[MAX_OPEN_FILES
];
56 static int flush_cache(int fd
);
58 int creat(const char *pathname
)
60 return open(pathname
, O_WRONLY
|O_CREAT
|O_TRUNC
);
63 static int open_internal(const char* pathname
, int flags
, bool use_cache
)
66 struct dirent_uncached
* entry
;
68 char pathnamecopy
[MAX_PATH
];
70 struct filedesc
* file
= NULL
;
76 LDEBUGF("open(\"%s\",%d)\n",pathname
,flags
);
78 if ( pathname
[0] != '/' ) {
79 DEBUGF("'%s' is not an absolute path.\n",pathname
);
80 DEBUGF("Only absolute pathnames supported at the moment\n");
85 /* find a free file descriptor */
86 for ( fd
=0; fd
<MAX_OPEN_FILES
; fd
++ )
87 if ( !openfiles
[fd
].busy
)
90 if ( fd
== MAX_OPEN_FILES
) {
91 DEBUGF("Too many files open\n");
96 file
= &openfiles
[fd
];
97 memset(file
, 0, sizeof(struct filedesc
));
99 if (flags
& (O_RDWR
| O_WRONLY
)) {
108 if (dircache_is_enabled() && !file
->write
&& use_cache
)
110 const struct dircache_entry
*ce
;
111 # ifdef HAVE_MULTIVOLUME
112 int volume
= strip_volume(pathname
, pathnamecopy
);
115 ce
= dircache_get_entry_ptr(pathname
);
123 fat_open(IF_MV2(volume
,)
127 file
->size
= ce
->size
;
128 file
->attr
= ce
->attribute
;
129 file
->cacheoffset
= -1;
130 file
->fileoffset
= 0;
136 strlcpy(pathnamecopy
, pathname
, sizeof(pathnamecopy
));
138 /* locate filename */
139 name
=strrchr(pathnamecopy
+1,'/');
142 dir
= opendir_uncached(pathnamecopy
);
147 dir
= opendir_uncached("/");
148 name
= pathnamecopy
+1;
151 DEBUGF("Failed opening dir\n");
158 DEBUGF("Empty file name\n");
161 closedir_uncached(dir
);
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
,)
172 file
->size
= file
->trunc
? 0 : entry
->size
;
173 file
->attr
= entry
->attribute
;
179 LDEBUGF("Didn't find file %s\n",name
);
180 if ( file
->write
&& (flags
& O_CREAT
) ) {
181 rc
= fat_create_file(name
,
185 DEBUGF("Couldn't create %s in %s\n",name
,pathnamecopy
);
188 closedir_uncached(dir
);
192 dircache_add_file(pathname
, file
->fatfile
.firstcluster
);
198 DEBUGF("Couldn't find %s in %s\n",name
,pathnamecopy
);
201 closedir_uncached(dir
);
205 if(file
->write
&& (file
->attr
& FAT_ATTR_DIRECTORY
)) {
208 closedir_uncached(dir
);
212 closedir_uncached(dir
);
214 file
->cacheoffset
= -1;
215 file
->fileoffset
= 0;
217 if (file
->write
&& (flags
& O_APPEND
)) {
218 rc
= lseek(fd
,0,SEEK_END
);
225 dircache_bind(fd
, pathname
);
231 int open(const char* pathname
, int flags
)
233 /* By default, use the dircache if available. */
234 return open_internal(pathname
, flags
, true);
239 struct filedesc
* file
= &openfiles
[fd
];
242 LDEBUGF("close(%d)\n", fd
);
244 if (fd
< 0 || fd
> MAX_OPEN_FILES
-1) {
257 dircache_update_filesize(fd
, file
->size
, file
->fatfile
.firstcluster
);
258 dircache_update_filetime(fd
);
268 struct filedesc
* file
= &openfiles
[fd
];
271 LDEBUGF("fsync(%d)\n", fd
);
273 if (fd
< 0 || fd
> MAX_OPEN_FILES
-1) {
282 /* flush sector cache */
284 rc
= flush_cache(fd
);
287 /* when failing, try to close the file anyway */
288 fat_closewrite(&(file
->fatfile
), file
->size
, file
->attr
);
295 rc
= ftruncate(fd
, file
->size
);
298 /* when failing, try to close the file anyway */
299 fat_closewrite(&(file
->fatfile
), file
->size
, file
->attr
);
304 /* tie up all loose ends */
305 rc
= fat_closewrite(&(file
->fatfile
), file
->size
, file
->attr
);
312 int remove(const char* name
)
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);
321 file
= &openfiles
[fd
];
323 dircache_remove(name
);
325 rc
= fat_remove(&(file
->fatfile
));
327 DEBUGF("Failed removing file: %d\n", rc
);
341 int rename(const char* path
, const char* newpath
)
347 struct filedesc
* file
;
348 char newpath2
[MAX_PATH
];
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
) {
360 fd
= open_internal(path
, O_RDONLY
, false);
366 /* extract new file name */
367 nameptr
= strrchr(newpath
,'/');
373 /* Extract new path */
374 strcpy(newpath2
, newpath
);
376 dirptr
= strrchr(newpath2
,'/');
384 if(strlen(dirptr
) == 0) {
388 dir
= opendir_uncached(dirptr
);
392 file
= &openfiles
[fd
];
394 rc
= fat_rename(&file
->fatfile
, &dir
->fatdir
, nameptr
,
395 file
->size
, file
->attr
);
396 #ifdef HAVE_MULTIVOLUME
398 DEBUGF("Failed renaming file across volumnes: %d\n", rc
);
404 DEBUGF("Failed renaming file: %d\n", rc
);
410 dircache_rename(path
, newpath
);
419 rc
= closedir_uncached(dir
);
428 int ftruncate(int fd
, off_t size
)
431 struct filedesc
* file
= &openfiles
[fd
];
433 sector
= size
/ SECTOR_SIZE
;
434 if (size
% SECTOR_SIZE
)
437 rc
= fat_seek(&(file
->fatfile
), sector
);
443 rc
= fat_truncate(&(file
->fatfile
));
451 dircache_update_filesize(fd
, size
, file
->fatfile
.firstcluster
);
457 static int flush_cache(int fd
)
460 struct filedesc
* file
= &openfiles
[fd
];
461 long sector
= file
->fileoffset
/ SECTOR_SIZE
;
463 DEBUGF("Flushing dirty sector cache\n");
465 /* make sure we are on correct sector */
466 rc
= fat_seek(&(file
->fatfile
), sector
);
470 rc
= fat_readwrite(&(file
->fatfile
), 1, file
->cache
, true );
473 if(file
->fatfile
.eof
)
484 static int readwrite(int fd
, void* buf
, long count
, bool write
)
488 struct filedesc
* file
;
491 if (fd
< 0 || fd
> MAX_OPEN_FILES
-1) {
496 file
= &openfiles
[fd
];
503 LDEBUGF( "readwrite(%d,%lx,%ld,%s)\n",
504 fd
,(long)buf
,count
,write
?"write":"read");
506 /* attempt to read past EOF? */
507 if (!write
&& count
> file
->size
- file
->fileoffset
)
508 count
= file
->size
- file
->fileoffset
;
510 /* any head bytes? */
511 if ( file
->cacheoffset
!= -1 ) {
512 int offs
= file
->cacheoffset
;
513 int headbytes
= MIN(count
, SECTOR_SIZE
- offs
);
516 memcpy( file
->cache
+ offs
, buf
, headbytes
);
520 memcpy( buf
, file
->cache
+ offs
, headbytes
);
523 if (offs
+ headbytes
== SECTOR_SIZE
) {
525 rc
= flush_cache(fd
);
531 file
->cacheoffset
= -1;
534 file
->cacheoffset
+= headbytes
;
541 /* If the buffer has been modified, either it has been flushed already
542 * (if (offs+headbytes == SECTOR_SIZE)...) or does not need to be (no
543 * more data to follow in this call). Do NOT flush here. */
545 /* read/write whole sectors right into/from the supplied buffer */
546 sectors
= count
/ SECTOR_SIZE
;
548 rc
= fat_readwrite(&(file
->fatfile
), sectors
,
549 (unsigned char*)buf
+nread
, write
);
551 DEBUGF("Failed read/writing %ld sectors\n",sectors
);
553 if(write
&& file
->fatfile
.eof
) {
554 DEBUGF("No space left on device\n");
557 file
->fileoffset
+= nread
;
559 file
->cacheoffset
= -1;
560 /* adjust file size to length written */
561 if ( write
&& file
->fileoffset
> file
->size
)
563 file
->size
= file
->fileoffset
;
565 dircache_update_filesize(fd
, file
->size
, file
->fatfile
.firstcluster
);
568 return nread
? nread
: rc
* 10 - 4;
572 nread
+= rc
* SECTOR_SIZE
;
573 count
-= sectors
* SECTOR_SIZE
;
575 /* if eof, skip tail bytes */
584 file
->cacheoffset
= -1;
588 /* any tail bytes? */
591 if ( file
->fileoffset
+ nread
< file
->size
) {
592 /* sector is only partially filled. copy-back from disk */
593 LDEBUGF("Copy-back tail cache\n");
594 rc
= fat_readwrite(&(file
->fatfile
), 1, file
->cache
, false );
596 DEBUGF("Failed writing\n");
598 file
->fileoffset
+= nread
;
599 file
->cacheoffset
= -1;
600 /* adjust file size to length written */
601 if ( file
->fileoffset
> file
->size
)
603 file
->size
= file
->fileoffset
;
605 dircache_update_filesize(fd
, file
->size
, file
->fatfile
.firstcluster
);
608 return nread
? nread
: rc
* 10 - 5;
610 /* seek back one sector to put file position right */
611 rc
= fat_seek(&(file
->fatfile
),
612 (file
->fileoffset
+ nread
) /
615 DEBUGF("fat_seek() failed\n");
617 file
->fileoffset
+= nread
;
618 file
->cacheoffset
= -1;
619 /* adjust file size to length written */
620 if ( file
->fileoffset
> file
->size
)
622 file
->size
= file
->fileoffset
;
624 dircache_update_filesize(fd
, file
->size
, file
->fatfile
.firstcluster
);
627 return nread
? nread
: rc
* 10 - 6;
630 memcpy( file
->cache
, (unsigned char*)buf
+ nread
, count
);
634 rc
= fat_readwrite(&(file
->fatfile
), 1, &(file
->cache
),false);
636 DEBUGF("Failed caching sector\n");
638 file
->fileoffset
+= nread
;
639 file
->cacheoffset
= -1;
640 return nread
? nread
: rc
* 10 - 7;
642 memcpy( (unsigned char*)buf
+ nread
, file
->cache
, count
);
646 file
->cacheoffset
= count
;
649 file
->fileoffset
+= nread
;
650 LDEBUGF("fileoffset: %ld\n", file
->fileoffset
);
652 /* adjust file size to length written */
653 if ( write
&& file
->fileoffset
> file
->size
)
655 file
->size
= file
->fileoffset
;
657 dircache_update_filesize(fd
, file
->size
, file
->fatfile
.firstcluster
);
664 ssize_t
write(int fd
, const void* buf
, size_t count
)
666 if (!openfiles
[fd
].write
) {
670 return readwrite(fd
, (void *)buf
, count
, true);
673 ssize_t
read(int fd
, void* buf
, size_t count
)
675 return readwrite(fd
, buf
, count
, false);
679 off_t
lseek(int fd
, off_t offset
, int whence
)
686 struct filedesc
* file
= &openfiles
[fd
];
688 LDEBUGF("lseek(%d,%ld,%d)\n",fd
,offset
,whence
);
690 if (fd
< 0 || fd
> MAX_OPEN_FILES
-1) {
705 pos
= file
->fileoffset
+ offset
;
709 pos
= file
->size
+ offset
;
716 if ((pos
< 0) || (pos
> file
->size
)) {
722 newsector
= pos
/ SECTOR_SIZE
;
723 oldsector
= file
->fileoffset
/ SECTOR_SIZE
;
724 sectoroffset
= pos
% SECTOR_SIZE
;
726 if ( (newsector
!= oldsector
) ||
727 ((file
->cacheoffset
==-1) && sectoroffset
) ) {
729 if ( newsector
!= oldsector
) {
731 rc
= flush_cache(fd
);
736 rc
= fat_seek(&(file
->fatfile
), newsector
);
742 if ( sectoroffset
) {
743 rc
= fat_readwrite(&(file
->fatfile
), 1,
744 &(file
->cache
),false);
749 file
->cacheoffset
= sectoroffset
;
752 file
->cacheoffset
= -1;
755 if ( file
->cacheoffset
!= -1 )
756 file
->cacheoffset
= sectoroffset
;
758 file
->fileoffset
= pos
;
763 off_t
filesize(int fd
)
765 struct filedesc
* file
= &openfiles
[fd
];
767 if (fd
< 0 || fd
> MAX_OPEN_FILES
-1) {
781 /* release all file handles on a given volume "by force", to avoid leaks */
782 int release_files(int volume
)
784 struct filedesc
* pfile
= openfiles
;
787 for ( fd
=0; fd
<MAX_OPEN_FILES
; fd
++, pfile
++)
789 #ifdef HAVE_MULTIVOLUME
790 if (pfile
->fatfile
.volume
== volume
)
795 pfile
->busy
= false; /* mark as available, no further action */
799 return closed
; /* return how many we did */
801 #endif /* #ifdef HAVE_HOTSWAP */