/*
* write the data and check if the data written to the proper position
* return 0 if position as expected, otherwise -1
*/
static int put_and_test(const char *alias, const char *buf, int size)
{
int code;
char test_buf[BIG_ENOUGH];
/* check arguments for sanity */
if(size < 0 || buf == NULL || alias == NULL) return -1;
/* put the data and update the channel size */
code = WRITE(alias, buf, size);
if(code != size) return code;
eofpos += code;
/* read from the start channel position (0) */
code = PREAD(alias, test_buf, size, 0);
ZTEST(code == size);
ZTEST(MEMCMP(buf, test_buf, size) != 0);
/* read from the current channel position (eofpos) */
code = PREAD(alias, test_buf, size, eofpos);
ZTEST(code == 0);
/* read from the proper alias position (eofpos - size) */
code = PREAD(alias, test_buf, size, eofpos - size);
ZTEST(code == size);
ZTEST(MEMCMP(buf, test_buf, size) == 0);
return 0;
}
int main(int argc, char **argv)
{
char buf[BIG_ENOUGH];
/* correct requests */
FPRINTF(STDERR, "TEST RANDOM WRITE ONLY CHANNEL\n");
FPRINTF(STDERR, "channel size = %ld\n", MANIFEST->channels[OPEN(RANWO)].size);
ZTEST(MANIFEST->channels[OPEN(RANWO)].size == 0);
ZTEST(PWRITE(RANWO, buf, 0, 0) == 0);
ZTEST(PWRITE(RANWO, buf, 0, 0) == 0);
ZTEST(PWRITE(RANWO, buf, 0, 1) == 0);
ZTEST(PWRITE(RANWO, buf, 1, 0) == 1);
ZTEST(PWRITE(RANWO, buf, 1,
MANIFEST->channels[OPEN(RANWO)].limits[PutSizeLimit] - 1) == 1);
ZTEST(PWRITE(RANWO, buf, 0, -1) == 0);
/* incorrect requests: NULL buffer */
ZTEST(PWRITE(RANWO, NULL, 0, 0) < 0);
ZTEST(PWRITE(RANWO, NULL, 0, 1) < 0);
ZTEST(PWRITE(RANWO, NULL, 1, 0) < 0);
ZTEST(PWRITE(RANWO, NULL, 1,
MANIFEST->channels[OPEN(RANWO)].limits[PutSizeLimit] - 1) < 0);
ZTEST(PWRITE(RANWO, NULL, 0, -1) < 0);
/* incorrect requests: size */
ZTEST(PWRITE(RANWO, buf, -1, 0) < 0);
/* incorrect requests: offset */
ZTEST(PWRITE(RANWO, buf, 0, -1) == 0);
ZTEST(PWRITE(RANWO, buf, 1, -1) < 0);
ZTEST(PWRITE(RANWO, buf, 1, MANIFEST->channels[OPEN(RANWO)].limits[PutSizeLimit]) < 0);
/* correct requests: reading of 0 bytes attempt */
ZTEST(PREAD(RANWO, buf, 0, 0) == 0);
/* incorrect requests: read attempt */
ZTEST(PREAD(RANWO, buf, 1, 0) < 0);
ZTEST(PREAD(RANWO, buf, 1, MANIFEST->channels[OPEN(RANWO)].limits[PutSizeLimit]) < 0);
/* incorrect requests: exhausted */
ZTEST(PWRITE(RANWO, buf, 31, 0) == 30);
ZTEST(PWRITE(RANWO, buf, 10, 0) < 0);
/* count errors and exit with it */
ZREPORT;
return 0;
}
int
do_test (int argc, char *argv[])
{
char buf[1000];
char res[1000];
int i;
memset (buf, '\0', sizeof (buf));
memset (res, '\xff', sizeof (res));
if (write (fd, buf, sizeof (buf)) != sizeof (buf))
error (EXIT_FAILURE, errno, "during write");
for (i = 100; i < 200; ++i)
buf[i] = i;
if (PWRITE (fd, buf + 100, 100, 100) != 100)
error (EXIT_FAILURE, errno, "during %s", STRINGIFY (PWRITE));
for (i = 450; i < 600; ++i)
buf[i] = i;
if (PWRITE (fd, buf + 450, 150, 450) != 150)
error (EXIT_FAILURE, errno, "during %s", STRINGIFY (PWRITE));
if (PREAD (fd, res, sizeof (buf) - 50, 50) != sizeof (buf) - 50)
error (EXIT_FAILURE, errno, "during %s", STRINGIFY (PREAD));
close (fd);
unlink (name);
return memcmp (buf + 50, res, sizeof (buf) - 50);
}
ssize_t NaClHostDescPRead(struct NaClHostDesc *d,
void *buf,
size_t len,
nacl_off64_t offset) {
ssize_t retval;
NaClHostDescCheckValidity("NaClHostDescPRead", d);
if (NACL_ABI_O_WRONLY == (d->flags & NACL_ABI_O_ACCMODE)) {
NaClLog(3, "NaClHostDescPRead: WRONLY file\n");
return -NACL_ABI_EBADF;
}
return ((-1 == (retval = PREAD(d->d, buf, len, offset)))
? -NaClXlateErrno(errno) : retval);
}
int ploop_copy_stop(struct ploop_copy_handle *h,
struct ploop_copy_stat *stat)
{
int ret;
int iter;
ploop_log(3, "pcopy last");
ret = freeze(h);
if (ret)
goto err;
iter = 1;
for (;;) {
ret = ploop_copy_next_iteration(h, stat);
if (ret)
goto err;
else if (stat->xferred == 0)
break;
if (iter++ > 2) {
ploop_err(0, "Too many iterations on frozen FS, aborting");
return SYSEXIT_LOOP;
}
}
if (!h->raw) {
/* Must clear dirty flag on ploop1 image. */
struct ploop_pvd_header *vh = get_free_iobuf(h);
if (PREAD(&h->idelta, vh, 4096, 0)) {
ret = SYSEXIT_READ;
goto err;
}
vh->m_DiskInUse = 0;
ploop_dbg(3, "Update header");
ret = send_buf(h, vh, 4096, 0);
if (ret)
goto err;
ret = send_optional_header(h);
if (ret)
goto err;
}
ploop_dbg(4, "IOCTL TRACK_STOP");
ret = ioctl(h->devfd, PLOOP_IOC_TRACK_STOP, 0);
if (ret)
goto err;
h->tracker_on = 0;
ploop_dbg(3, "SEND 0 0 (close)");
send_async(h, NULL, 0, 0);
pthread_join(h->send_th, NULL);
h->send_th = 0;
ploop_dbg(3, "pcopy stop done");
err:
ploop_copy_release(h);
return ret;
}
void
mpi_pci_attach(struct device *parent, struct device *self, void *aux)
{
struct mpi_pci_softc *psc = (void *)self;
struct mpi_softc *sc = &psc->psc_mpi;
struct pci_attach_args *pa = aux;
pcireg_t memtype;
int r;
pci_intr_handle_t ih;
const char *intrstr;
psc->psc_pc = pa->pa_pc;
psc->psc_tag = pa->pa_tag;
psc->psc_ih = NULL;
sc->sc_dmat = pa->pa_dmat;
sc->sc_ios = 0;
/* find the appropriate memory base */
for (r = PCI_MAPREG_START; r < PCI_MAPREG_END; r += sizeof(memtype)) {
memtype = pci_mapreg_type(psc->psc_pc, psc->psc_tag, r);
if ((memtype & PCI_MAPREG_TYPE_MASK) == PCI_MAPREG_TYPE_MEM)
break;
}
if (r >= PCI_MAPREG_END) {
printf(": unable to locate system interface registers\n");
return;
}
if (pci_mapreg_map(pa, r, memtype, 0, &sc->sc_iot, &sc->sc_ioh,
NULL, &sc->sc_ios, 0) != 0) {
printf(": unable to map system interface registers\n");
return;
}
/* disable the expansion rom */
PWRITE(psc, PCI_ROM_REG, PREAD(psc, PCI_ROM_REG) & ~PCI_ROM_ENABLE);
/* hook up the interrupt */
if (pci_intr_map(pa, &ih)) {
printf(": unable to map interrupt\n");
goto unmap;
}
intrstr = pci_intr_string(psc->psc_pc, ih);
psc->psc_ih = pci_intr_establish(psc->psc_pc, ih, IPL_BIO,
mpi_intr, sc, sc->sc_dev.dv_xname);
if (psc->psc_ih == NULL) {
printf(": unable to map interrupt%s%s\n",
intrstr == NULL ? "" : " at ",
intrstr == NULL ? "" : intrstr);
goto unmap;
}
printf(": %s", intrstr);
if (pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG) ==
PCI_ID_CODE(PCI_VENDOR_SYMBIOS, PCI_PRODUCT_SYMBIOS_1030))
sc->sc_flags |= MPI_F_SPI;
if (mpi_attach(sc) != 0) {
/* error printed by mpi_attach */
goto deintr;
}
return;
deintr:
pci_intr_disestablish(psc->psc_pc, psc->psc_ih);
psc->psc_ih = NULL;
unmap:
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
sc->sc_ios = 0;
}
int main(int argc, char **argv)
{
char buf[BIG_ENOUGH];
/* correct requests */
FPRINTF(STDERR, "TEST SEQUENTIAL READ ONLY CHANNEL\n");
FPRINTF(STDERR, "channel size = %lld\n", MANIFEST->channels[OPEN(SEQRO)].size);
ZTEST(MANIFEST->channels[OPEN(SEQRO)].size == 0);
ZTEST(PREAD(SEQRO, buf, 0, 0) == 0);
ZTEST(PREAD(SEQRO, buf, 0, 1) == 0);
ZTEST(PREAD(SEQRO, buf, 1, 0) == 1);
ZTEST(PREAD(SEQRO, buf, 1, MANIFEST->channels[OPEN(SEQRO)].size - 1) == 1);
ZTEST(PREAD(SEQRO, buf, 0, -1) == 0);
/* incorrect requests: NULL buffer */
ZTEST(PREAD(SEQRO, NULL, 0, 0) < 0);
ZTEST(PREAD(SEQRO, NULL, 0, 1) < 0);
ZTEST(PREAD(SEQRO, NULL, 1, 0) < 0);
ZTEST(PREAD(SEQRO, NULL, 1, MANIFEST->channels[OPEN(SEQRO)].size - 1) < 0);
ZTEST(PREAD(SEQRO, NULL, 0, -1) < 0);
/* incorrect requests: size */
ZTEST(PREAD(SEQRO, buf, -1, 0) < 0);
/* incorrect requests: offset */
ZTEST(PREAD(SEQRO, buf, 0, -1) == 0);
ZTEST(PREAD(SEQRO, buf, 1, -1) == 1);
ZTEST(PREAD(SEQRO, buf, 1, MANIFEST->channels[OPEN(SEQRO)].size) == 1);
/* correct requests: writing of 0 bytes attempt */
ZTEST(PWRITE(SEQRO, buf, 0, 0) == 0);
/* incorrect requests: write attempt */
ZTEST(PWRITE(SEQRO, buf, 1, 0) < 0);
ZTEST(PWRITE(SEQRO, buf, 1, MANIFEST->channels[OPEN(SEQRO)].size) < 0);
ZTEST(PWRITE(SEQRO, buf, 1, MANIFEST->channels[OPEN(SEQRO)].size - 1) < 0);
/* incorrect requests: exhausted */
ZTEST(PREAD(SEQRO, buf, 30, 0) == 28);
ZTEST(PREAD(SEQRO, buf, 10, 0) < 0);
/* count errors and exit with it */
ZREPORT;
return 0;
}
int main(int argc, char **argv)
{
int overall_errors = 0;
char buf[BIG_ENOUGH];
/*
* todo: add more cases for
* (un)successfull writes to not empty channel
* (un)successfull reads from not empty channel
*/
/* test (in)valid write cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST (IN)VALID CDR WRITE CASES\n");
ZTEST(PWRITE(STDRW_GOAT, buf, 0, 0) == 0); /* accessing 0 bytes is always ok */
ZTEST(PWRITE(STDRW_GOAT, buf, -1, -1) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDRW_GOAT, buf, -1, 0) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDRW_GOAT, buf, -1, 1) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDRW_GOAT, buf, 0, -1) == 0); /* accessing of 0 bytes is always ok */
ZTEST(PWRITE(STDRW_GOAT, buf, 1, -1) < 0); /* size = 1, offset invalid */
ZTEST(PWRITE(STDRW_GOAT, buf, 0, MANIFEST->channels[OPEN(STDRW_GOAT)].limits[PutSizeLimit] + 1) == 0);
ZTEST(PWRITE(STDRW_GOAT, buf, 1, MANIFEST->channels[OPEN(STDRW_GOAT)].limits[PutSizeLimit] + 1) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test (in)valid reead cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST (IN)VALID CDR READ CASES\n");
ZTEST(PREAD(STDRW_GOAT, buf, 0, 0) == 0); /* accessing 0 bytes is always ok */
ZTEST(PREAD(STDRW_GOAT, buf, -1, -1) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDRW_GOAT, buf, -1, 0) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDRW_GOAT, buf, -1, 1) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDRW_GOAT, buf, 0, -1) == 0); /* accessing 0 bytes is always ok */
ZTEST(PREAD(STDRW_GOAT, buf, 1, -1) < 0); /* valid size, invalid offset = fail */
ZTEST(PREAD(STDRW_GOAT, buf, 0, MANIFEST->channels[OPEN(STDRW_GOAT)].limits[PutSizeLimit] + 1) < 0);
ZTEST(PREAD(STDRW_GOAT, buf, 1, MANIFEST->channels[OPEN(STDRW_GOAT)].limits[PutSizeLimit] + 1) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test NULL buffer cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST NULL BUFFER CASES\n");
ZTEST(PWRITE(STDRW_GOAT, NULL, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, NULL, 0, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other invalid buffer address/size cases for pwrite */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER INVALID BUFFER/SIZE CASES FOR PWRITE\n");
ZTEST(PWRITE(STDRW_GOAT, (void*)0x1, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, (void*)0xffff, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x10000, -1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, MANIFEST->heap_ptr, MANIFEST->heap_size + 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x100000000LL - 0x1000001 - 0x10000, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x100000000LL, 1, 0) < 0);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x100000000LL - 0x1000000, 0x1000001, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other valid buffer address/size cases for pwrite */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER VALID BUFFER/SIZE CASES FOR PWRITE\n");
ZTEST(PWRITE(STDRW_GOAT, (void*)0x10000, 1, 0) == 1);
ZTEST(PWRITE(STDRW_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size - 1, 1, 0) == 1);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x100000000LL - 0x1000000, 1, 0) == 1);
ZTEST(PWRITE(STDRW_GOAT, (void*)0x100000000LL - 0x1, 1, 0) == 1);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other invalid buffer address/size cases for pread */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER INVALID BUFFER/SIZE CASES FOR PREAD\n");
ZTEST(PREAD(STDRW_GOAT, (char*)main, 1, 0) < 0);
ZTEST(PREAD(STDRW_GOAT, MANIFEST->heap_ptr, MANIFEST->heap_size + 1, 0) < 0);
ZTEST(PREAD(STDRW_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size, 1, 0) < 0);
ZTEST(PREAD(STDRW_GOAT, (void*)0x100000000LL - 0x1000001, 1, 0) < 0);
ZTEST(PREAD(STDRW_GOAT, (void*)0x100000000LL, 1, 0) < 0);
ZTEST(PREAD(STDRW_GOAT, (void*)0x100000000LL - 0x1000000, 0x1000001, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other valid buffer address/size cases for pread */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER VALID BUFFER/SIZE CASES FOR PREAD\n");
ZTEST(PREAD(STDRW_GOAT, &data_start, 1, 0) == 1);
ZTEST(PREAD(STDRW_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size - 1, 1, 0) == 1);
ZTEST(PREAD(STDRW_GOAT, (void*)0x100000000LL - 0x1000000, 1, 0) == 1);
ZTEST(PREAD(STDRW_GOAT, (void*)0x100000000LL - 0x1, 1, 0) == 1);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* exit with code */
if(overall_errors > 0)
FPRINTF(STDERR, "OVERALL TEST FAILED with %d errors\n", overall_errors);
else
FPRINTF(STDERR, "OVERALL TEST SUCCEED\n\n");
return overall_errors;
}
int main(int argc, char **argv)
{
int overall_errors = 0;
char buf[BIG_ENOUGH];
/* test an empty cdr channel */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST AN EMPTY CDR\n");
initial_put(STDCDR_EMPTY);
MSG_OK(STDCDR_EMPTY, "01234");
MSG_OK(STDCDR_EMPTY, "567");
MSG_OK(STDCDR_EMPTY, "89abcdefg");
MSG_OK(STDCDR_EMPTY, "zyx");
MSG_OK(STDCDR_EMPTY, "this is the end");
MSG_ERR(STDCDR_EMPTY, "this write should fail");
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test stubbed cdr channel */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST STUBBED CDR\n");
eofpos = MANIFEST->channels[OPEN(STDCDR_STUBBED)].size;
FPRINTF(STDERR, "%s size = %lld\n",
MANIFEST->channels[OPEN(STDCDR_STUBBED)].name, eofpos);
MSG_OK(STDCDR_STUBBED, "01234");
MSG_OK(STDCDR_STUBBED, "567");
MSG_OK(STDCDR_STUBBED, "89abcdefg");
MSG_OK(STDCDR_STUBBED, "zyx");
MSG_OK(STDCDR_STUBBED, "this is the end");
MSG_ERR(STDCDR_STUBBED, "this write should fail");
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test (in)valid write cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST (IN)VALID CDR WRITE CASES\n");
ZTEST(PWRITE(STDCDR_GOAT, buf, 0, 0) == 0); /* accessing 0 bytes is always ok */
ZTEST(PWRITE(STDCDR_GOAT, buf, -1, -1) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDCDR_GOAT, buf, -1, 0) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDCDR_GOAT, buf, -1, 1) < 0); /* invalid size, offset ignored = fail */
ZTEST(PWRITE(STDCDR_GOAT, buf, 0, -1) == 0); /* accessing of 0 bytes is always ok */
ZTEST(PWRITE(STDCDR_GOAT, buf, 1, -1) == 1); /* size = 1, offset ignored = 1 byte written */
ZTEST(PWRITE(STDCDR_GOAT, buf, 0, MANIFEST->channels[OPEN(STDCDR_GOAT)].limits[PutSizeLimit] + 1) == 0);
ZTEST(PWRITE(STDCDR_GOAT, buf, 1, MANIFEST->channels[OPEN(STDCDR_GOAT)].limits[PutSizeLimit] + 1) == 1);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test (in)valid read cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST (IN)VALID CDR READ CASES\n");
ZTEST(PREAD(STDCDR_GOAT, buf, 0, 0) == 0); /* accessing 0 bytes is always ok */
ZTEST(PREAD(STDCDR_GOAT, buf, -1, -1) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDCDR_GOAT, buf, -1, 0) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDCDR_GOAT, buf, -1, 1) < 0); /* invalid size, invalid offset = fail */
ZTEST(PREAD(STDCDR_GOAT, buf, 0, -1) == 0); /* accessing 0 bytes is always ok */
ZTEST(PREAD(STDCDR_GOAT, buf, 1, -1) < 0); /* valid size, invalid offset = fail */
ZTEST(PREAD(STDCDR_GOAT, buf, 0, MANIFEST->channels[OPEN(STDCDR_GOAT)].limits[PutSizeLimit] + 1) < 0);
ZTEST(PREAD(STDCDR_GOAT, buf, 1, MANIFEST->channels[OPEN(STDCDR_GOAT)].limits[PutSizeLimit] + 1) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test NULL buffer cases */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST NULL BUFFER CASES\n");
ZTEST(PWRITE(STDCDR_GOAT, NULL, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, NULL, 0, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other invalid buffer address/size cases for pwrite */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER INVALID BUFFER/SIZE CASES FOR PWRITE\n");
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x1, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0xffff, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x10000, -1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, MANIFEST->heap_ptr, MANIFEST->heap_size + 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x100000000LL - 0x1000001 - 0x10000, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x100000000LL, 1, 0) < 0);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x100000000LL - 0x1000000, 0x1000001, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other valid buffer address/size cases for pwrite */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER VALID BUFFER/SIZE CASES FOR PWRITE\n");
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x10000, 1, 0) == 1);
ZTEST(PWRITE(STDCDR_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size - 1, 1, 0) == 1);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x100000000LL - 0x1000000, 1, 0) == 1);
ZTEST(PWRITE(STDCDR_GOAT, (void*)0x100000000LL - 0x1, 1, 0) == 1);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other invalid buffer address/size cases for pread */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER INVALID BUFFER/SIZE CASES FOR PREAD\n");
ZTEST(PREAD(STDCDR_GOAT, (char*)main, 1, 0) < 0);
ZTEST(PREAD(STDCDR_GOAT, MANIFEST->heap_ptr, MANIFEST->heap_size + 1, 0) < 0);
ZTEST(PREAD(STDCDR_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size, 1, 0) < 0);
ZTEST(PREAD(STDCDR_GOAT, (void*)0x100000000LL - 0x1000001, 1, 0) < 0);
ZTEST(PREAD(STDCDR_GOAT, (void*)0x100000000LL, 1, 0) < 0);
ZTEST(PREAD(STDCDR_GOAT, (void*)0x100000000LL - 0x1000000, 0x1000001, 0) < 0);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* test other valid buffer address/size cases for pread */
ERRCOUNT = 0;
FPRINTF(STDERR, "TEST OTHER VALID BUFFER/SIZE CASES FOR PREAD\n");
ZTEST(PREAD(STDCDR_GOAT, &data_start, 1, 0) == 1);
ZTEST(PREAD(STDCDR_GOAT, MANIFEST->heap_ptr + MANIFEST->heap_size - 1, 1, 0) == 1);
ZTEST(PREAD(STDCDR_GOAT, (void*)0x100000000LL - 0x1000000, 1, 0) == 1);
ZTEST(PREAD(STDCDR_GOAT, (void*)0x100000000LL - 0x1, 1, 0) == 1);
overall_errors += ERRCOUNT;
FPRINTF(STDERR, ERRCOUNT ? "TEST FAILED\n\n" : "TEST SUCCEED\n\n");
/* exit with code */
if(overall_errors > 0)
FPRINTF(STDERR, "OVERALL TEST FAILED with %d errors\n", overall_errors);
else
FPRINTF(STDERR, "OVERALL TEST SUCCEED\n\n");
return overall_errors;
}
