#include <time.h>
#include <errno.h>
+struct Region {
+ off_t pos;
+ size_t size;
+};
+
struct Source {
char *filename;
ssize_t from;
ssize_t to;
ssize_t start; // starting position in concatenated file
int fd;
+ int dirty;
};
static struct {
time_t mtime;
time_t ctime;
} times;
-
+
+/**
+ * Overlay
+ */
+static struct {
+ struct Source source;
+ struct Region *table;
+ size_t count;
+ size_t limit;
+} overlay;
+
+static void usage();
+
+#define FRAG(m) (overlay.table+m)
+#define BEG(m) (FRAG(m)->pos)
+#define END(m) (FRAG(m)->pos + FRAG(m)->size)
+
+static ssize_t overlay_prior_fragment(off_t pos) {
+ size_t lo = 0, hi = overlay.count;
+ while ( lo < hi ) {
+ size_t m = ( lo + hi ) / 2;
+ if ( m == lo ) {
+ return BEG( m ) < pos? m : -1;
+ }
+ if ( BEG( m ) <= pos ) {
+ lo = m;
+ } else {
+ hi = m;
+ }
+ }
+ return -1;
+}
+
+static void overlay_save_count() {
+ lseek( overlay.source.fd, overlay.source.to, SEEK_SET );
+ size_t size = sizeof( overlay.count );
+ char *p = (char *) &overlay.count ;
+ while ( size > 0 ) {
+ size_t n = write( overlay.source.fd, p, size );
+ if ( n < 0 ) {
+ perror( overlay.source.filename );
+ exit( 1 );
+ }
+ size -= n;
+ p += n;
+ }
+ if ( overlay.source.dirty++ > 1000 ) {
+ fsync( overlay.source.fd );
+ overlay.source.dirty = 0;
+ }
+}
+
+static void overlay_save_table(size_t lo,size_t hi) {
+ char *p = (char *) FRAG(lo);
+ size_t pos = overlay.source.to + sizeof( overlay.count ) +
+ lo * sizeof( struct Region );
+ size_t size = ( hi - lo ) * sizeof( struct Region );
+ if ( pos != lseek( overlay.source.fd, pos, SEEK_SET ) ) {
+ fprintf( stderr, "%s: seek error\n", overlay.source.filename );
+ exit( 1 );
+ }
+ while ( size > 0 ) {
+ size_t n = write( overlay.source.fd, p, size );
+ if ( n < 0 ) {
+ perror( overlay.source.filename );
+ exit( 1 );
+ }
+ size -= n;
+ p += n;
+ }
+ if ( overlay.source.dirty++ > 1000 ) {
+ fsync( overlay.source.fd );
+ overlay.source.dirty = 0;
+ }
+}
+
+static void overlay_insert(size_t p,off_t pos,size_t size) {
+ size_t bytes;
+ if ( overlay.count >= overlay.limit ) {
+ overlay.limit = overlay.count + 10;
+ bytes = overlay.limit * sizeof( struct Region );
+ overlay.table = overlay.table?
+ realloc( overlay.table, bytes ) : malloc( bytes );
+ }
+ bytes = ( overlay.count++ - p ) * sizeof( struct Region );
+ if ( bytes ) {
+ memmove( FRAG( p+1 ), FRAG( p ), bytes );
+ }
+ FRAG( p )->pos = pos;
+ FRAG( p )->size = size;
+ overlay_save_count();
+}
+
+static void overlay_delete(size_t p) {
+ if ( p < --overlay.count ) {
+ size_t size = ( overlay.count - p ) * sizeof( struct Region );
+ memmove( FRAG(p), FRAG(p+1), size );
+ }
+ overlay_save_count();
+}
+
+static void overlay_mark(off_t pos,size_t size) {
+#if DEBUG
+ fprintf( stderr, "overlay_mark( %ld, %ld )\n", pos, size );
+#endif
+ int deleted = 0;
+ ssize_t q;
+ ssize_t p = overlay_prior_fragment( pos );
+ // p is the nearest region below pos (or -1)
+ if ( p >= 0 && pos <= END(p) ) {
+ // p overlaps mark region
+ if ( END(p) >= pos + size ) {
+#if DEBUG
+ fprintf( stderr, "overlay size 1( %ld )\n", FRAG(p)->size );
+#endif
+ return; // new mark within existing.
+ }
+ // new mark region extends existing
+ FRAG(p)->size = pos + size - BEG(p);
+ q = p+1;
+ while ( q < overlay.count && BEG(q) <= END(p) ) {
+ if ( END(q) > END(p) ) {
+ FRAG(p)->size = END(q) - BEG(p);
+ }
+ overlay_delete( q );
+ deleted++;
+ }
+ overlay_save_table( p, deleted? overlay.count : q );
+#if DEBUG
+ fprintf( stderr, "overlay size 2( %ld ) deleted %d\n",
+ FRAG(p)->size, deleted );
+#endif
+ return;
+ }
+ // The region p does not expand into new mark region
+ p++; // subsequent region
+ if ( p >= overlay.count || BEG(p) > pos + size ) {
+ // New mark is separate region at p
+ overlay_insert( p, pos, size);
+#if DEBUG
+ fprintf( stderr, "overlay size 4( %ld )\n", FRAG(p)->size );
+#endif
+ overlay_save_table( p, overlay.count );
+ return;
+ }
+ // New marks start before and overlap with the region
+ if ( BEG(p) + FRAG(p)->size < pos + size ) {
+ FRAG(p)->size = size; // new mark covers old region
+ } else {
+ FRAG(p)->size += BEG(p) - pos;
+ }
+ BEG(p) = pos;
+ q = p+1;
+ while ( q < overlay.count && BEG(q) <= END(p) ) {
+ if ( END(q) > END(p) ) {
+ FRAG(p)->size = END(q) - BEG(p);
+ }
+ overlay_delete( q );
+ deleted++;
+ }
+ overlay_save_table( p, deleted? overlay.count : q );
+#if DEBUG
+ fprintf( stderr, "overlay size 4( %ld ) deleted %d\n",
+ FRAG(p)->size, deleted );
+#endif
+}
+
+static void setup_overlay(char *filename) {
+ overlay.source.filename = filename;
+ overlay.source.fd = open( filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR );
+ if ( overlay.source.fd < 0 ) {
+ perror( filename );
+ usage();
+ }
+}
+
#if DEBUG
static void print_source(struct Source *p) {
fprintf( stderr, "%p { %s, %ld, %ld, %ld, %d }\n",
} else if ( RANGE( sscanf( range, "%d:%n", &a, &c ), 1 )) {
p->from = ( a < 0 )? ( p->to + a ) : a;
} else if ( RANGE( sscanf( range, "%d%n", &a, &c ), 1 )) {
- if ( a < 0 ) {
- p->from = p->to + a;
+ if ( a >= 0 ) {
+ p->from = a;
} else {
- p->to = p->from + a;
+ p->from = p->to + a;
}
} else if ( RANGE( sscanf( range, ":%n", &c), 0 ) ) {
// to end from start
return 1;
}
}
- if ( p->from >= p->to ||
- p->from >= filestat.st_size || p->to > filestat.st_size ) {
+ if ( ( filestat.st_mode & S_IFMT ) == S_IFCHR ) {
+ filestat.st_size = p->to; // Pretend size of character device
+ }
+ if ( p->from < 0 ) {
+ p->from = 0;
+ }
+ if ( p->to > filestat.st_size ) {
+ p->to = filestat.st_size;
+ }
+ if ( p->from >= p->to || p->from >= filestat.st_size ) {
fprintf( stderr, "** BAD RANGE: %s [%ld:%ld]\n",
argv[i], p->from, p->to );
return 1;
if ( offset >= sources.size ) {
return -1;
}
+#if DEBUG
+ fprintf( stderr, "find_source( %ld )\n", offset );
+#endif
while ( lo + 1 < hi ) {
int m = ( lo + hi ) / 2;
if ( offset < sources.array[ m ].start ) {
+#if DEBUG
+ fprintf( stderr, " offset < [%d].start: %ld\n",
+ m, sources.array[ m ].start );
+#endif
hi = m;
} else {
+#if DEBUG
+ fprintf( stderr, " offset >= [%d].start: %ld\n",
+ m, sources.array[ m ].start );
+#endif
lo = m;
}
}
+#if DEBUG
+ fprintf( stderr, "found %d\n", lo );
+#endif
return lo;
}
+static int overlay_merge(char *buf,off_t off,size_t size) {
+#if DEBUG
+ fprintf( stderr, "merge %ld %ld\n", off, size );
+#endif
+ // Find nearest overlay data before or at off
+ ssize_t p = overlay_prior_fragment( off );
+ if ( p < 0 ) {
+ p = 0;
+ }
+ for ( ; p < overlay.count && BEG(p) < off+size; p++ ) {
+ if ( END(p) < off ) {
+ continue;
+ }
+ size_t delta = FRAG(p)->size;
+ if ( BEG(p) < off ) {
+ delta -= off - BEG(p);
+ } else {
+ size_t skip = BEG(p) - off;
+ off += skip;
+ size -= skip;
+ buf += skip;
+ }
+ if ( delta > size ) {
+ delta = size;
+ }
+ lseek( overlay.source.fd, off, SEEK_SET );
+ while ( delta > 0 ) {
+ size_t n = read( overlay.source.fd, buf, delta );
+ off += n;
+ size -= n;
+ delta -= n;
+ buf += n;
+ }
+ }
+#if DEBUG
+ fprintf( stderr, "merged\n" );
+#endif
+ return 0;
+}
+
// Read <size> bytes from <offset> in file
static int fusefile_read(const char *path, char *buf, size_t size,
off_t off, struct fuse_file_info *fi)
#if DEBUG
fprintf( stderr, "read %ld %ld\n", off, size );
#endif
- size_t rr = 0;
+ size_t rr = 0; // total reading
while ( size > 0 ) {
#if DEBUG
- fprintf( stderr, "find_source %ld %ld\n", off, size );
+ fprintf( stderr, " find_source %ld %ld\n", off, size );
#endif
int i = find_source( off );
if ( i < 0 ) {
if ( n > size ) {
n = size;
}
+ if ( sources.array[i].dirty ) {
+ fsync( sources.array[i].fd );
+ sources.array[i].dirty = 0;
+ }
+#if DEBUG
+ fprintf( stderr, " seek fd=%d to %ld\n", sources.array[i].fd, b );
+#endif
if ( lseek( sources.array[i].fd, b, SEEK_SET ) < 0 ) {
perror( sources.array[i].filename );
return -ENOENT;
}
#if DEBUG
- fprintf( stderr, "get %ld bytes at %ld\n", n, rr );
+ fprintf( stderr, " now read %ld from fd=%d\n",
+ n, sources.array[i].fd );
#endif
ssize_t r = read( sources.array[i].fd, buf + rr, n );
#if DEBUG
- fprintf( stderr, "got %ld bytes\n", r );
+ fprintf( stderr, " got %ld bytes\n", r );
#endif
if ( r < 0 ) {
perror( sources.array[i].filename );
if ( r == 0 ) {
break;
}
+ if ( overlay.source.filename ) {
+ if ( overlay.source.dirty ) {
+ fsync( overlay.source.fd );
+ overlay.source.dirty = 0;
+ }
+ int x = overlay_merge( buf + rr, off + rr, r );
+ if ( x ) {
+ return x;
+ }
+ }
rr += r;
off += r;
size -= r;
}
+#if DEBUG
+ fprintf( stderr, " total reading %ld bytes\n", rr );
+#endif
return rr;
}
return 0;
}
+static void overlay_load() {
+ lseek( overlay.source.fd, overlay.source.to, SEEK_SET );
+ size_t x = 0;
+ size_t size = sizeof( overlay.count );
+ if ( read( overlay.source.fd, &x, size ) != size ) {
+ return;
+ }
+#if DEBUG
+ fprintf( stderr, "overlay: %s with %ld regions\n",
+ overlay.source.filename, x );
+#endif
+ struct Region f = { 0, 0 };
+ size = sizeof( struct Region );
+ while ( x-- > 0 ) {
+ if ( read( overlay.source.fd, &f, size ) != size ) {
+ fprintf( stderr, "%s: bad meta data\n", overlay.source.filename );
+ exit( 1 );
+ }
+#if DEBUG
+ fprintf( stderr, "overlay region: %ld %ld\n", f.pos, f.size );
+#endif
+ overlay_mark( f.pos, f.size );
+ }
+}
/**
* Write a full block of data over the sources at the offset
#if DEBUG
fprintf( stderr, "write_block( %ld, ?, %ld )\n", off, size );
#endif
+ if ( overlay.source.filename ) {
+ overlay_mark( off, size ); // Mark region as written
+ }
while ( size > 0 ) {
int index = find_source( off ); // index of source file
if ( index < 0 ) {
return -EIO; // past EOF
}
- struct Source *source = &sources.array[ index ];
+ struct Source *source = overlay.source.filename?
+ &overlay.source : &sources.array[ index ];
off_t from = off - source->start + source->from;
off_t max = source->to - from;
if ( lseek( source->fd, from, SEEK_SET ) < 0 ) {
size -= n;
off += n;
}
+ if ( source->dirty++ >= 1000 ) {
+ fsync( source->fd );
+ source->dirty = 0;
+ }
}
return 0;
}
}
}
+static void fsync_all_dirty() {
+ int i = 0;
+ for ( ; i < sources.count; i++ ) {
+ if ( sources.array[i].dirty ) {
+ fsync( sources.array[i].fd );
+ sources.array[i].dirty = 0;
+ }
+ }
+ if ( overlay.source.filename && overlay.source.dirty ) {
+ fsync( overlay.source.fd );
+ overlay.source.dirty = 0;
+ }
+}
+
static int fusefile_flush(const char *path, struct fuse_file_info *info) {
#if DEBUG
fprintf( stderr, "fusefile_flush( %s )\n", path );
if ( strcmp( path, "/" ) != 0 ) {
return -ENOENT;
}
+ fsync_all_dirty();
return 0;
}
if ( strcmp( path, "/" ) != 0 ) {
return -ENOENT;
}
+ fsync_all_dirty();
return 0;
}
static void usage() {
char *usage =
"Usage: fusefile [ <fuse options> ] <mount> <file/from-to> ... \n"
-"Mounts a virtual, read-only file that is a concatenation of file fragments\n"
+"Mounts a virtual, file that is a concatenation of file fragments\n"
;
fprintf( stderr, "%s", usage );
exit( 1 );
}
fuseargc = i;
mnt = argv[ i++ ]; // First non-option argument is the mount pount
+ char *overlaytag = "-overlay:";
+ int overlaytagsize = strlen( overlaytag );
+ if ( strncmp( argv[i], overlaytag, overlaytagsize ) == 0 ) {
+ // consume "-overlay:filename"
+ setup_overlay( argv[i++] + overlaytagsize ); // Need a writable file
+ if ( i >= argc ) {
+ usage();
+ }
+ }
if ( setup_sources( argv, i, argc-i ) ) {
return 1;
}
+ if ( overlay.source.filename ) {
+ overlay.source.to = sources.size; // Register total size.
+ overlay_load();
+ }
if ( stat( mnt, &stbuf ) == -1 ) {
int fd = open( mnt, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR );
if ( fd < 0 ) {
times.ctime = stbuf.st_ctime;
}
+ {
+ int fd = open( mnt, O_RDWR, S_IRUSR | S_IWUSR );
+ if ( fd < 0 ) {
+ perror( mnt );
+ return 1;
+ }
+ if ( lseek( fd, sources.size, SEEK_SET ) < 0 ) {
+ return -EIO;
+ }
+ }
fuseargc = setup_argv( fuseargc, &argv );
struct fuse_args args = FUSE_ARGS_INIT( fuseargc, argv );
if ( fuse_parse_cmdline( &args, &mnt, &mt, &fg ) ) {