/*
* Inject misc syscalls into the thing.
*/
static void domisc(int me, int fd, char *bits)
{
int chunk;
struct stat sb;
if (type > m_fstat)
type = m_fsync;
switch (type) {
case m_fsync:
if (fsync(fd) < 0) {
tst_brkm(TFAIL, NULL, "\tTest[%d]: fsync error %d.",
me,
errno);
}
break;
case m_trunc:
chunk = rand() % (file_max / csize);
file_max = CHUNK(chunk);
last_trunc = file_max;
if (tr_flag) {
if (ftruncate(fd, file_max) < 0) {
tst_brkm(TFAIL,
NULL,
"\tTest[%d]: ftruncate error %d @ 0x%x.",
me, errno, file_max);
}
tr_flag = 0;
} else {
if (truncate(test_name, file_max) < 0) {
tst_brkm(TFAIL,
NULL,
"\tTest[%d]: truncate error %d @ 0x%x.",
me, errno, file_max);
}
tr_flag = 1;
}
for (; chunk % 8 != 0; chunk++)
bits[chunk / 8] &= ~(1 << (chunk % 8));
for (; chunk < nchunks; chunk += 8)
bits[chunk / 8] = 0;
break;
case m_fstat:
if (fstat(fd, &sb) < 0) {
tst_brkm(TFAIL, NULL, "\tTest[%d]: fstat() error %d.",
me,
errno);
}
if (sb.st_size != file_max) {
tst_brkm(TFAIL,
NULL, "\tTest[%d]: fstat() mismatch; st_size=%"
PRIx64 ",file_max=%x.", me,
(int64_t) sb.st_size, file_max);
}
break;
}
++misc_cnt[type];
++type;
}
void tenkListChunks(PVOID heapHandle) {
struct HPool *heap;
struct DestroyStruct dStruct;
struct HeapChunk *curChunk;
ULONG i;
heap = getHeap(&heapModel, heapHandle);
dprintf("[T] Currently tracking %d chunks for heap 0x%08x\n",
heap->numChunks, heap->base);
i = heap->inUseHead;
while (i != NULLNODE) {
if (CHUNK(i).inUse) {
dprintf("\tAddress: 0x%08x\tSize: 0x%08x", CHUNK(i).addr, CHUNK(i).size);
dprintf("\tFlags: 0x%08x\t%s\n\n", CHUNK(i).flags,
(CHUNK(i).free)?"FREE'D":"IN USE");
}
i = CHUNK(i).nextInUse;
}
if (heap->numChunks == 0) {
dStruct.heapHandle = heap->base;
heapDestroy(&heapModel, &dStruct);
}
}
void tenkValidate(PVOID heapHandle) {
struct HPool *heap;
struct DestroyStruct dStruct;
struct HeapChunk *curChunk;
ULONG chunkPtr;
ULONG i, nextIndex;
BOOL screwed = FALSE;
heap = getHeap(&heapModel, heapHandle);
i = heap->inUseHead;
while (i != NULLNODE) {
if (CHUNK(i).free) {
// CHUNK(i).nextInUse must be equal to the next ptr
if(!ReadMemory((ULONG64)(CHUNK(i).addr)+4, (PVOID) &chunkPtr, 4, NULL)) {
dprintf("[T] Unable to read memory at address 0x%08x\n!");
return;
}
// Find next free chunk - continue if there are no more
nextIndex = CHUNK(i).nextInUse;
while (nextIndex != NULLNODE && !(CHUNK(nextIndex).free))
nextIndex = CHUNK(nextIndex).nextInUse;
if (nextIndex == NULLNODE) {
i = CHUNK(i).nextInUse;
continue;
}
// Validate next free chunk
if (CHUNK(nextIndex).addr != (PVOID) chunkPtr) {
dprintf("[T] Corruped next pointer for chunk at 0x%08x\n", CHUNK(i).addr);
dprintf(">\tGot: 0x%08x\tExpected: 0x%08x\n", chunkPtr, CHUNK(nextIndex).addr);
screwed = TRUE;
}
// next free chunk prev, must equal CHUNK(i).addr
if(!ReadMemory((ULONG64)CHUNK(nextIndex).addr, (PVOID) &chunkPtr, 4, NULL)) {
dprintf("[T] Unable to read memory at address 0x%08x\n!");
return;
}
if ((PVOID) chunkPtr != CHUNK(i).addr) {
dprintf("[T] Corruped prev pointer for chunk at 0x%08x\n", CHUNK(nextIndex).addr);
dprintf(">\tGot: 0x%08x\tExpected: 0x%08x\n", chunkPtr, CHUNK(i).addr);
screwed = TRUE;
}
} else {
}
i = CHUNK(i).nextInUse;
}
dprintf("[T] Validation complete: ");
if (!screwed)
dprintf("all known free chunks are correct\n");
else
dprintf("errors found\n");
}
static void dotest(int testers, int me, int fd)
{
char *bits, *buf;
char val, val0;
int count, collide, chunk, whenmisc, xfr, i;
/* Stuff for the readv call */
struct iovec r_iovec[MAXIOVCNT];
int r_ioveclen;
/* Stuff for the writev call */
struct iovec val0_iovec[MAXIOVCNT];
struct iovec val_iovec[MAXIOVCNT];
int w_ioveclen;
nchunks = max_size / (testers * csize);
whenmisc = 0;
if ((bits = malloc((nchunks + 7) / 8)) == NULL) {
tst_resm(TBROK, "\tmalloc failed(bits)");
tst_exit();
}
if ((buf = (malloc(csize))) == NULL) {
tst_resm(TBROK, "\tmalloc failed(buf)");
tst_exit();
}
/* Allocate memory for the iovec buffers and init the iovec arrays */
r_ioveclen = w_ioveclen = csize / MAXIOVCNT;
/* Please note that the above statement implies that csize
* be evenly divisible by MAXIOVCNT.
*/
for (i = 0; i < MAXIOVCNT; i++) {
if ((r_iovec[i].iov_base = malloc(r_ioveclen)) == NULL) {
tst_resm(TBROK, "\tmalloc failed(iov_base)");
tst_exit();
}
r_iovec[i].iov_len = r_ioveclen;
/* Allocate unused memory areas between all the buffers to
* make things more diffult for the OS.
*/
if (malloc((i + 1) * 8) == NULL) {
tst_resm(TBROK, "\tmalloc failed((i+1)*8)");
tst_exit();
}
if ((val0_iovec[i].iov_base = malloc(w_ioveclen)) == NULL) {
tst_resm(TBROK, "\tmalloc failed(val0_iovec)");
tst_exit();
}
val0_iovec[i].iov_len = w_ioveclen;
if (malloc((i + 1) * 8) == NULL) {
tst_resm(TBROK, "\tmalloc failed((i+1)*8)");
tst_exit();
}
if ((val_iovec[i].iov_base = malloc(w_ioveclen)) == NULL) {
tst_resm(TBROK, "\tmalloc failed(iov_base)");
tst_exit();
}
val_iovec[i].iov_len = w_ioveclen;
if (malloc((i + 1) * 8) == NULL) {
tst_resm(TBROK, "\tmalloc failed(((i+1)*8)");
tst_exit();
}
}
/*
* No init sectors; file-sys makes 0 to start.
*/
val = (64 / testers) * me + 1;
val0 = 0;
/*
* For each iteration:
* zap bits array
* loop:
* pick random chunk, read it.
* if corresponding bit off {
* verify == 0. (sparse file)
* ++count;
* } else
* verify == val.
* write "val" on it.
* repeat until count = nchunks.
* ++val.
*/
srand(getpid());
if (misc_intvl)
whenmisc = NEXTMISC;
while (iterations-- > 0) {
for (i = 0; i < NMISC; i++)
misc_cnt[i] = 0;
memset(bits, 0, (nchunks + 7) / 8);
/* Have to fill the val0 and val iov buffers in a different manner
*/
for (i = 0; i < MAXIOVCNT; i++) {
memset(val0_iovec[i].iov_base, val0,
val0_iovec[i].iov_len);
memset(val_iovec[i].iov_base, val,
val_iovec[i].iov_len);
}
count = 0;
collide = 0;
while (count < nchunks) {
chunk = rand() % nchunks;
/*
* Read it.
*/
if (lseek64(fd, CHUNK(chunk), 0) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: lseek64(0) fail at %"
PRIx64 "x, errno = %d.", me,
CHUNK(chunk), errno);
tst_exit();
}
if ((xfr = readv(fd, &r_iovec[0], MAXIOVCNT)) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: readv fail at %" PRIx64
"x, errno = %d.", me, CHUNK(chunk),
errno);
tst_exit();
}
/*
* If chunk beyond EOF just write on it.
* Else if bit off, haven't seen it yet.
* Else, have. Verify values.
*/
if (xfr == 0) {
bits[chunk / 8] |= (1 << (chunk % 8));
} else if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) {
if (xfr != csize) {
tst_resm(TFAIL,
"\tTest[%d]: xfr=%d != %d, zero read.",
me, xfr, csize);
tst_exit();
}
for (i = 0; i < MAXIOVCNT; i++) {
if (memcmp
(r_iovec[i].iov_base,
val0_iovec[i].iov_base,
r_iovec[i].iov_len)) {
tst_resm(TFAIL,
"\tTest[%d] bad verify @ 0x%"
PRIx64
" for val %d count %d xfr %d.",
me, CHUNK(chunk), val0,
count, xfr);
ft_dumpiov(&r_iovec[i]);
ft_dumpbits(bits,
(nchunks + 7) / 8);
tst_exit();
}
}
bits[chunk / 8] |= (1 << (chunk % 8));
++count;
} else {
if (xfr != csize) {
tst_resm(TFAIL,
"\tTest[%d]: xfr=%d != %d, val read.",
me, xfr, csize);
tst_exit();
}
++collide;
for (i = 0; i < MAXIOVCNT; i++) {
if (memcmp
(r_iovec[i].iov_base,
val_iovec[i].iov_base,
r_iovec[i].iov_len)) {
tst_resm(TFAIL,
"\tTest[%d] bad verify @ 0x%"
PRIx64
" for val %d count %d xfr %d.",
me, CHUNK(chunk), val,
count, xfr);
ft_dumpiov(&r_iovec[i]);
ft_dumpbits(bits,
(nchunks + 7) / 8);
tst_exit();
}
}
}
/*
* Write it.
*/
if (lseek64(fd, -xfr, 1) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: lseek64(1) fail at %"
PRIx64 ", errno = %d.", me,
CHUNK(chunk), errno);
tst_exit();
}
if ((xfr =
writev(fd, &val_iovec[0], MAXIOVCNT)) < csize) {
if (errno == ENOSPC) {
tst_resm(TFAIL,
"\tTest[%d]: no space, exiting.",
me);
fsync(fd);
tst_exit();
}
tst_resm(TFAIL,
"\tTest[%d]: writev fail at %" PRIx64
"x xfr %d, errno = %d.", me,
CHUNK(chunk), xfr, errno);
tst_exit();
}
/*
* If hit "misc" interval, do it.
*/
if (misc_intvl && --whenmisc <= 0) {
domisc(me, fd);
whenmisc = NEXTMISC;
}
if (count + collide > 2 * nchunks)
break;
}
/*
* End of iteration, maybe before doing all chunks.
*/
if (count < nchunks) {
//tst_resm(TINFO, "\tTest{%d} val %d stopping @ %d, collide = {%d}.",
// me, val, count, collide);
for (i = 0; i < nchunks; i++) {
if ((bits[i / 8] & (1 << (i % 8))) == 0) {
if (lseek64(fd, CHUNK(i), 0) <
(off64_t) 0) {
tst_resm(TFAIL,
"\tTest[%d]: lseek64 fail at %"
PRIx64
"x, errno = %d.", me,
CHUNK(i), errno);
tst_exit();
}
if (writev(fd, &val_iovec[0], MAXIOVCNT)
!= csize) {
tst_resm(TFAIL,
"\tTest[%d]: writev fail at %"
PRIx64
"x, errno = %d.", me,
CHUNK(i), errno);
tst_exit();
}
}
}
}
fsync(fd);
++misc_cnt[m_fsync];
//tst_resm(TINFO, "\tTest[%d] val %d done, count = %d, collide = %d.",
// me, val, count, collide);
//for (i = 0; i < NMISC; i++)
// tst_resm(TINFO, "\t\tTest[%d]: %d %s's.", me, misc_cnt[i], m_str[i]);
val0 = val++;
}
}
static void dotest(int testers, int me, int fd)
{
char *bits, *hold_bits;
char val;
int chunk, whenmisc, xfr, count, collide, i;
/* Stuff for the readv call */
struct iovec r_iovec[MAXIOVCNT];
int r_ioveclen;
/* Stuff for the writev call */
struct iovec val_iovec[MAXIOVCNT];
struct iovec zero_iovec[MAXIOVCNT];
int w_ioveclen;
nchunks = max_size / csize;
whenmisc = 0;
if ((bits = malloc((nchunks + 7) / 8)) == 0) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
if ((hold_bits = malloc((nchunks + 7) / 8)) == 0) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
/*Allocate memory for the iovec buffers and init the iovec arrays */
r_ioveclen = w_ioveclen = csize / MAXIOVCNT;
/* Please note that the above statement implies that csize
* be evenly divisible by MAXIOVCNT.
*/
for (i = 0; i < MAXIOVCNT; i++) {
if ((r_iovec[i].iov_base = calloc(r_ioveclen, 1)) == 0) {
tst_brkm(TBROK, NULL, "\tmalloc failed");
/* tst_exit(); */
}
r_iovec[i].iov_len = r_ioveclen;
/* Allocate unused memory areas between all the buffers to
* make things more diffult for the OS.
*/
if (malloc((i + 1) * 8) == NULL) {
tst_brkm(TBROK, NULL, "\tmalloc failed");
}
if ((val_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
val_iovec[i].iov_len = w_ioveclen;
if (malloc((i + 1) * 8) == NULL) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
if ((zero_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
zero_iovec[i].iov_len = w_ioveclen;
if (malloc((i + 1) * 8) == NULL) {
tst_resm(TBROK, "\tmalloc failed");
tst_exit();
}
}
/*
* No init sectors; allow file to be sparse.
*/
val = (64 / testers) * me + 1;
/*
* For each iteration:
* zap bits array
* loop
* pick random chunk, read it.
* if corresponding bit off {
* verify = 0. (sparse file)
* ++count;
* } else
* verify = val.
* write "val" on it.
* repeat unitl count = nchunks.
* ++val.
*/
srand(getpid());
if (misc_intvl)
whenmisc = NEXTMISC;
while (iterations-- > 0) {
for (i = 0; i < NMISC; i++)
misc_cnt[i] = 0;
ftruncate(fd, 0);
file_max = 0;
memset(bits, 0, (nchunks + 7) / 8);
memset(hold_bits, 0, (nchunks + 7) / 8);
/* Have to fill the val and zero iov buffers in a different manner
*/
for (i = 0; i < MAXIOVCNT; i++) {
memset(val_iovec[i].iov_base, val,
val_iovec[i].iov_len);
memset(zero_iovec[i].iov_base, 0,
zero_iovec[i].iov_len);
}
count = 0;
collide = 0;
while (count < nchunks) {
chunk = rand() % nchunks;
/*
* Read it.
*/
if (lseek(fd, CHUNK(chunk), 0) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: lseek(0) fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
if ((xfr = readv(fd, &r_iovec[0], MAXIOVCNT)) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: readv fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
/*
* If chunk beyond EOF just write on it.
* Else if bit off, haven't seen it yet.
* Else, have. Verify values.
*/
if (CHUNK(chunk) >= file_max) {
bits[chunk / 8] |= (1 << (chunk % 8));
++count;
} else if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) {
if (xfr != csize) {
tst_resm(TFAIL,
"\tTest[%d]: xfr=%d != %d, zero read.",
me, xfr, csize);
tst_exit();
}
for (i = 0; i < MAXIOVCNT; i++) {
if (memcmp
(r_iovec[i].iov_base,
zero_iovec[i].iov_base,
r_iovec[i].iov_len)) {
tst_resm(TFAIL,
"\tTest[%d] bad verify @ 0x%x for val %d count %d xfr %d file_max 0x%x, should be 0.",
me, CHUNK(chunk), val,
count, xfr, file_max);
tst_resm(TINFO,
"\tTest[%d]: last_trunc = 0x%x.",
me, last_trunc);
sync();
ft_dumpiov(&r_iovec[i]);
ft_dumpbits(bits,
(nchunks + 7) / 8);
ft_orbits(hold_bits, bits,
(nchunks + 7) / 8);
tst_resm(TINFO, "\tHold ");
ft_dumpbits(hold_bits,
(nchunks + 7) / 8);
tst_exit();
}
}
bits[chunk / 8] |= (1 << (chunk % 8));
++count;
} else {
if (xfr != csize) {
tst_resm(TFAIL,
"\tTest[%d]: xfr=%d != %d, val read.",
me, xfr, csize);
tst_exit();
}
++collide;
for (i = 0; i < MAXIOVCNT; i++) {
if (memcmp
(r_iovec[i].iov_base,
val_iovec[i].iov_base,
r_iovec[i].iov_len)) {
tst_resm(TFAIL,
"\tTest[%d] bad verify @ 0x%x for val %d count %d xfr %d file_max 0x%x.",
me, CHUNK(chunk), val,
count, xfr, file_max);
tst_resm(TINFO,
"\tTest[%d]: last_trunc = 0x%x.",
me, last_trunc);
sync();
ft_dumpiov(&r_iovec[i]);
ft_dumpbits(bits,
(nchunks + 7) / 8);
ft_orbits(hold_bits, bits,
(nchunks + 7) / 8);
tst_resm(TINFO, "\tHold ");
ft_dumpbits(hold_bits,
(nchunks + 7) / 8);
tst_exit();
}
}
}
/*
* Writev it.
*/
if (lseek(fd, -xfr, 1) < 0) {
tst_resm(TFAIL,
"\tTest[%d]: lseek(1) fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
if ((xfr =
writev(fd, &val_iovec[0], MAXIOVCNT)) < csize) {
if (errno == ENOSPC) {
tst_resm(TFAIL,
"\tTest[%d]: no space, exiting.",
me);
fsync(fd);
tst_exit();
}
tst_resm(TFAIL,
"\tTest[%d]: writev fail at %x xfr %d, errno = %d.",
me, CHUNK(chunk), xfr, errno);
tst_exit();
}
if (CHUNK(chunk) + csize > file_max)
file_max = CHUNK(chunk) + csize;
/*
* If hit "misc" interval, do it.
*/
if (misc_intvl && --whenmisc <= 0) {
ft_orbits(hold_bits, bits, (nchunks + 7) / 8);
domisc(me, fd, bits);
whenmisc = NEXTMISC;
}
if (count + collide > 2 * nchunks)
break;
}
/*
* End of iteration, maybe before doing all chunks.
*/
fsync(fd);
++misc_cnt[m_fsync];
//tst_resm(TINFO, "\tTest{%d} val %d done, count = %d, collide = {%d}",
// me, val, count, collide);
//for (i = 0; i < NMISC; i++)
// tst_resm(TINFO, "\t\tTest{%d}: {%d} %s's.", me, misc_cnt[i], m_str[i]);
++val;
}
}
/* XXX (garrcoop): should not be using libltp as it runs forked. */
static void dotest(int testers, int me, int fd)
{
char *bits, *hold_bits, *buf, *val_buf, *zero_buf;
char val;
int count, collide, chunk, whenmisc, xfr, i;
nchunks = max_size / csize;
if ((bits = calloc((nchunks + 7) / 8, 1)) == 0) {
tst_resm(TBROK,
"Test broken due to inability of malloc(bits).");
tst_exit();
}
if ((hold_bits = calloc((nchunks + 7) / 8, 1)) == 0) {
tst_resm(TBROK,
"Test broken due to inability of malloc(hold_bits).");
tst_exit();
}
if ((buf = (calloc(csize, 1))) == 0) {
tst_resm(TBROK, "Test broken due to inability of malloc(buf).");
tst_exit();
}
if ((val_buf = (calloc(csize, 1))) == 0) {
tst_resm(TBROK,
"Test broken due to inability of malloc(val_buf).");
tst_exit();
}
if ((zero_buf = (calloc(csize, 1))) == 0) {
tst_resm(TBROK,
"Test broken due to inability of malloc(zero_buf).");
tst_exit();
}
/*
* No init sectors; allow file to be sparse.
*/
val = (64 / testers) * me + 1;
/*
* For each iteration:
* zap bits array
* loop:
* pick random chunk, read it.
* if corresponding bit off {
* verify == 0. (sparse file)
* ++count;
* } else
* verify == val.
* write "val" on it.
* repeat until count = nchunks.
* ++val.
*/
srand(getpid());
if (misc_intvl)
whenmisc = NEXTMISC;
while (iterations-- > 0) {
for (i = 0; i < NMISC; i++)
misc_cnt[i] = 0;
ftruncate(fd, 0);
file_max = 0;
memset(bits, 0, (nchunks + 7) / 8);
memset(hold_bits, 0, (nchunks + 7) / 8);
memset(val_buf, val, csize);
memset(zero_buf, 0, csize);
count = 0;
collide = 0;
while (count < nchunks) {
chunk = rand() % nchunks;
/*
* Read it.
*/
if (lseek(fd, CHUNK(chunk), 0) < 0) {
tst_resm(TFAIL,
"Test[%d]: lseek(0) fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
if ((xfr = read(fd, buf, csize)) < 0) {
tst_resm(TFAIL,
"Test[%d]: read fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
/*
* If chunk beyond EOF just write on it.
* Else if bit off, haven't seen it yet.
* Else, have. Verify values.
*/
if (CHUNK(chunk) >= file_max) {
bits[chunk / 8] |= (1 << (chunk % 8));
++count;
} else if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) {
if (xfr != csize) {
tst_resm(TFAIL,
"Test[%d]: xfr=%d != %d, zero read.",
me, xfr, csize);
tst_exit();
}
if (memcmp(buf, zero_buf, csize)) {
tst_resm(TFAIL,
"Test[%d] bad verify @ 0x%x for val %d "
"count %d xfr %d file_max 0x%x, should be %d.",
me, CHUNK(chunk), val, count,
xfr, file_max, zero_buf[0]);
tst_resm(TFAIL,
"Test[%d]: last_trunc = 0x%x.",
me, last_trunc);
sync();
ft_dumpbuf(buf, csize);
ft_dumpbits(bits, (nchunks + 7) / 8);
ft_orbits(hold_bits, bits,
(nchunks + 7) / 8);
tst_resm(TINFO, "Hold ");
ft_dumpbits(hold_bits,
(nchunks + 7) / 8);
tst_exit();
}
bits[chunk / 8] |= (1 << (chunk % 8));
++count;
} else {
if (xfr != csize) {
tst_resm(TFAIL,
"\tTest[%d]: xfr=%d != %d, val read.",
me, xfr, csize);
tst_exit();
}
++collide;
if (memcmp(buf, val_buf, csize)) {
tst_resm(TFAIL,
"Test[%d] bad verify @ 0x%x for val %d "
"count %d xfr %d file_max 0x%x.",
me, CHUNK(chunk), val, count,
xfr, file_max);
tst_resm(TFAIL,
"Test[%d]: last_trunc = 0x%x.",
me, last_trunc);
sync();
ft_dumpbuf(buf, csize);
ft_dumpbits(bits, (nchunks + 7) / 8);
ft_orbits(hold_bits, bits,
(nchunks + 7) / 8);
tst_resm(TINFO, "Hold ");
ft_dumpbits(hold_bits,
(nchunks + 7) / 8);
tst_exit();
}
}
/*
* Write it.
*/
if (lseek(fd, -xfr, 1) < 0) {
tst_resm(TFAIL,
"Test[%d]: lseek(1) fail at %x, errno = %d.",
me, CHUNK(chunk), errno);
tst_exit();
}
if ((xfr = write(fd, val_buf, csize)) < csize) {
if (errno == ENOSPC) {
tst_resm(TFAIL,
"Test[%d]: no space, exiting.",
me);
fsync(fd);
tst_exit();
}
tst_resm(TFAIL,
"Test[%d]: write fail at %x xfr %d, errno = %d.",
me, CHUNK(chunk), xfr, errno);
tst_exit();
}
if (CHUNK(chunk) + csize > file_max)
file_max = CHUNK(chunk) + csize;
/*
* If hit "misc" interval, do it.
*/
if (misc_intvl && --whenmisc <= 0) {
ft_orbits(hold_bits, bits, (nchunks + 7) / 8);
domisc(me, fd, bits);
whenmisc = NEXTMISC;
}
if (count + collide > 2 * nchunks)
break;
}
/*
* End of iteration, maybe before doing all chunks.
*/
fsync(fd);
++misc_cnt[m_fsync];
//tst_resm(TINFO, "Test{%d} val %d done, count = %d, collide = {%d}",
// me, val, count, collide);
//for (i = 0; i < NMISC; i++)
// tst_resm(TINFO, "Test{%d}: {%d} %s's.", me, misc_cnt[i], m_str[i]);
++val;
}
}
////////////////////////////////////////////////////////////////////////////
//
// LoadLIBShape()
//
int LoadLIBShape(char *SLIB_Filename, char *Filename,struct Shape *SHP)
{
#define CHUNK(Name) (*ptr == *Name) && \
(*(ptr+1) == *(Name+1)) && \
(*(ptr+2) == *(Name+2)) && \
(*(ptr+3) == *(Name+3))
int RT_CODE;
FILE *fp;
char CHUNK[5];
char far *ptr;
memptr IFFfile = NULL;
unsigned long FileLen, size, ChunkLen;
int loop;
RT_CODE = 1;
// Decompress to ram and return ptr to data and return len of data in
// passed variable...
if (!LoadLIBFile(SLIB_Filename,Filename,&IFFfile))
Quit("Error Loading Compressed lib shape!");
// Evaluate the file
//
ptr = MK_FP(IFFfile,0);
if (!CHUNK("FORM"))
goto EXIT_FUNC;
ptr += 4;
FileLen = *(long far *)ptr;
SwapLong((long far *)&FileLen);
ptr += 4;
if (!CHUNK("ILBM"))
goto EXIT_FUNC;
ptr += 4;
FileLen += 4;
while (FileLen)
{
ChunkLen = *(long far *)(ptr+4);
SwapLong((long far *)&ChunkLen);
ChunkLen = (ChunkLen+1) & 0xFFFFFFFE;
if (CHUNK("BMHD"))
{
ptr += 8;
SHP->bmHdr.w = ((struct BitMapHeader far *)ptr)->w;
SHP->bmHdr.h = ((struct BitMapHeader far *)ptr)->h;
SHP->bmHdr.x = ((struct BitMapHeader far *)ptr)->x;
SHP->bmHdr.y = ((struct BitMapHeader far *)ptr)->y;
SHP->bmHdr.d = ((struct BitMapHeader far *)ptr)->d;
SHP->bmHdr.trans = ((struct BitMapHeader far *)ptr)->trans;
SHP->bmHdr.comp = ((struct BitMapHeader far *)ptr)->comp;
SHP->bmHdr.pad = ((struct BitMapHeader far *)ptr)->pad;
SwapWord(&SHP->bmHdr.w);
SwapWord(&SHP->bmHdr.h);
SwapWord(&SHP->bmHdr.x);
SwapWord(&SHP->bmHdr.y);
ptr += ChunkLen;
}
else
if (CHUNK("BODY"))
{
ptr += 4;
size = *((long far *)ptr);
ptr += 4;
SwapLong((long far *)&size);
SHP->BPR = (SHP->bmHdr.w+7) >> 3;
MM_GetPtr(&SHP->Data,size);
if (!SHP->Data)
goto EXIT_FUNC;
movedata(FP_SEG(ptr),FP_OFF(ptr),FP_SEG(SHP->Data),0,size);
ptr += ChunkLen;
break;
}
else
#define PATTERN(p,r) {{p,sizeof(p)-1},{r,sizeof(r)-1},{{0},0}}
#define CHUNK(c) {c,sizeof(c)-1}
AC_PATTERN_t patterns[] = {
PATTERN("city", "[S1]"), /* Replace "simplicity" with "[S1]" */
PATTERN("the ", ""), /* Replace "the " with an empty string */
PATTERN("and", NULL), /* Do not replace "and" */
PATTERN("experience", "[S2]"),
PATTERN("exp", "[S3]"),
PATTERN("simplicity", "[S4]"),
PATTERN("ease", "[S5]"),
};
#define PATTERN_COUNT (sizeof(patterns)/sizeof(AC_PATTERN_t))
AC_TEXT_t input_chunks[] = {
CHUNK("experience "),
CHUNK("the ease "),
CHUNK("and simpli"),
CHUNK("city of multifast"),
};
#define CHUNK_COUNT (sizeof(input_chunks)/sizeof(AC_TEXT_t))
/* Define a call-back function of type MF_REPLACE_CALBACK_f */
void listener (AC_TEXT_t *text, void *user);
/* The call-back function is called when:
* 1. the replacement buffer is full
* 2. the _rep_flush() is called
*
* Replacement buffer size is determined by the MF_REPLACEMENT_BUFFER_SIZE
* macro
////////////////////////////////////////////////////////////////////////////
//
// LoadLIBShape()
//
id0_int_t LoadLIBShape(const id0_char_t *SLIB_Filename, const id0_char_t *Filename,struct Shape *SHP)
{
#define CHUNK(Name) (*ptr == *Name) && \
(*(ptr+1) == *(Name+1)) && \
(*(ptr+2) == *(Name+2)) && \
(*(ptr+3) == *(Name+3))
id0_int_t RT_CODE;
//FILE *fp;
//id0_char_t CHUNK[5];
id0_char_t id0_far *ptr;
memptr IFFfile = NULL;
id0_unsigned_long_t FileLen, size, ChunkLen;
//id0_int_t loop;
RT_CODE = 1;
// Decompress to ram and return ptr to data and return len of data in
// passed variable...
if (!LoadLIBFile(SLIB_Filename,Filename,&IFFfile))
Quit("Error Loading Compressed lib shape!");
// Evaluate the file
//
ptr = (id0_char_t *)IFFfile;
//ptr = MK_FP(IFFfile,0);
if (!CHUNK("FORM"))
goto EXIT_FUNC;
ptr += 4;
memcpy(&FileLen, ptr, sizeof(id0_unsigned_long_t));
FileLen = BE_Cross_Swap32BE(FileLen);
//FileLen = *(id0_long_t id0_far *)ptr;
//SwapLong((id0_long_t id0_far *)&FileLen);
ptr += 4;
if (!CHUNK("ILBM"))
goto EXIT_FUNC;
ptr += 4;
FileLen += 4;
while (FileLen)
{
memcpy(&ChunkLen, (ptr+4), sizeof(id0_long_t));
ChunkLen = BE_Cross_Swap32BE(ChunkLen);
//ChunkLen = *(id0_long_t id0_far *)(ptr+4);
//SwapLong((id0_long_t id0_far *)&ChunkLen);
ChunkLen = (ChunkLen+1) & 0xFFFFFFFE;
if (CHUNK("BMHD"))
{
ptr += 8;
SHP->bmHdr.w = BE_Cross_Swap16BE(((struct BitMapHeader id0_far *)ptr)->w);
SHP->bmHdr.h = BE_Cross_Swap16BE(((struct BitMapHeader id0_far *)ptr)->h);
SHP->bmHdr.x = BE_Cross_Swap16BE(((struct BitMapHeader id0_far *)ptr)->x);
SHP->bmHdr.y = BE_Cross_Swap16BE(((struct BitMapHeader id0_far *)ptr)->y);
#if 0
SHP->bmHdr.w = ((struct BitMapHeader id0_far *)ptr)->w;
SHP->bmHdr.h = ((struct BitMapHeader id0_far *)ptr)->h;
SHP->bmHdr.x = ((struct BitMapHeader id0_far *)ptr)->x;
SHP->bmHdr.y = ((struct BitMapHeader id0_far *)ptr)->y;
#endif
SHP->bmHdr.d = ((struct BitMapHeader id0_far *)ptr)->d;
SHP->bmHdr.trans = ((struct BitMapHeader id0_far *)ptr)->trans;
SHP->bmHdr.comp = ((struct BitMapHeader id0_far *)ptr)->comp;
SHP->bmHdr.pad = ((struct BitMapHeader id0_far *)ptr)->pad;
#if 0
SwapWord(&SHP->bmHdr.w);
SwapWord(&SHP->bmHdr.h);
SwapWord(&SHP->bmHdr.x);
SwapWord(&SHP->bmHdr.y);
#endif
ptr += ChunkLen;
}
else
if (CHUNK("BODY"))
{
ptr += 4;
memcpy(&size, ptr, sizeof(id0_long_t));
size = BE_Cross_Swap32BE(size);
//size = *((id0_long_t id0_far *)ptr);
ptr += 4;
//SwapLong((id0_long_t id0_far *)&size);
SHP->BPR = (SHP->bmHdr.w+7) >> 3;
MM_GetPtr(&SHP->Data,size);
if (!SHP->Data)
goto EXIT_FUNC;
//movedata(FP_SEG(ptr),FP_OFF(ptr),FP_SEG(SHP->Data),0,size);
memcpy(SHP->Data,ptr,size);
ptr += ChunkLen;
break;
}
else
