zysrw()
{
register struct fcblk *fcb = WA (struct fcblk *);
register struct ioblk *iob = MK_MP(fcb->iob, struct ioblk *);
/* ensure the file is open */
if ( !(iob->flg1 & IO_OPN) )
return EXIT_1;
/* see if this file can be LSEEK'ed */
if ( LSEEK(iob->fdn, (FILEPOS)0, 1) < (FILEPOS)0 )
return EXIT_2;
/* seek to the beginning */
if (doset( iob, 0L, 0 ) == (FILEPOS)-1)
return EXIT_3;
return NORMAL_RETURN;
}
/* -- see zlib.h -- */
int ZEXPORT gzrewind(
gzFile file)
{
gz_statep state;
/* get internal structure */
if (file == NULL)
return -1;
state = (gz_statep)file;
/* check that we're reading and that there's no error */
if (state->mode != GZ_READ || state->err != Z_OK)
return -1;
/* back up and start over */
if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
return -1;
gz_reset(state);
return 0;
}
/*
* do_check -- check the mapping
*/
static void
do_check(int fd, void *addr, size_t mlen)
{
/* arrange to catch SEGV */
struct sigaction v;
sigemptyset(&v.sa_mask);
v.sa_flags = 0;
v.sa_handler = signal_handler;
SIGACTION(SIGSEGV, &v, NULL);
char pat[CHECK_BYTES];
char buf[CHECK_BYTES];
/* write some pattern to the file */
memset(pat, 0x5A, CHECK_BYTES);
WRITE(fd, pat, CHECK_BYTES);
if (memcmp(pat, addr, CHECK_BYTES))
UT_OUT("first %d bytes do not match", CHECK_BYTES);
/* fill up mapped region with new pattern */
memset(pat, 0xA5, CHECK_BYTES);
memcpy(addr, pat, CHECK_BYTES);
UT_ASSERTeq(pmem_msync(addr, CHECK_BYTES), 0);
UT_ASSERTeq(pmem_unmap(addr, mlen), 0);
if (!ut_sigsetjmp(Jmp)) {
/* same memcpy from above should now fail */
memcpy(addr, pat, CHECK_BYTES);
} else {
UT_OUT("unmap successful");
}
LSEEK(fd, (os_off_t)0, SEEK_SET);
if (READ(fd, buf, CHECK_BYTES) == CHECK_BYTES) {
if (memcmp(pat, buf, CHECK_BYTES))
UT_OUT("first %d bytes do not match", CHECK_BYTES);
}
}
/* -- see zlib.h -- */
z_off64_t ZEXPORT gzoffset64(
gzFile file)
{
z_off64_t offset;
gz_statep state;
/* get internal structure and check integrity */
if (file == NULL)
return -1;
state = (gz_statep)file;
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
return -1;
/* compute and return effective offset in file */
offset = LSEEK(state->fd, 0, SEEK_CUR);
if (offset == -1)
return -1;
if (state->mode == GZ_READ) /* reading */
offset -= state->strm.avail_in; /* don't count buffered input */
return offset;
}
static void
do_memcpy(int fd, char *dest, int dest_off, char *src, int src_off,
size_t bytes, char *file_name)
{
void *ret;
char buf[bytes];
memset(buf, 0, bytes);
memset(dest, 0, bytes);
memset(src, 0, bytes);
memset(src, 0x5A, bytes / 4);
memset(src + bytes / 4, 0x46, bytes / 4);
/* dest == src */
ret = pmem_memcpy_persist(dest + dest_off, dest + dest_off, bytes / 2);
ASSERTeq(ret, dest + dest_off);
ASSERTeq(*(char *)(dest + dest_off), 0);
/* len == 0 */
ret = pmem_memcpy_persist(dest + dest_off, src, 0);
ASSERTeq(ret, dest + dest_off);
ASSERTeq(*(char *)(dest + dest_off), 0);
ret = pmem_memcpy_persist(dest + dest_off, src + src_off, bytes / 2);
ASSERTeq(ret, dest + dest_off);
/* memcmp will validate that what I expect in memory. */
if (memcmp(src + src_off, dest + dest_off, bytes / 2))
ERR("%s: first %zu bytes do not match",
file_name, bytes / 2);
/* Now validate the contents of the file */
LSEEK(fd, (off_t)dest_off, SEEK_SET);
if (READ(fd, buf, bytes / 2) == bytes / 2) {
if (memcmp(src + src_off, buf, bytes / 2))
ERR("%s: first %zu bytes do not match",
file_name, bytes / 2);
}
}
int iobfseekmark(IOBFILE *iobf)
{
IOBLIST *ioblist;
if (!iobf->mark_set) {
return -1;
}
if (iobf->mark_wrap) { /* implies can_seek */
#if POSIX_SHORTCUT
if (LSEEK(iobf->fd, iobf->posixmark, SEEK_SET) != iobf->posixmark) {
return -1;
}
#else
if (fsetpos(iobf->istream, &iobf->stdiomark) != 0) {
return -1;
}
#endif
iob_release_buffer(&iobf->ioblist);
iob_copy_buffer(&iobf->ioblist, &iobf->ioblist_mark);
iobf->mark_wrap = 0;
}
ioblist = &iobf->ioblist;
ioblist->buf_ptr = ioblist->buf_head;
ioblist->tot_pos = iobf->mark_pos;
ioblist->buf_pos = iobf->mark_pos % BUFFER_SIZE;
iobf->ungetc = iobf->mark_ungetc;
/* Clear status flags on success */
if (iobf->eof == -1) {
iobf->eof = 1;
}
#if DEBUG
iobf->read_count = ioblist->tot_pos;
#endif
return 0;
}
bool QFile::open( int m, int f )
{
if ( isOpen() ) {
#if defined(CHECK_RANGE)
warning( "QFile::open: File already open" );
#endif
return FALSE;
}
init();
setMode( m |IO_Raw );
setState( IO_Open );
fd = f;
ext_f = TRUE;
if ( fd == 0 || fd == 1 || fd == 2 ) {
length = INT_MAX;
} else {
STATBUF st;
FSTAT( fd, &st );
length = (int)st.st_size;
index = (int)LSEEK(fd, 0, SEEK_CUR);
}
return TRUE;
}
bool QFile::at( int pos )
{
if ( !isOpen() ) {
#if defined(CHECK_STATE)
warning( "QFile::at: File is not open" );
#endif
return FALSE;
}
bool ok;
if ( isRaw() ) { // raw file
pos = (int)LSEEK(fd, pos, SEEK_SET);
ok = pos != -1;
} else { // buffered file
ok = fseek(fh, pos, SEEK_SET) == 0;
}
if ( ok )
index = pos;
#if defined(CHECK_RANGE)
else
warning( "QFile::at: Cannot set file position %d", pos );
#endif
return ok;
}
int
dbs_seg_extend (dbe_storage_t * dbs, int n)
{
/* extend each stripe of the last segment of dbs by n */
disk_segment_t * ds;
dk_set_t last = dbs->dbs_disks;
int fd, inx, rc;
OFF_T org_sz;
while (last->next)
last = last->next;
ds = (disk_segment_t*)last->data;
fd = dst_fd (ds->ds_stripes[0]);
org_sz = LSEEK (fd, 0, SEEK_END);
dst_fd_done (ds->ds_stripes[0], fd);
DO_BOX (disk_stripe_t *, dst, inx, ds->ds_stripes)
{
fd = dst_fd (dst);
rc = fd_extend (dbs, fd, n);
dst_fd_done (dst, fd);
if (rc != n)
{
int inx2;
for (inx2 = 0; inx2 < inx; inx2++)
{
fd = dst_fd (ds->ds_stripes[inx2]);
FTRUNCATE (fd, org_sz);
dst_fd_done (ds->ds_stripes[inx2], fd);
}
return 0;
}
}
END_DO_BOX;
ds->ds_size += n * ds->ds_n_stripes;
dbs->dbs_n_pages+= n * ds->ds_n_stripes;
dbs->dbs_n_free_pages+= n * ds->ds_n_stripes;
return n;
}
int QFile::writeBlock( const char *p, uint len )
{
#if defined(CHECK_NULL)
if ( p == 0 && len != 0 )
warning( "QFile::writeBlock: Null pointer error" );
#endif
#if defined(CHECK_STATE)
if ( !isOpen() ) { // file not open
warning( "QFile::writeBlock: File not open" );
return -1;
}
if ( !isWritable() ) { // writing not permitted
warning( "QFile::writeBlock: Write operation not permitted" );
return -1;
}
#endif
int nwritten; // number of bytes written
if ( isRaw() ) // raw file
nwritten = WRITE( fd, p, len );
else // buffered file
nwritten = fwrite( p, 1, len, fh );
if ( nwritten != (int)len ) { // write error
if ( errno == ENOSPC ) // disk is full
setStatus( IO_ResourceError );
else
setStatus( IO_WriteError );
if ( isRaw() ) // recalc file position
index = (int)LSEEK( fd, 0, SEEK_CUR );
else
index = fseek( fh, 0, SEEK_CUR );
} else {
index += nwritten;
}
if ( index > length ) // update file length
length = index;
return nwritten;
}
bool QFile::open( int m, int f )
{
if ( isOpen() ) {
#if defined(CHECK_RANGE)
qWarning( "QFile::open: File already open" );
#endif
return FALSE;
}
init();
setMode( m |IO_Raw );
setState( IO_Open );
fd = f;
ext_f = TRUE;
STATBUF st;
FSTAT( fd, &st );
ioIndex = (int)LSEEK(fd, 0, SEEK_CUR);
if ( (st.st_mode & STAT_MASK) != STAT_REG || f == 0 ) { // stdin is not seekable...
// non-seekable
setType( IO_Sequential );
length = INT_MAX;
} else {
length = (int)st.st_size;
if ( length == 0 && isReadable() ) {
// try if you can read from it (if you can, it's a sequential
// device; e.g. a file in the /proc filesystem)
int c = getch();
if ( c != -1 ) {
ungetch(c);
setType( IO_Sequential );
length = INT_MAX;
}
resetStatus();
}
}
return TRUE;
}
int32_t drn_close_writer(drn_writer_t *cache)
{
drn_header_container_t header;
drn_map_container_t * maps = (drn_map_container_t *) ALLOCATE(sbcount(cache->maps) * sizeof(drn_map_container_t));
uint64_t m_idx;
uint64_t i;
size_t bytes;
for (m_idx=0; m_idx < sbcount(cache->maps); ++m_idx)
{
drn_writer_map_t * map = cache->maps + m_idx;
drn_hash_cell_t * hash_map = (drn_hash_cell_t *) ALLOCATE(DRN_HASH_MAP_SIZE * sizeof (drn_hash_cell_t));
uint64_t hc_idx;
uint64_t chunk_count = 0;
uint64_t values_size = 0;
drn_writer_key_t * key_array = map->keys;
uint64_t k_idx;
drn_hash_desc_t * descriptors;
char * values_string_array;
uint32_t desc_offset_cntr;
uint32_t value_strings_offset_cntr;
for (hc_idx = 0; hc_idx < DRN_HASH_MAP_SIZE; ++hc_idx)
{
hash_map[hc_idx].offset = 0;
hash_map[hc_idx].count = 0;
}
/* count Es + sum VV lengths */
for (k_idx = 0; k_idx < sbcount(map->keys); ++k_idx)
{
drn_writer_key_t * value = map->keys + k_idx;
chunk_count += sbcount(value->descriptors);
values_size += strlen(value->value)+1;
}
/* Allocate Es */
descriptors = (drn_hash_desc_t*) ALLOCATE((size_t) chunk_count * sizeof(drn_hash_desc_t));
/* Allocate Vv */
values_string_array = (char *) ALLOCATE((size_t) values_size * sizeof(char));
/* Sort Vs */
qsort(key_array, sbcount(map->keys), sizeof(drn_writer_key_t), drn_val_hash_cmp);
/* For each V */
desc_offset_cntr = 0;
value_strings_offset_cntr = 0;
for (k_idx = 0; k_idx < sbcount(map->keys); ++k_idx)
{
uint32_t hash = drn_oat_hash(key_array[k_idx].value, (uint32_t) strlen(key_array[k_idx].value))%DRN_HASH_MAP_SIZE;
uint64_t * chunk_ids = key_array[k_idx].descriptors;
uint64_t d_idx;
/* Fill H */
hash_map[hash].offset = desc_offset_cntr;
hash_map[hash].count = sbcount(key_array[k_idx].descriptors);
/* Fill Vv */
memcpy(values_string_array + value_strings_offset_cntr, key_array[k_idx].value, strlen(key_array[k_idx].value)+1);
/* fill E */
qsort(chunk_ids, sbcount(key_array[k_idx].descriptors), sizeof(uint64_t), drn_uint64_cmp);
for (d_idx = 0; d_idx < sbcount(key_array[k_idx].descriptors); ++d_idx)
{
descriptors[desc_offset_cntr].chunk_id = chunk_ids[d_idx];
descriptors[desc_offset_cntr].key_value_offset = value_strings_offset_cntr;
++desc_offset_cntr;
}
/* Increment offsets */
value_strings_offset_cntr += (uint32_t) strlen(key_array[k_idx].value)+1;
}
/* Write hash array as desc */
drn_writer_add_chunk(cache, hash_map, sizeof(drn_hash_cell_t) * DRN_HASH_MAP_SIZE);
maps[m_idx].hash_chunk_id = drn_writer_get_last_chunk_id(cache);
/* Write hash name as desc */
drn_writer_add_chunk(cache, map->name, strlen(map->name) + 1);
maps[m_idx].name_chunk_id = drn_writer_get_last_chunk_id(cache);
/* Write value string array as desc */
drn_writer_add_chunk(cache, descriptors, sizeof(drn_hash_desc_t) * chunk_count);
maps[m_idx].descriptors_chunk_id = drn_writer_get_last_chunk_id(cache);
/* Write desc array as desc */
drn_writer_add_chunk(cache, values_string_array, values_size);
maps[m_idx].value_strings_chunk_id = drn_writer_get_last_chunk_id(cache);
FREE(hash_map);
FREE(descriptors);
FREE(values_string_array);
}
drn_writer_add_chunk(cache, maps, sizeof(drn_map_container_t) * sbcount(cache->maps));
FREE(maps);
header.version = cache->version;
memcpy(header.description, cache->description, 256);
header.index_offset = cache->desc_start_offset + cache->desc_end_offset;
header.chunk_count = cache->chunk_count;
header.maps_chunk_id = drn_writer_get_last_chunk_id(cache);
LSEEK(cache->fd, 0L, SEEK_SET);
bytes = WRITE(cache->fd, &header, sizeof(drn_header_container_t));
if (bytes != sizeof(drn_header_container_t))
return -1;
LSEEK(cache->fd, cache->desc_start_offset + cache->desc_end_offset, SEEK_SET);
bytes = WRITE(cache->fd, cache->descriptors, WRITE_COUNT_CAST (sizeof(drn_desc_t) * cache->chunk_count));
if (bytes != sizeof(drn_desc_t) * cache->chunk_count)
return -1;
if (CLOSE(cache->fd) == -1)
return -1;
for (i = 0; i < sbcount(cache->maps); ++i)
{
drn_writer_map_t * map = cache->maps + i;
uint64_t j;
for (j = 0; j < sbcount(map->keys); ++j)
{
drn_writer_key_t * value = map->keys + j;
sbfree(value->descriptors);
FREE(value->value);
}
sbfree(map->keys);
FREE(map->name);
}
sbfree(cache->maps);
sbfree(cache->descriptors);
return 0;
}
bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
long permission)
{
_STLP_fd file_no;
if (_M_is_open)
return false;
#if defined (_STLP_USE_UNIX_IO) || defined (_STLP_USE_UNIX_EMULATION_IO)
int flags = 0;
// Unix makes no distinction between text and binary files.
switch(openmode & (~ios_base::ate & ~ios_base::binary)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
flags = O_WRONLY | O_CREAT | O_TRUNC;
break;
case ios_base::out | ios_base::app:
flags = O_WRONLY | O_CREAT | O_APPEND;
break;
case ios_base::in:
flags = O_RDONLY;
permission = 0; // Irrelevant unless we're writing.
break;
case ios_base::in | ios_base::out:
flags = O_RDWR;
break;
case ios_base::in | ios_base::out | ios_base::trunc:
flags = O_RDWR | O_CREAT | O_TRUNC;
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
# if defined (_STLP_USE_UNIX_EMULATION_IO)
if (openmode & ios_base::binary)
flags |= O_BINARY;
else
flags |= O_TEXT;
file_no = _open(name, flags, permission);
# else
file_no = open(name, flags, permission);
# endif /* _STLP_USE_UNIX_EMULATION_IO */
if (file_no < 0)
return false;
_M_is_open = true;
if (openmode & ios_base::ate)
if (LSEEK(file_no, 0, SEEK_END) == -1)
_M_is_open = false;
#elif defined (_STLP_USE_STDIO_IO)
// use FILE-based i/o
const char* flags;
switch(openmode & (~ios_base::ate)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
flags = "w";
break;
case ios_base::out | ios_base::binary:
case ios_base::out | ios_base::trunc | ios_base::binary:
flags = "wb";
break;
case ios_base::out | ios_base::app:
flags = "a";
break;
case ios_base::out | ios_base::app | ios_base::binary:
flags = "ab";
break;
case ios_base::in:
flags = "r";
break;
case ios_base::in | ios_base::binary:
flags = "rb";
break;
case ios_base::in | ios_base::out:
flags = "r+";
break;
case ios_base::in | ios_base::out | ios_base::binary:
flags = "r+b";
break;
case ios_base::in | ios_base::out | ios_base::trunc:
flags = "w+";
break;
case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
flags = "w+b";
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
// fbp : TODO : set permissions !
(void)permission; // currently unused //*TY 02/26/2000 - added to suppress warning message
_M_file = fopen(name, flags);
if (_M_file) {
file_no = fileno(_M_file);
}
else
return false;
// unset buffering immediately
setbuf(_M_file, 0);
_M_is_open = true;
if (openmode & ios_base::ate)
if (fseek(_M_file, 0, SEEK_END) == -1)
_M_is_open = false;
# elif defined (_STLP_USE_WIN32_IO)
DWORD dwDesiredAccess, dwShareMode, dwCreationDisposition;
bool doTruncate = false;
switch(openmode & (~ios_base::ate & ~ios_base::binary)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
dwDesiredAccess = GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
// boris : even though it is very non-intuitive, standard
// requires them both to behave same.
doTruncate = true;
break;
case ios_base::out | ios_base::app:
dwDesiredAccess = GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
break;
case ios_base::in:
dwDesiredAccess = GENERIC_READ;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_EXISTING;
permission = 0; // Irrelevant unless we're writing.
break;
case ios_base::in | ios_base::out:
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_EXISTING;
break;
case ios_base::in | ios_base::out | ios_base::trunc:
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
doTruncate = true;
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
#if defined(_STLP_WINCE)
file_no = CreateFile(__ASCIIToWide(name).c_str(),
#else
file_no = CreateFileA(name,
#endif
dwDesiredAccess, dwShareMode, 0,
dwCreationDisposition, permission, 0);
if ( file_no == INVALID_HANDLE_VALUE )
return false;
if ((doTruncate && SetEndOfFile(file_no) == 0) ||
((openmode & ios_base::ate) && SetFilePointer(file_no, 0, NULL, FILE_END) == -1)) {
CloseHandle(file_no);
return false;
}
_M_is_open = true;
#else
# error "Port!"
#endif /* __unix */
_M_file_id = file_no;
_M_should_close = _M_is_open;
_M_openmode = openmode;
if (_M_is_open)
_M_regular_file = _SgI::__is_regular_file(_M_file_id);
return _M_is_open;
}
int
main(int argc, char *argv[])
{
START(argc, argv, "pmem_map");
if (argc != 2)
FATAL("usage: %s file", argv[0]);
int fd;
void *addr;
fd = OPEN(argv[1], O_RDWR);
struct stat stbuf;
FSTAT(fd, &stbuf);
char pat[CHECK_BYTES];
char buf[CHECK_BYTES];
addr = pmem_map(fd);
if (addr == NULL) {
OUT("!pmem_map");
goto err;
}
/* write some pattern to the file */
memset(pat, 0x5A, CHECK_BYTES);
WRITE(fd, pat, CHECK_BYTES);
if (memcmp(pat, addr, CHECK_BYTES))
OUT("%s: first %d bytes do not match",
argv[1], CHECK_BYTES);
/* fill up mapped region with new pattern */
memset(pat, 0xA5, CHECK_BYTES);
memcpy(addr, pat, CHECK_BYTES);
MUNMAP(addr, stbuf.st_size);
LSEEK(fd, (off_t)0, SEEK_SET);
if (READ(fd, buf, CHECK_BYTES) == CHECK_BYTES) {
if (memcmp(pat, buf, CHECK_BYTES))
OUT("%s: first %d bytes do not match",
argv[1], CHECK_BYTES);
}
CLOSE(fd);
/* re-open the file with read-only access */
fd = OPEN(argv[1], O_RDONLY);
addr = pmem_map(fd);
if (addr != NULL) {
MUNMAP(addr, stbuf.st_size);
OUT("expected pmem_map failure");
}
err:
CLOSE(fd);
DONE(NULL);
}
/* Open a gzip file either by name or file descriptor. */
local gzFile gz_open(
const char *path,
int fd,
const char *mode)
{
gz_statep state;
/* allocate gzFile structure to return */
state = malloc(sizeof(gz_state));
if (state == NULL)
return NULL;
state->size = 0; /* no buffers allocated yet */
state->want = GZBUFSIZE; /* requested buffer size */
state->msg = NULL; /* no error message yet */
/* interpret mode */
state->mode = GZ_NONE;
state->level = Z_DEFAULT_COMPRESSION;
state->strategy = Z_DEFAULT_STRATEGY;
while (*mode) {
if (*mode >= '0' && *mode <= '9')
state->level = *mode - '0';
else
switch (*mode) {
case 'r':
state->mode = GZ_READ;
break;
#ifndef NO_GZCOMPRESS
case 'w':
state->mode = GZ_WRITE;
break;
case 'a':
state->mode = GZ_APPEND;
break;
#endif
case '+': /* can't read and write at the same time */
free(state);
return NULL;
case 'b': /* ignore -- will request binary anyway */
break;
case 'f':
state->strategy = Z_FILTERED;
break;
case 'h':
state->strategy = Z_HUFFMAN_ONLY;
break;
case 'R':
state->strategy = Z_RLE;
break;
case 'F':
state->strategy = Z_FIXED;
default: /* could consider as an error, but just ignore */
;
}
mode++;
}
/* must provide an "r", "w", or "a" */
if (state->mode == GZ_NONE) {
free(state);
return NULL;
}
/* save the path name for error messages */
state->path = malloc(strlen(path) + 1);
if (state->path == NULL) {
free(state);
return NULL;
}
strcpy(state->path, path);
/* open the file with the appropriate mode (or just use fd) */
state->fd = fd != -1 ? fd :
open(path,
#ifdef O_LARGEFILE
O_LARGEFILE |
#endif
#ifdef O_BINARY
O_BINARY |
#endif
(state->mode == GZ_READ ?
O_RDONLY :
(O_WRONLY | O_CREAT | (
state->mode == GZ_WRITE ?
O_TRUNC :
O_APPEND))),
0666);
if (state->fd == -1) {
free(state->path);
free(state);
return NULL;
}
if (state->mode == GZ_APPEND)
state->mode = GZ_WRITE; /* simplify later checks */
/* save the current position for rewinding (only if reading) */
if (state->mode == GZ_READ) {
state->start = LSEEK(state->fd, 0, SEEK_CUR);
if (state->start == -1) state->start = 0;
}
/* initialize stream */
gz_reset(state);
/* return stream */
return (gzFile)state;
}
void
main(int argc, char **argv)
{
Word *w;
char *s, *temp;
char *files[256], **f = files, **ff;
int sflag = 0;
int i;
int tfd = -1;
Biobuf tb;
Bufblock *buf;
Bufblock *whatif;
/*
* start with a copy of the current environment variables
* instead of sharing them
*/
Binit(&bout, 1, OWRITE);
buf = newbuf();
whatif = 0;
USED(argc);
for(argv++; *argv && (**argv == '-'); argv++)
{
bufcpy(buf, argv[0], strlen(argv[0]));
insert(buf, ' ');
switch(argv[0][1])
{
case 'a':
aflag = 1;
break;
case 'd':
if(*(s = &argv[0][2]))
while(*s) switch(*s++)
{
case 'p': debug |= D_PARSE; break;
case 'g': debug |= D_GRAPH; break;
case 'e': debug |= D_EXEC; break;
}
else
debug = 0xFFFF;
break;
case 'e':
explain = &argv[0][2];
break;
case 'f':
if(*++argv == 0)
badusage();
*f++ = *argv;
bufcpy(buf, argv[0], strlen(argv[0]));
insert(buf, ' ');
break;
case 'i':
iflag = 1;
break;
case 'k':
kflag = 1;
break;
case 'n':
nflag = 1;
break;
case 's':
sflag = 1;
break;
case 't':
tflag = 1;
break;
case 'u':
uflag = 1;
break;
case 'w':
if(whatif == 0)
whatif = newbuf();
else
insert(whatif, ' ');
if(argv[0][2])
bufcpy(whatif, &argv[0][2], strlen(&argv[0][2]));
else {
if(*++argv == 0)
badusage();
bufcpy(whatif, &argv[0][0], strlen(&argv[0][0]));
}
break;
default:
badusage();
}
}
#ifdef PROF
{
extern etext();
monitor(main, etext, buf, sizeof buf, 300);
}
#endif
if(aflag)
iflag = 1;
usage();
syminit();
initenv();
usage();
/*
assignment args become null strings
*/
temp = 0;
for(i = 0; argv[i]; i++) if(utfrune(argv[i], '=')){
bufcpy(buf, argv[i], strlen(argv[i]));
insert(buf, ' ');
if(tfd < 0){
temp = maketmp();
if(temp == 0) {
perror("temp file");
Exit();
}
close(create(temp, OWRITE, 0600));
if((tfd = open(temp, 2)) < 0){
perror(temp);
Exit();
}
Binit(&tb, tfd, OWRITE);
}
Bprint(&tb, "%s\n", argv[i]);
*argv[i] = 0;
}
if(tfd >= 0){
Bflush(&tb);
LSEEK(tfd, 0L, 0);
parse("command line args", tfd, 1);
remove(temp);
}
if (buf->current != buf->start) {
buf->current--;
insert(buf, 0);
}
symlook("MKFLAGS", S_VAR, (void *) stow(buf->start));
buf->current = buf->start;
for(i = 0; argv[i]; i++){
if(*argv[i] == 0) continue;
if(i)
insert(buf, ' ');
bufcpy(buf, argv[i], strlen(argv[i]));
}
insert(buf, 0);
symlook("MKARGS", S_VAR, (void *) stow(buf->start));
freebuf(buf);
if(f == files){
if(access(MKFILE, 4) == 0)
parse(MKFILE, open(MKFILE, 0), 0);
} else
for(ff = files; ff < f; ff++)
parse(*ff, open(*ff, 0), 0);
if(DEBUG(D_PARSE)){
dumpw("default targets", target1);
dumpr("rules", rules);
dumpr("metarules", metarules);
dumpv("variables");
}
if(whatif){
insert(whatif, 0);
timeinit(whatif->start);
freebuf(whatif);
}
execinit();
/* skip assignment args */
while(*argv && (**argv == 0))
argv++;
catchnotes();
if(*argv == 0){
if(target1)
for(w = target1; w; w = w->next)
mk(w->s);
else {
fprint(2, "mk: nothing to mk\n");
Exit();
}
} else {
if(sflag){
for(; *argv; argv++)
if(**argv)
mk(*argv);
} else {
Word *head, *tail, *t;
/* fake a new rule with all the args as prereqs */
tail = 0;
t = 0;
for(; *argv; argv++)
if(**argv){
if(tail == 0)
tail = t = newword(*argv);
else {
t->next = newword(*argv);
t = t->next;
}
}
if(tail->next == 0)
mk(tail->s);
else {
head = newword("command line arguments");
addrules(head, tail, strdup(""), VIR, mkinline, 0);
mk(head->s);
}
}
}
if(uflag)
prusage();
exits(0);
}
/* -- see zlib.h -- */
z_off64_t ZEXPORT gzseek64(
gzFile file,
z_off64_t offset,
int whence)
{
unsigned n;
z_off64_t ret;
gz_statep state;
/* get internal structure and check integrity */
if (file == NULL)
return -1;
state = (gz_statep)file;
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
return -1;
/* check that there's no error */
if (state->err != Z_OK)
return -1;
/* can only seek from start or relative to current position */
if (whence != SEEK_SET && whence != SEEK_CUR)
return -1;
/* normalize offset to a SEEK_CUR specification */
if (whence == SEEK_SET)
offset -= state->pos;
else if (state->seek)
offset += state->skip;
state->seek = 0;
/* if within raw area while reading, just go there */
if (state->mode == GZ_READ && state->how == COPY &&
state->pos + offset >= state->raw) {
ret = LSEEK(state->fd, offset - state->have, SEEK_CUR);
if (ret == -1)
return -1;
state->have = 0;
state->eof = 0;
state->seek = 0;
gz_error(state, Z_OK, NULL);
state->strm.avail_in = 0;
state->pos += offset;
return state->pos;
}
/* calculate skip amount, rewinding if needed for back seek when reading */
if (offset < 0) {
if (state->mode != GZ_READ) /* writing -- can't go backwards */
return -1;
offset += state->pos;
if (offset < 0) /* before start of file! */
return -1;
if (gzrewind(file) == -1) /* rewind, then skip to offset */
return -1;
}
/* if reading, skip what's in output buffer (one less gzgetc() check) */
if (state->mode == GZ_READ) {
n = GT_OFF(state->have) || (z_off64_t)state->have > offset ?
(unsigned)offset : state->have;
state->have -= n;
state->next += n;
state->pos += n;
offset -= n;
}
/* request skip (if not zero) */
if (offset) {
state->seek = 1;
state->skip = offset;
}
return state->pos + offset;
}
uint QFile::size() const
{
STATBUF st;
if ( isOpen() ) {
FSTAT( fh ? FILENO(fh) : fd, &st );
return st.st_size;
} else {
#if defined(__CYGWIN32_)
STAT( QFile::encodeName(fn), &st );
#else
QString str = fn;
reslashify(str);
#ifdef QT_LARGEFILE_SUPPORT
if ( _wstati64( (wchar_t*) str.ucs2(), &st ) != -1 ) {
#else
if ( _wstat( (wchar_t*) str.ucs2(), &st ) != -1 ) {
#endif
#endif
return st.st_size;
}
}
return 0;
}
/*!
\fn int QFile::at() const
Returns the file index.
\sa size()
*/
/*!
Sets the file index to \e pos. Returns TRUE if successful, otherwise FALSE.
Example:
\code
QFile f( "data.bin" );
f.open( IO_ReadOnly ); // index set to 0
f.at( 100 ); // set index to 100
f.at( f.at()+50 ); // set index to 150
f.at( f.size()-80 ); // set index to 80 before EOF
f.close();
\endcode
\warning The result is undefined if the file was \link open() opened\endlink
using the \c IO_Append specifier.
\sa size(), open()
*/
bool QFile::at( int pos )
{
if ( !isOpen() ) {
#if defined(CHECK_STATE)
qWarning( "QFile::at: File is not open" );
#endif
return FALSE;
}
bool ok;
if ( isRaw() ) { // raw file
pos = (int)LSEEK(fd, pos, SEEK_SET);
ok = pos != -1;
} else { // buffered file
ok = fseek(fh, pos, SEEK_SET) == 0;
}
if ( ok )
ioIndex = pos;
#if defined(CHECK_RANGE)
else
qWarning( "QFile::at: Cannot set file position %d", pos );
#endif
return ok;
}
/*!
Reads at most \e len bytes from the file into \e p and returns the
number of bytes actually read.
Returns -1 if a serious error occurred.
\warning We have experienced problems with some C libraries when a buffered
file is opened for both reading and writing. If a read operation takes place
immediately after a write operation, the read buffer contains garbage data.
Worse, the same garbage is written to the file. Calling flush() before
readBlock() solved this problem.
\sa writeBlock()
*/
int QFile::readBlock( char *p, uint len )
{
#if defined(CHECK_NULL)
if ( !p )
qWarning( "QFile::readBlock: Null pointer error" );
#endif
#if defined(CHECK_STATE)
if ( !isOpen() ) { // file not open
qWarning( "QFile::readBlock: File not open" );
return -1;
}
if ( !isReadable() ) { // reading not permitted
qWarning( "QFile::readBlock: Read operation not permitted" );
return -1;
}
#endif
int nread; // number of bytes read
if ( isRaw() ) { // raw file
nread = READ( fd, p, len );
if ( len && nread <= 0 ) {
nread = 0;
setStatus(IO_ReadError);
}
} else { // buffered file
nread = (int)fread( p, 1, len, fh );
if ( (uint)nread != len ) {
if ( ferror( fh ) || nread==0 )
setStatus(IO_ReadError);
}
}
ioIndex += nread;
return nread;
}
/*! \overload int writeBlock( const QByteArray& data )
*/
/*! \reimp
Writes \e len bytes from \e p to the file and returns the number of
bytes actually written.
Returns -1 if a serious error occurred.
\warning When working with buffered files, data may not be written
to the file at once. Call flush() to make sure the data is really
written.
\sa readBlock()
*/
int QFile::writeBlock( const char *p, uint len )
{
#if defined(CHECK_NULL)
if ( p == 0 && len != 0 )
qWarning( "QFile::writeBlock: Null pointer error" );
#endif
#if defined(CHECK_STATE)
if ( !isOpen() ) { // file not open
qWarning( "QFile::writeBlock: File not open" );
return -1;
}
if ( !isWritable() ) { // writing not permitted
qWarning( "QFile::writeBlock: Write operation not permitted" );
return -1;
}
#endif
int nwritten; // number of bytes written
if ( isRaw() ) // raw file
nwritten = WRITE( fd, p, len );
else // buffered file
nwritten = (int)fwrite( p, 1, len, fh );
if ( nwritten != (int)len ) { // write error
if ( errno == ENOSPC ) // disk is full
setStatus( IO_ResourceError );
else
setStatus( IO_WriteError );
if ( isRaw() ) // recalc file position
ioIndex = (int)LSEEK( fd, 0, SEEK_CUR );
else
ioIndex = fseek( fh, 0, SEEK_CUR );
} else {
ioIndex += nwritten;
}
if ( ioIndex > length ) // update file length
length = ioIndex;
return nwritten;
}
/*!
Returns the file handle of the file.
This is a small positive integer, suitable for use with C library
functions such as fdopen() and fcntl(), as well as with QSocketNotifier.
If the file is not open or there is an error, handle() returns -1.
\sa QSocketNotifier
*/
int QFile::handle() const
{
if ( !isOpen() )
return -1;
else if ( fh )
return FILENO( fh );
else
return fd;
}
/*!
Closes an open file.
The file is not closed if it was opened with an existing file handle.
If the existing file handle is a \c FILE*, the file is flushed.
If the existing file handle is an \c int file descriptor, nothing
is done to the file.
Some "write-behind" filesystems may report an unspecified error on
closing the file. These errors only indicate that something may
have gone wrong since the previous open(). In such a case status()
reports IO_UnspecifiedError after close(), otherwise IO_Ok.
\sa open(), flush()
*/
void QFile::close()
{
bool ok = FALSE;
if ( isOpen() ) { // file is not open
if ( fh ) { // buffered file
if ( ext_f )
ok = fflush( fh ) != -1; // flush instead of closing
else
ok = fclose( fh ) != -1;
} else { // raw file
if ( ext_f )
ok = TRUE; // cannot close
else
ok = CLOSE( fd ) != -1;
}
init(); // restore internal state
}
if (!ok)
setStatus (IO_UnspecifiedError);
return;
}
/*
* do_memmove: Worker function for memmove.
*
* Always work within the boundary of bytes. Fill in 1/2 of the src
* memory with the pattern we want to write. This allows us to check
* that we did not overwrite anything we were not supposed to in the
* dest. Use the non pmem version of the memset/memcpy commands
* so as not to introduce any possible side affects.
*/
static void
do_memmove(int fd, void *dest, void *src, char *file_name, off_t dest_off,
off_t src_off, off_t off, off_t bytes)
{
void *ret;
void *src1 = malloc(bytes);
void *buf = malloc(bytes);
char old;
memset(buf, 0, bytes);
memset(src1, 0, bytes);
memset(src, 0x5A, bytes / 4);
memset(src + bytes / 4, 0x54, bytes / 4);
/* dest == src */
old = *(char *)(dest + dest_off);
ret = pmem_memmove_persist(dest + dest_off, dest + dest_off, bytes / 2);
ASSERTeq(ret, dest + dest_off);
ASSERTeq(*(char *)(dest + dest_off), old);
/* len == 0 */
old = *(char *)(dest + dest_off);
ret = pmem_memmove_persist(dest + dest_off, src + src_off, 0);
ASSERTeq(ret, dest + dest_off);
ASSERTeq(*(char *)(dest + dest_off), old);
/*
* A side affect of the memmove call is that
* src contents will be changed in the case of overlapping
* addresses.
*/
memcpy(src1, src, bytes / 2);
ret = pmem_memmove_persist(dest + dest_off, src + src_off, bytes / 2);
ASSERTeq(ret, dest + dest_off);
/* memcmp will validate that what I expect in memory. */
if (memcmp(src1 + src_off, dest + dest_off, bytes / 2))
ERR("%s: %zu bytes do not match with memcmp",
file_name, bytes / 2);
/*
* This is a special case. An overlapping dest means that
* src is a pointer to the file, and destination is src + dest_off +
* overlap. This is the basis for the comparison. The use of ERR
* here is deliberate. This will force a failure of the test but allow
* it to continue until its done. The idea is that allowing some
* to succeed and others to fail gives more information about what
* went wrong.
*/
if (dest > src && off != 0) {
LSEEK(fd, (off_t)dest_off + off, SEEK_SET);
if (READ(fd, buf, bytes / 2) == bytes / 2) {
if (memcmp(src1 + src_off, buf, bytes / 2))
ERR("%s: first %zu bytes do not match",
file_name, bytes / 2);
}
} else {
LSEEK(fd, (off_t)dest_off, SEEK_SET);
if (READ(fd, buf, bytes / 2) == bytes / 2) {
if (memcmp(src1 + src_off, buf, bytes / 2))
ERR("%s: first %zu bytes do not match",
file_name, bytes / 2);
}
}
}
/**
* @param buffer can be NULL, in case when user want to just buffer it or skip some data.
*
* Global options that have efffect on this function are following
* 1) ccx_options.live_stream
* 2) ccx_options.buffer_input
* 3) ccx_options.input_source
* 4) ccx_options.binary_concat
*
* TODO instead of using global ccx_options move them to ccx_demuxer
*/
size_t buffered_read_opt (struct ccx_demuxer *ctx, unsigned char *buffer, size_t bytes)
{
size_t origin_buffer_size = bytes;
size_t copied = 0;
time_t seconds = 0;
position_sanity_check(ctx);
if (ccx_options.live_stream > 0)
time (&seconds);
if (ccx_options.buffer_input || ctx->filebuffer_pos < ctx->bytesinbuffer)
{
// Needs to return data from filebuffer_start+pos to filebuffer_start+pos+bytes-1;
int eof = (ctx->infd == -1);
while ((!eof || ccx_options.live_stream) && bytes)
{
if (terminate_asap)
break;
if (eof)
{
// No more data available inmediately, we sleep a while to give time
// for the data to come up
sleepandchecktimeout (seconds);
}
size_t ready = ctx->bytesinbuffer - ctx->filebuffer_pos;
if (ready == 0) // We really need to read more
{
if (!ccx_options.buffer_input)
{
// We got in the buffering code because of the initial buffer for
// detection stuff. However we don't want more buffering so
// we do the rest directly on the final buffer.
int i;
do
{
// No code for network support here, because network is always
// buffered - if here, then it must be files.
if (buffer != NULL) // Read
{
i = read (ctx->infd, buffer, bytes);
if( i == -1)
fatal (EXIT_READ_ERROR, "Error reading input file!\n");
buffer += i;
}
else // Seek
{
LLONG op, np;
op = LSEEK (ctx->infd, 0, SEEK_CUR); // Get current pos
if (op + bytes < 0) // Would mean moving beyond start of file: Not supported
return 0;
np = LSEEK (ctx->infd, bytes, SEEK_CUR); // Pos after moving
i = (int) (np - op);
}
// if both above lseek returned -1 (error); i would be 0 here and
// in case when its not live stream copied would decrease and bytes would...
if (i == 0 && ccx_options.live_stream)
{
if (ccx_options.input_source == CCX_DS_STDIN)
{
ccx_options.live_stream = 0;
break;
}
else
{
sleepandchecktimeout (seconds);
}
}
else
{
copied += i;
bytes -= i;
}
}
while ((i || ccx_options.live_stream ||
(ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied))) && bytes);
return copied;
}
// Keep the last 8 bytes, so we have a guaranteed
// working seek (-8) - needed by mythtv.
int keep = ctx->bytesinbuffer > 8 ? 8 : ctx->bytesinbuffer;
memmove (ctx->filebuffer, ctx->filebuffer+(FILEBUFFERSIZE-keep),keep);
int i;
if (ccx_options.input_source == CCX_DS_FILE || ccx_options.input_source == CCX_DS_STDIN)
i = read (ctx->infd, ctx->filebuffer + keep, FILEBUFFERSIZE-keep);
else if (ccx_options.input_source == CCX_DS_TCP)
i = net_tcp_read(ctx->infd, (char *) ctx->filebuffer + keep, FILEBUFFERSIZE - keep);
else
i = recvfrom(ctx->infd,(char *) ctx->filebuffer + keep, FILEBUFFERSIZE - keep, 0, NULL, NULL);
if (terminate_asap) /* Looks like receiving a signal here will trigger a -1, so check that first */
break;
if (i == -1)
fatal (EXIT_READ_ERROR, "Error reading input stream!\n");
if (i == 0)
{
/* If live stream, don't try to switch - acknowledge eof here as it won't
cause a loop end */
if (ccx_options.live_stream || ((struct lib_ccx_ctx *)ctx->parent)->inputsize <= origin_buffer_size || !(ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied)))
eof = 1;
}
ctx->filebuffer_pos = keep;
ctx->bytesinbuffer = (int) i + keep;
ready = i;
}
int copy = (int) (ready>=bytes ? bytes:ready);
if (copy)
{
if (buffer != NULL)
{
memcpy (buffer, ctx->filebuffer + ctx->filebuffer_pos, copy);
buffer += copy;
}
ctx->filebuffer_pos += copy;
bytes -= copy;
copied += copy;
}
}
}
else // Read without buffering
{
if (buffer != NULL)
{
int i;
while (bytes > 0 && ctx->infd != -1 &&
((i = read(ctx->infd, buffer, bytes)) != 0 || ccx_options.live_stream ||
(ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied))))
{
if (terminate_asap)
break;
if( i == -1)
fatal (EXIT_READ_ERROR, "Error reading input file!\n");
else if (i == 0)
sleepandchecktimeout (seconds);
else
{
copied += i;
bytes -= i;
buffer += i;
}
}
return copied;
}
while (bytes != 0 && ctx->infd != -1)
{
LLONG op, np;
if (terminate_asap)
break;
op = LSEEK (ctx->infd, 0, SEEK_CUR); // Get current pos
if (op + bytes < 0) // Would mean moving beyond start of file: Not supported
return 0;
np = LSEEK (ctx->infd, bytes, SEEK_CUR); // Pos after moving
if (op == -1 && np == -1) // Possibly a pipe that doesn't like "skipping"
{
char c;
for (size_t i = 0; i<bytes; i++) read(ctx->infd, &c, 1);
copied = bytes;
}
else
copied = copied + (np - op);
bytes = bytes- (unsigned int) copied;
if (copied == 0)
{
if (ccx_options.live_stream)
sleepandchecktimeout (seconds);
else
{
if (ccx_options.binary_concat)
switch_to_next_file(ctx->parent, 0);
else
break;
}
}
}
}
return copied;
}
int32_t drn_open(drn_t * cache, const char * filename, int mode)
{
int fd = OPEN(filename, OPEN_MODE);
if (fd <=0)
{
return -1;
}
cache->fd = fd;
cache->mmap_size = drn_fsize(fd);
cache->mode = mode;
if (mode == DRN_READ_NOLOAD)
{
uint64_t i;
size_t bytes;
drn_desc_t hashes_desc;
drn_map_container_t * map_containers;
cache->mmap_start = 0;
cache->data = 0;
cache->header = ALLOCATE(sizeof(drn_header_container_t));
bytes = READ(fd, cache->header, sizeof(drn_header_container_t));
assert(bytes == sizeof(drn_header_container_t));
if (drn_get_version(cache) != DRN_WRITER_VERSION)
return 1;
cache->descriptors = ALLOCATE(cache->header->chunk_count * sizeof(drn_desc_t));
LSEEK(fd, cache->header->index_offset, SEEK_SET);
bytes = READ(fd, cache->descriptors, READ_COUNT_CAST ((size_t) cache->header->chunk_count) * sizeof(drn_desc_t));
assert(bytes == cache->header->chunk_count * sizeof(drn_desc_t));
hashes_desc = drn_get_desc(cache, cache->header->maps_chunk_id);
cache->map_count = hashes_desc.size / sizeof(drn_map_container_t);
cache->maps = ALLOCATE(sizeof(drn_map_t) * (size_t) cache->map_count);
map_containers = ALLOCATE(hashes_desc.size);
drn_read_chunk(cache, cache->header->maps_chunk_id, map_containers);
for (i = 0; i < cache->map_count; ++i)
{
drn_desc_t d;
const drn_map_container_t * c = map_containers + i;
drn_map_t * h = cache->maps + i;
h->hash = ALLOCATE(drn_get_desc(cache, c->hash_chunk_id).size);
drn_read_chunk(cache, c->hash_chunk_id, (void *) h->hash);
h->name = ALLOCATE(drn_get_desc(cache, c->name_chunk_id).size);
drn_read_chunk(cache, c->name_chunk_id, (void *) h->name);
d = drn_get_desc(cache, c->descriptors_chunk_id);
h->chunk_count = d.size / sizeof(drn_hash_desc_t);
h->descriptors = ALLOCATE(d.size);
drn_read_chunk(cache, c->descriptors_chunk_id, (void *) h->descriptors);
h->value_strings = ALLOCATE(drn_get_desc(cache, c->value_strings_chunk_id).size);
drn_read_chunk(cache, c->value_strings_chunk_id, (void *)h->value_strings);
}
FREE(map_containers);
}
else
{
uint64_t i;
drn_desc_t maps_desc;
drn_map_container_t * map_containers;
if (mode == DRN_READ_MMAP)
{
#ifdef _MSC_VER
wchar_t * w_filename;
size_t bytes;
CLOSE(fd);
w_filename = ALLOCATE((strlen(filename)+1) * sizeof(wchar_t));
bytes = mbstowcs(w_filename, filename, strlen(filename)+1);
//cache->w_fhandle = CreateFile(L"test.drn", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
cache->w_fhandle = CreateFile(w_filename, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
FREE(w_filename);
if ((int) cache->w_fhandle == HFILE_ERROR)
{
DWORD err = GetLastError();
printf("ERROR %Ld\n", err);
return -1;
}
cache->w_mhandle = CreateFileMapping(cache->w_fhandle, NULL, PAGE_READONLY, 0, 0, NULL);
if (cache->w_mhandle == NULL)
{
DWORD err = GetLastError();
return -1;
}
cache->mmap_start = MapViewOfFile(cache->w_mhandle, FILE_MAP_READ, 0, 0, (size_t) cache->mmap_size);
if (cache->mmap_start == NULL)
{
DWORD err = GetLastError();
return -1;
}
#else
cache->mmap_start = mmap(0, cache->mmap_size, PROT_READ, MAP_PRIVATE, fd, 0);
CLOSE(fd);
#endif
}
else if (mode == DRN_READ_LOAD)
{
size_t bytes;
cache->mmap_start = ALLOCATE(cache->mmap_size);
bytes = READ(fd, cache->mmap_start, READ_COUNT_CAST (size_t) cache->mmap_size);
assert(bytes == cache->mmap_size);
CLOSE(fd);
}
cache->data = (char *) cache->mmap_start + sizeof(drn_header_container_t);
cache->header = (drn_header_container_t *) cache->mmap_start;
if (drn_get_version(cache) != DRN_WRITER_VERSION)
return 1;
cache->descriptors = (drn_desc_t *) ((char *)cache->mmap_start + cache->header->index_offset);
maps_desc = drn_get_desc(cache, cache->header->maps_chunk_id);
cache->map_count = maps_desc.size / sizeof(drn_map_container_t);
map_containers = (drn_map_container_t *) drn_get_chunk(cache, cache->header->maps_chunk_id);
cache->maps = ALLOCATE(sizeof(drn_map_t) * (size_t) cache->map_count);
for (i = 0; i < cache->map_count; ++i)
{
drn_desc_t d;
const drn_map_container_t * c = map_containers + i;
drn_map_t * h = cache->maps + i;
h->hash = drn_get_chunk(cache, c->hash_chunk_id);
h->name = drn_get_chunk(cache, c->name_chunk_id);
d = drn_get_desc(cache, c->descriptors_chunk_id);
h->chunk_count = d.size / sizeof(drn_hash_desc_t);
h->descriptors = drn_get_chunk(cache, c->descriptors_chunk_id);
h->value_strings = drn_get_chunk(cache, c->value_strings_chunk_id);
}
}
return 0;
}
int
main(int argc, char *argv[])
{
START(argc, argv, "pmem_map");
if (argc != 2)
FATAL("usage: %s file", argv[0]);
/* arrange to catch SEGV */
struct sigaction v;
sigemptyset(&v.sa_mask);
v.sa_flags = 0;
v.sa_handler = signal_handler;
SIGACTION(SIGSEGV, &v, NULL);
int fd;
void *addr;
fd = OPEN(argv[1], O_RDWR);
struct stat stbuf;
FSTAT(fd, &stbuf);
char pat[CHECK_BYTES];
char buf[CHECK_BYTES];
addr = pmem_map(fd);
if (addr == NULL) {
OUT("!pmem_map");
goto err;
}
/* write some pattern to the file */
memset(pat, 0x5A, CHECK_BYTES);
WRITE(fd, pat, CHECK_BYTES);
if (memcmp(pat, addr, CHECK_BYTES))
OUT("%s: first %d bytes do not match",
argv[1], CHECK_BYTES);
/* fill up mapped region with new pattern */
memset(pat, 0xA5, CHECK_BYTES);
memcpy(addr, pat, CHECK_BYTES);
pmem_unmap(addr, stbuf.st_size);
if (!sigsetjmp(Jmp, 1)) {
/* same memcpy from above should now fail */
memcpy(addr, pat, CHECK_BYTES);
} else {
OUT("unmap successful");
}
LSEEK(fd, (off_t)0, SEEK_SET);
if (READ(fd, buf, CHECK_BYTES) == CHECK_BYTES) {
if (memcmp(pat, buf, CHECK_BYTES))
OUT("%s: first %d bytes do not match",
argv[1], CHECK_BYTES);
}
CLOSE(fd);
/* re-open the file with read-only access */
fd = OPEN(argv[1], O_RDONLY);
addr = pmem_map(fd);
if (addr != NULL) {
MUNMAP(addr, stbuf.st_size);
OUT("expected pmem_map failure");
}
err:
CLOSE(fd);
DONE(NULL);
}
/*
* check_mapping -- check access to memory mapped file
*/
static void
check_mapping(int fd, char *addr, size_t len, int prot, int flags, off_t offset)
{
volatile int i;
/* arrange to catch SEGV */
struct sigaction v;
sigemptyset(&v.sa_mask);
v.sa_flags = 0;
v.sa_handler = signal_handler;
SIGACTION(SIGSEGV, &v, NULL);
char pat[PAGE_SIZE] = { 0 };
char buf[PAGE_SIZE];
if ((flags & CHECK_RO) == 0 && fd != -1) {
/* write some pattern to the file */
memset(pat, 0x5A, PAGE_SIZE);
for (i = 0; i < len / PAGE_SIZE; i++) {
LSEEK(fd, offset + PAGE_SIZE * i, SEEK_SET);
WRITE(fd, pat, PAGE_SIZE);
LSEEK(fd, offset + PAGE_SIZE * i, SEEK_SET);
if (READ(fd, buf, PAGE_SIZE) == PAGE_SIZE) {
if (memcmp(pat, buf, PAGE_SIZE))
UT_FATAL("first %d bytes do not match",
PAGE_SIZE);
}
}
}
check_access(addr, len, prot);
munmap(addr, len);
/* same memcpy from above should now fail */
for (i = 0; i < len / PAGE_SIZE; i++) {
if (!ut_sigsetjmp(Jmp)) {
memcpy(addr + PAGE_SIZE * i, pat, PAGE_SIZE);
UT_FATAL("unmap failed");
}
}
if (fd != -1) {
/* expected pattern */
if ((flags & (CHECK_PRIV | CHECK_RO)) != 0 ||
(prot & PROT_WRITE) == 0)
memset(pat, 0x5A, PAGE_SIZE);
else
memset(pat, 0xA5, PAGE_SIZE);
for (i = 0; i < len / PAGE_SIZE; i++) {
LSEEK(fd, offset + PAGE_SIZE * i, SEEK_SET);
if (READ(fd, buf, PAGE_SIZE) == PAGE_SIZE) {
if (memcmp(pat, buf, PAGE_SIZE))
UT_FATAL("first %d bytes do not match",
PAGE_SIZE);
}
}
}
}
int
main(int argc, char *argv[])
{
int fd;
size_t mapped_len;
char *dest;
char *dest1;
char *ret;
START(argc, argv, "pmem_memset");
if (argc != 4)
UT_FATAL("usage: %s file offset length", argv[0]);
fd = OPEN(argv[1], O_RDWR);
/* open a pmem file and memory map it */
if ((dest = pmem_map_file(argv[1], 0, 0, 0, &mapped_len, NULL)) == NULL)
UT_FATAL("!Could not mmap %s\n", argv[1]);
int dest_off = atoi(argv[2]);
size_t bytes = strtoul(argv[3], NULL, 0);
char *buf = MALLOC(bytes);
memset(dest, 0, bytes);
util_persist_auto(util_fd_is_device_dax(fd), dest, bytes);
dest1 = MALLOC(bytes);
memset(dest1, 0, bytes);
/*
* This is used to verify that the value of what a non persistent
* memset matches the outcome of the persistent memset. The
* persistent memset will match the file but may not be the
* correct or expected value.
*/
memset(dest1 + dest_off, 0x5A, bytes / 4);
memset(dest1 + dest_off + (bytes / 4), 0x46, bytes / 4);
/* Test the corner cases */
ret = pmem_memset_persist(dest + dest_off, 0x5A, 0);
UT_ASSERTeq(ret, dest + dest_off);
UT_ASSERTeq(*(char *)(dest + dest_off), 0);
/*
* Do the actual memset with persistence.
*/
ret = pmem_memset_persist(dest + dest_off, 0x5A, bytes / 4);
UT_ASSERTeq(ret, dest + dest_off);
ret = pmem_memset_persist(dest + dest_off + (bytes / 4),
0x46, bytes / 4);
UT_ASSERTeq(ret, dest + dest_off + (bytes / 4));
if (memcmp(dest, dest1, bytes / 2))
UT_ERR("%s: first %zu bytes do not match",
argv[1], bytes / 2);
LSEEK(fd, (off_t)0, SEEK_SET);
if (READ(fd, buf, bytes / 2) == bytes / 2) {
if (memcmp(buf, dest, bytes / 2))
UT_ERR("%s: first %zu bytes do not match",
argv[1], bytes / 2);
}
UT_ASSERTeq(pmem_unmap(dest, mapped_len), 0);
FREE(dest1);
FREE(buf);
CLOSE(fd);
DONE(NULL);
}
/* Open a gzip file either by name or file descriptor. */
local gzFile gz_open(
const void *path,
int fd,
const char *mode)
{
gz_statep state;
size_t len;
int oflag;
#ifdef O_CLOEXEC
int cloexec = 0;
#endif
#ifdef O_EXCL
int exclusive = 0;
#endif
/* check input */
if (path == NULL)
return NULL;
/* allocate gzFile structure to return */
state = (gz_statep)malloc(sizeof(gz_state));
if (state == NULL)
return NULL;
state->size = 0; /* no buffers allocated yet */
state->want = GZBUFSIZE; /* requested buffer size */
state->msg = NULL; /* no error message yet */
/* interpret mode */
state->mode = GZ_NONE;
state->level = Z_DEFAULT_COMPRESSION;
state->strategy = Z_DEFAULT_STRATEGY;
state->direct = 0;
while (*mode) {
if (*mode >= '0' && *mode <= '9')
state->level = *mode - '0';
else
switch (*mode) {
case 'r':
state->mode = GZ_READ;
break;
#ifndef NO_GZCOMPRESS
case 'w':
state->mode = GZ_WRITE;
break;
case 'a':
state->mode = GZ_APPEND;
break;
#endif
case '+': /* can't read and write at the same time */
free(state);
return NULL;
case 'b': /* ignore -- will request binary anyway */
break;
#ifdef O_CLOEXEC
case 'e':
cloexec = 1;
break;
#endif
#ifdef O_EXCL
case 'x':
exclusive = 1;
break;
#endif
case 'f':
state->strategy = Z_FILTERED;
break;
case 'h':
state->strategy = Z_HUFFMAN_ONLY;
break;
case 'R':
state->strategy = Z_RLE;
break;
case 'F':
state->strategy = Z_FIXED;
break;
case 'T':
state->direct = 1;
break;
default: /* could consider as an error, but just ignore */
;
}
mode++;
}
/* must provide an "r", "w", or "a" */
if (state->mode == GZ_NONE) {
free(state);
return NULL;
}
/* can't force transparent read */
if (state->mode == GZ_READ) {
if (state->direct) {
free(state);
return NULL;
}
state->direct = 1; /* for empty file */
}
/* save the path name for error messages */
#ifdef _WIN32
if (fd == -2) {
len = wcstombs(NULL, path, 0);
if (len == (size_t)-1)
len = 0;
}
else
#endif
len = strlen((const char *)path);
state->path = (char *)malloc(len + 1);
if (state->path == NULL) {
free(state);
return NULL;
}
#ifdef _WIN32
if (fd == -2)
if (len)
wcstombs(state->path, path, len + 1);
else
*(state->path) = 0;
else
#endif
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
snprintf(state->path, len + 1, "%s", (const char *)path);
#else
strcpy(state->path, path);
#endif
/* compute the flags for open() */
oflag =
#ifdef O_LARGEFILE
O_LARGEFILE |
#endif
#ifdef O_BINARY
O_BINARY |
#endif
#ifdef O_CLOEXEC
(cloexec ? O_CLOEXEC : 0) |
#endif
(state->mode == GZ_READ ?
O_RDONLY :
(O_WRONLY | O_CREAT |
#ifdef O_EXCL
(exclusive ? O_EXCL : 0) |
#endif
(state->mode == GZ_WRITE ?
O_TRUNC :
O_APPEND)));
/* open the file with the appropriate flags (or just use fd) */
state->fd = fd > -1 ? fd : (
#ifdef _WIN32
fd == -2 ? _wopen(path, oflag, 0666) :
#endif
open((const char *)path, oflag, 0666));
if (state->fd == -1) {
free(state->path);
free(state);
return NULL;
}
if (state->mode == GZ_APPEND)
state->mode = GZ_WRITE; /* simplify later checks */
/* save the current position for rewinding (only if reading) */
if (state->mode == GZ_READ) {
state->start = LSEEK(state->fd, 0, SEEK_CUR);
if (state->start == -1) state->start = 0;
}
/* initialize stream */
gz_reset(state);
/* return stream */
return (gzFile)state;
}
int main () {
int retval, i;
int fd;
int index_node_number;
/* Some arbitrary data for our files */
memset (data1, '1', sizeof (data1));
memset (data2, '2', sizeof (data1));
memset (data3, '3', sizeof (data1));
#ifdef TEST1
/* ****TEST 1: MAXIMUM file creation**** */
/* Generate MAXIMUM regular files */
for (i = 0; i < MAX_FILES + 1; i++) { // go beyond the limit
sprintf (pathname, "/file%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "creat: File creation error! status: %d\n",
retval);
if (i != MAX_FILES)
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
/* Delete all the files created */
for (i = 0; i < MAX_FILES; i++) {
sprintf (pathname, "/file%d", i);
retval = UNLINK (pathname);
if (retval < 0) {
fprintf (stderr, "unlink: File deletion error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
#endif // TEST1
#ifdef TEST2
/* ****TEST 2: LARGEST file size**** */
/* Generate one LARGEST file */
retval = CREAT ("/bigfile");
if (retval < 0) {
fprintf (stderr, "creat: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = OPEN ("/bigfile"); /* Open file to write to it */
if (retval < 0) {
fprintf (stderr, "open: File open error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
fd = retval; /* Assign valid fd */
/* Try writing to all direct data blocks */
retval = write (fd, data1, sizeof(data1));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE1 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#ifdef TEST_SINGLE_INDIRECT
/* Try writing to all single-indirect data blocks */
retval = write (fd, data2, sizeof(data2));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE2 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#ifdef TEST_DOUBLE_INDIRECT
/* Try writing to all double-indirect data blocks */
retval = write (fd, data3, sizeof(data3));
if (retval < 0) {
fprintf (stderr, "write: File write STAGE3 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#endif // TEST_DOUBLE_INDIRECT
#endif // TEST_SINGLE_INDIRECT
#endif // TEST2
#ifdef TEST3
/* ****TEST 3: Seek and Read file test**** */
retval = LSEEK (fd, 0); /* Go back to the beginning of your file */
if (retval < 0) {
fprintf (stderr, "lseek: File seek error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Try reading from all direct data blocks */
retval = READ (fd, addr, sizeof(data1));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE1 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 1s here... */
printf ("Data at addr: %s\n", addr);
#ifdef TEST_SINGLE_INDIRECT
/* Try reading from all single-indirect data blocks */
retval = READ (fd, addr, sizeof(data2));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE2 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 2s here... */
printf ("Data at addr: %s\n", addr);
#ifdef TEST_DOUBLE_INDIRECT
/* Try reading from all double-indirect data blocks */
retval = write (fd, addr, sizeof(data3));
if (retval < 0) {
fprintf (stderr, "read: File read STAGE3 error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Should be all 3s here... */
printf ("Data at addr: %s\n", addr);
#endif // TEST_DOUBLE_INDIRECT
#endif // TEST_SINGLE_INDIRECT
/* Close the bigfile */
retval = CLOSE(fd);
if (retval < 0) {
fprintf (stderr, "close: File close error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
/* Remove the biggest file */
retval = UNLINK ("/bigfile");
if (retval < 0) {
fprintf (stderr, "unlink: /bigfile file deletion error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
#endif // TEST3
#ifdef TEST4
/* ****TEST 4: Make directory and read directory entries**** */
retval = MKDIR ("/dir1");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 1 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = MKDIR ("/dir1/dir2");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 2 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = MKDIR ("/dir1/dir3");
if (retval < 0) {
fprintf (stderr, "mkdir: Directory 3 creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
retval = OPEN ("/dir1"); /* Open directory file to read its entries */
if (retval < 0) {
fprintf (stderr, "open: Directory open error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
fd = retval; /* Assign valid fd */
memset (addr, 0, sizeof(addr)); /* Clear scratchpad memory */
while ((retval = READDIR (fd, addr))) { /* 0 indicates end-of-file */
if (retval < 0) {
fprintf (stderr, "readdir: Directory read error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
index_node_number = atoi(&addr[14]);
printf ("Contents at addr: [%s,%d]\n", addr, index_node_number);
}
#endif // TEST4
#ifdef TEST5
/* ****TEST 5: 2 process test**** */
if((retval = fork())) {
if(retval == -1) {
fprintf(stderr, "Failed to fork\n");
exit(EXIT_FAILURE);
}
/* Generate 300 regular files */
for (i = 0; i < 300; i++) {
sprintf (pathname, "/file_p_%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "(Parent) create: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
}
else {
/* Generate 300 regular files */
for (i = 0; i < 300; i++) {
sprintf (pathname, "/file_c_%d", i);
retval = CREAT (pathname);
if (retval < 0) {
fprintf (stderr, "(Child) create: File creation error! status: %d\n",
retval);
exit(EXIT_FAILURE);
}
memset (pathname, 0, 80);
}
}
#endif // TEST5
printf("Congratulations, you have passed all tests!!\n");
return 0;
}
byte
FileSystem_FSTableMounter(FileSystem_MountInfo* FSMountInfo, MOUNT_TYPE mountType)
{
byte bStatus = FileSystem_SUCCESS ;
unsigned i, uiCopyPosition ;
FileSystem_BootBlock* FSBootBlock = &FSMountInfo->FSBootBlock ;
if(mountType == FS_MOUNT)
FSMountBuffer = (char*)malloc(sizeof(char) * FSBootBlock->BPB_FSTableSize * 512) ;
if(mountType == FS_UNMOUNT)
{
char bSectorBuffer[512] ;
bSectorBuffer[510] = 0x55 ; /* BootSector Signature */
bSectorBuffer[511] = 0xAA ;
printf("\n Sector Per Track @ UnMount = %d", FSMountInfo->FSBootBlock.BPB_SecPerTrk);
memcpy(&bSectorBuffer, (char*)&FSMountInfo->FSBootBlock, sizeof(FileSystem_BootBlock)) ;
if(LSEEK(fd_DiskImageFile, 512, SEEK_SET) < 0)
{
PUT_ERROR_MSG("LSEEK") ;
return EXTERNAL_ERROR ;
}
if(write(fd_DiskImageFile, (char*)bSectorBuffer, 512) < 0)
{
PUT_ERROR_MSG("WRITE") ;
return EXTERNAL_ERROR ;
}
}
if(LSEEK(fd_DiskImageFile, (FSBootBlock->BPB_RsvdSecCnt + 1) * 512, SEEK_SET) < 0)
{
PUT_ERROR_MSG("LSEEK") ;
return EXTERNAL_ERROR ;
}
for(i = 0, uiCopyPosition = 0; i < FSBootBlock->BPB_FSTableSize; i++, uiCopyPosition += 512)
{
if(mountType == FS_MOUNT)
{
if(read(fd_DiskImageFile, (char*)FSMountBuffer + uiCopyPosition, 512) < 0)
{
PUT_ERROR_MSG("READ") ;
return EXTERNAL_ERROR ;
}
}
else
{
if(write(fd_DiskImageFile, (char*)FSMountBuffer + uiCopyPosition, 512) < 0)
{
PUT_ERROR_MSG("WRITE") ;
return EXTERNAL_ERROR ;
}
}
}
return bStatus ;
}
static void ds_writeBlock(struct fileStore * fs, size_t blockNumber, void * value)
{
LSEEK((fs->data_file, blockNumber * fs->blockSize, SEEK_SET));
WRITE((fs->data_file, value, fs->blockSize));
}
static void
show_fstat_error (void)
{ static const char *filename = "fstat.dat" ;
static char data [256] ;
STATBUF statbuf ;
int fd, mode, flags ;
if (sizeof (statbuf.st_size) != sizeof (INT64))
{ printf ("\n\nLine %d: Error, sizeof (statbuf.st_size) != 8.\n\n", __LINE__) ;
return ;
} ;
puts ("\n64 bit fstat() test.\n--------------------") ;
printf ("0) Create a file, write %d bytes and close it.\n", SIGNED_SIZEOF (data)) ;
mode = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY ;
flags = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ;
if ((fd = open (filename, mode, flags)) < 0)
{ printf ("\n\nLine %d: open() failed : %s\n\n", __LINE__, strerror (errno)) ;
return ;
} ;
assert (write (fd, data, sizeof (data)) > 0) ;
close (fd) ;
printf ("1) Re-open file in read/write mode and write another %d bytes at the end.\n", SIGNED_SIZEOF (data)) ;
mode = O_RDWR | O_BINARY ;
flags = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ;
if ((fd = open (filename, mode, flags)) < 0)
{ printf ("\n\nLine %d: open() failed : %s\n\n", __LINE__, strerror (errno)) ;
return ;
} ;
LSEEK (fd, 0, SEEK_END) ;
assert (write (fd, data, sizeof (data)) > 0) ;
printf ("2) Now use system (\"%s %s\") to show the file length.\n\n", dir_cmd, filename) ;
/* Would use snprintf, but thats not really available on windows. */
memset (data, 0, sizeof (data)) ;
strncpy (data, dir_cmd, sizeof (data) - 1) ;
strncat (data, " ", sizeof (data) - 1 - strlen (data)) ;
strncat (data, filename, sizeof (data) - 1 - strlen (data)) ;
assert (system (data) >= 0) ;
puts ("") ;
printf ("3) Now use fstat() to get the file length.\n") ;
if (FSTAT (fd, &statbuf) != 0)
{ printf ("\n\nLine %d: fstat() returned error : %s\n", __LINE__, strerror (errno)) ;
return ;
} ;
printf ("4) According to fstat(), the file length is %ld, ", (long) statbuf.st_size) ;
close (fd) ;
if (statbuf.st_size != 2 * sizeof (data))
printf ("but thats just plain ***WRONG***.\n\n") ;
else
{ printf ("which is correct.\n\n") ;
unlink (filename) ;
} ;
} /* show_fstat_error */
