titaniumtown/os161-assignments
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
Simon Gardling
2024-09-10 13:03:02 -04:00
parent 53c617d779
commit d66450e427
381 changed files with 28864 additions and 34170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3479
userland/testbin/frack/check.c
View File

File diff suppressed because it is too large Load Diff

8
userland/testbin/frack/check.h
View File

@@ -28,24 +28,22 @@
* SUCH DAMAGE.
*/
int check_createfile(unsigned name);
int check_openfile(unsigned name);
void check_closefile(int handle, unsigned name);
void check_write(int handle, unsigned name, unsigned code, unsigned seq,
off_t pos, off_t len);
off_t pos, off_t len);
void check_truncate(int handle, unsigned name, off_t len);
void check_mkdir(unsigned name);
void check_rmdir(unsigned name);
void check_unlink(unsigned name);
void check_link(unsigned from, unsigned to);
void check_rename(unsigned from, unsigned to);
void check_renamexd(unsigned fromdir, unsigned from,
unsigned todir, unsigned to);
void check_renamexd(unsigned fromdir, unsigned from, unsigned todir,
unsigned to);
void check_chdir(unsigned name);
void check_chdirup(void);
void check_sync(void);
void check_setup(void);
void checkfs(void);

257
userland/testbin/frack/data.c
View File

@@ -43,68 +43,51 @@
static char databuf[DATA_MAXSIZE];
static char readbuf[DATA_MAXSIZE];
static
void
prepdata(unsigned code, unsigned seq, char *buf, off_t len)
{
char smallbuf[32];
char letter;
size_t slen;
static void prepdata(unsigned code, unsigned seq, char *buf, off_t len) {
char smallbuf[32];
char letter;
size_t slen;
snprintf(smallbuf, sizeof(smallbuf), "%u@%u\n", seq, code);
slen = strlen(smallbuf);
snprintf(smallbuf, sizeof(smallbuf), "%u@%u\n", seq, code);
slen = strlen(smallbuf);
while (len >= slen) {
memcpy(buf, smallbuf, slen);
buf += slen;
len -= slen;
}
if (len > 1) {
letter = 'A' + (code + seq) % 26;
memset(buf, letter, len - 1);
buf += len - 1;
}
if (len > 0) {
*buf = '\n';
}
while (len >= slen) {
memcpy(buf, smallbuf, slen);
buf += slen;
len -= slen;
}
if (len > 1) {
letter = 'A' + (code + seq) % 26;
memset(buf, letter, len - 1);
buf += len - 1;
}
if (len > 0) {
*buf = '\n';
}
}
static
int
matches_at(size_t start, size_t len)
{
if (!memcmp(databuf + start, readbuf + start, len)) {
return 1;
}
return 0;
static int matches_at(size_t start, size_t len) {
if (!memcmp(databuf + start, readbuf + start, len)) {
return 1;
}
return 0;
}
static
int
byte_at(size_t start, size_t len, unsigned char val)
{
size_t i;
static int byte_at(size_t start, size_t len, unsigned char val) {
size_t i;
for (i=0; i<len; i++) {
if ((unsigned char)readbuf[start + i] != val) {
return 0;
}
}
return 1;
for (i = 0; i < len; i++) {
if ((unsigned char)readbuf[start + i] != val) {
return 0;
}
}
return 1;
}
static
int
zero_at(size_t start, size_t len)
{
return byte_at(start, len, 0);
}
static int zero_at(size_t start, size_t len) { return byte_at(start, len, 0); }
static
int
poison_at(size_t start, size_t len)
{
return byte_at(start, len, POISON_VAL);
static int poison_at(size_t start, size_t len) {
return byte_at(start, len, POISON_VAL);
}
/*
@@ -119,109 +102,93 @@ poison_at(size_t start, size_t len)
* CHECKSTART is the offset into the write region where we begin checking.
* CHECKLEN is the length of the region we check.
*/
int
data_matches(const char *namestr, off_t regionoffset,
unsigned code, unsigned seq, off_t zerostart, off_t len,
off_t checkstart, off_t checklen)
{
int ret;
off_t where;
size_t howmuch;
off_t absend, slop;
int data_matches(const char *namestr, off_t regionoffset, unsigned code,
unsigned seq, off_t zerostart, off_t len, off_t checkstart,
off_t checklen) {
int ret;
off_t where;
size_t howmuch;
off_t absend, slop;
assert(len <= DATA_MAXSIZE);
assert(checklen > 0);
assert(checklen <= len);
assert(checkstart >= 0 && checkstart < len);
assert(checkstart + checklen <= len);
assert(zerostart >= 0);
assert(zerostart <= len);
assert(len <= DATA_MAXSIZE);
assert(checklen > 0);
assert(checklen <= len);
assert(checkstart >= 0 && checkstart < len);
assert(checkstart + checklen <= len);
assert(zerostart >= 0);
assert(zerostart <= len);
prepdata(code, seq, databuf, len);
prepdata(code, seq, databuf, len);
ret = 1;
while (checklen > 0) {
/* check one block at a time */
where = checkstart;
howmuch = BLOCKSIZE;
/* no more than is left to do */
if (howmuch > checklen) {
howmuch = checklen;
}
/* if we stick over a block boundary, stop there */
absend = regionoffset + where + howmuch;
slop = absend % BLOCKSIZE;
if (slop != 0 && slop < howmuch) {
howmuch -= slop;
}
/* if we go past the zerostart point, stop there */
if (where < zerostart && where + howmuch > zerostart) {
howmuch = zerostart - where;
}
assert(howmuch > 0);
ret = 1;
while (checklen > 0) {
/* check one block at a time */
where = checkstart;
howmuch = BLOCKSIZE;
/* no more than is left to do */
if (howmuch > checklen) {
howmuch = checklen;
}
/* if we stick over a block boundary, stop there */
absend = regionoffset + where + howmuch;
slop = absend % BLOCKSIZE;
if (slop != 0 && slop < howmuch) {
howmuch -= slop;
}
/* if we go past the zerostart point, stop there */
if (where < zerostart && where + howmuch > zerostart) {
howmuch = zerostart - where;
}
assert(howmuch > 0);
if (matches_at(where, howmuch)) {
/* nothing */
}
else if (zero_at(where, howmuch)) {
if (where >= zerostart) {
printf("WARNING: file %s range %lld-%lld is "
"zeroed\n",
namestr, regionoffset + where,
regionoffset + where + howmuch);
}
else {
ret = 0;
}
}
else if (poison_at(where, howmuch)) {
if (where >= zerostart) {
printf("ERROR: file %s range %lld-%lld is "
"poisoned\n",
namestr, regionoffset + where,
regionoffset + where + howmuch);
}
else {
ret = 0;
}
}
else {
ret = 0;
}
if (matches_at(where, howmuch)) {
/* nothing */
} else if (zero_at(where, howmuch)) {
if (where >= zerostart) {
printf("WARNING: file %s range %lld-%lld is "
"zeroed\n",
namestr, regionoffset + where, regionoffset + where + howmuch);
} else {
ret = 0;
}
} else if (poison_at(where, howmuch)) {
if (where >= zerostart) {
printf("ERROR: file %s range %lld-%lld is "
"poisoned\n",
namestr, regionoffset + where, regionoffset + where + howmuch);
} else {
ret = 0;
}
} else {
ret = 0;
}
checkstart += howmuch;
checklen -= howmuch;
}
return ret;
checkstart += howmuch;
checklen -= howmuch;
}
return ret;
}
void
data_check(const char *namestr, off_t regionoffset,
unsigned code, unsigned seq, off_t zerostart, off_t len,
off_t checkstart, off_t checklen)
{
assert(zerostart >= 0);
assert(zerostart <= len);
void data_check(const char *namestr, off_t regionoffset, unsigned code,
unsigned seq, off_t zerostart, off_t len, off_t checkstart,
off_t checklen) {
assert(zerostart >= 0);
assert(zerostart <= len);
if (!data_matches(namestr, regionoffset,
code, seq, zerostart, len, checkstart, checklen)) {
printf("ERROR: file %s range %lld-%lld contains garbage\n",
namestr, regionoffset + checkstart,
regionoffset + checkstart + checklen);
}
if (!data_matches(namestr, regionoffset, code, seq, zerostart, len,
checkstart, checklen)) {
printf("ERROR: file %s range %lld-%lld contains garbage\n", namestr,
regionoffset + checkstart, regionoffset + checkstart + checklen);
}
}
void *
data_map(unsigned code, unsigned seq, off_t len)
{
assert(len <= DATA_MAXSIZE);
prepdata(code, seq, databuf, len);
return databuf;
void *data_map(unsigned code, unsigned seq, off_t len) {
assert(len <= DATA_MAXSIZE);
prepdata(code, seq, databuf, len);
return databuf;
}
void *
data_mapreadbuf(off_t len)
{
assert(len <= DATA_MAXSIZE);
return readbuf;
void *data_mapreadbuf(off_t len) {
assert(len <= DATA_MAXSIZE);
return readbuf;
}

12
userland/testbin/frack/data.h
View File

@@ -30,12 +30,12 @@
void *data_map(unsigned code, unsigned seq, off_t len);
void *data_mapreadbuf(off_t len);
int data_matches(const char *namestr, off_t regionoffset,
unsigned code, unsigned seq, off_t zerostart, off_t len,
off_t checkstart, off_t checklen);
void data_check(const char *namestr, off_t regionoffset,
unsigned code, unsigned seq, off_t zerostart, off_t len,
off_t checkstart, off_t checklen);
int data_matches(const char *namestr, off_t regionoffset, unsigned code,
unsigned seq, off_t zerostart, off_t len, off_t checkstart,
off_t checklen);
void data_check(const char *namestr, off_t regionoffset, unsigned code,
unsigned seq, off_t zerostart, off_t len, off_t checkstart,
off_t checklen);
#define DATA_MAXSIZE 65536
#define POISON_VAL 0xa9

293
userland/testbin/frack/do.c
View File

@@ -39,213 +39,180 @@
#include "name.h"
#include "do.h"
int
do_opendir(unsigned name)
{
const char *namestr;
int fd;
int do_opendir(unsigned name) {
const char *namestr;
int fd;
namestr = name_get(name);
fd = open(namestr, O_RDONLY);
if (fd < 0) {
err(1, "%s: opendir", namestr);
}
return fd;
namestr = name_get(name);
fd = open(namestr, O_RDONLY);
if (fd < 0) {
err(1, "%s: opendir", namestr);
}
return fd;
}
void
do_closedir(int fd, unsigned name)
{
if (close(fd)) {
warn("%s: closedir", name_get(name));
}
void do_closedir(int fd, unsigned name) {
if (close(fd)) {
warn("%s: closedir", name_get(name));
}
}
int
do_createfile(unsigned name)
{
const char *namestr;
int fd;
int do_createfile(unsigned name) {
const char *namestr;
int fd;
namestr = name_get(name);
fd = open(namestr, O_WRONLY|O_CREAT|O_EXCL, 0664);
if (fd < 0) {
err(1, "%s: create", namestr);
}
printf("create %s\n", namestr);
return fd;
namestr = name_get(name);
fd = open(namestr, O_WRONLY | O_CREAT | O_EXCL, 0664);
if (fd < 0) {
err(1, "%s: create", namestr);
}
printf("create %s\n", namestr);
return fd;
}
int
do_openfile(unsigned name, int dotrunc)
{
const char *namestr;
int fd;
int do_openfile(unsigned name, int dotrunc) {
const char *namestr;
int fd;
namestr = name_get(name);
fd = open(namestr, O_WRONLY | (dotrunc ? O_TRUNC : 0), 0664);
if (fd < 0) {
err(1, "%s: open", namestr);
}
return fd;
namestr = name_get(name);
fd = open(namestr, O_WRONLY | (dotrunc ? O_TRUNC : 0), 0664);
if (fd < 0) {
err(1, "%s: open", namestr);
}
return fd;
}
void
do_closefile(int fd, unsigned name)
{
if (close(fd)) {
warn("%s: close", name_get(name));
}
void do_closefile(int fd, unsigned name) {
if (close(fd)) {
warn("%s: close", name_get(name));
}
}
void
do_write(int fd, unsigned name, unsigned code, unsigned seq,
off_t pos, off_t len)
{
off_t done = 0;
ssize_t ret;
char *buf;
const char *namestr;
void do_write(int fd, unsigned name, unsigned code, unsigned seq, off_t pos,
off_t len) {
off_t done = 0;
ssize_t ret;
char *buf;
const char *namestr;
namestr = name_get(name);
buf = data_map(code, seq, len);
if (lseek(fd, pos, SEEK_SET) == -1) {
err(1, "%s: lseek to %lld", name_get(name), pos);
}
namestr = name_get(name);
buf = data_map(code, seq, len);
if (lseek(fd, pos, SEEK_SET) == -1) {
err(1, "%s: lseek to %lld", name_get(name), pos);
}
while (done < len) {
ret = write(fd, buf + done, len - done);
if (ret == -1) {
err(1, "%s: write %lld at %lld", name_get(name),
len, pos);
}
done += ret;
}
while (done < len) {
ret = write(fd, buf + done, len - done);
if (ret == -1) {
err(1, "%s: write %lld at %lld", name_get(name), len, pos);
}
done += ret;
}
printf("write %s: %lld at %lld\n", namestr, len, pos);
printf("write %s: %lld at %lld\n", namestr, len, pos);
}
void
do_truncate(int fd, unsigned name, off_t len)
{
const char *namestr;
void do_truncate(int fd, unsigned name, off_t len) {
const char *namestr;
namestr = name_get(name);
if (ftruncate(fd, len) == -1) {
err(1, "%s: truncate to %lld", namestr, len);
}
printf("truncate %s: to %lld\n", namestr, len);
namestr = name_get(name);
if (ftruncate(fd, len) == -1) {
err(1, "%s: truncate to %lld", namestr, len);
}
printf("truncate %s: to %lld\n", namestr, len);
}
void
do_mkdir(unsigned name)
{
const char *namestr;
void do_mkdir(unsigned name) {
const char *namestr;
namestr = name_get(name);
if (mkdir(namestr, 0775) == -1) {
err(1, "%s: mkdir", namestr);
}
printf("mkdir %s\n", namestr);
namestr = name_get(name);
if (mkdir(namestr, 0775) == -1) {
err(1, "%s: mkdir", namestr);
}
printf("mkdir %s\n", namestr);
}
void
do_rmdir(unsigned name)
{
const char *namestr;
void do_rmdir(unsigned name) {
const char *namestr;
namestr = name_get(name);
if (rmdir(namestr) == -1) {
err(1, "%s: rmdir", namestr);
}
printf("rmdir %s\n", namestr);
namestr = name_get(name);
if (rmdir(namestr) == -1) {
err(1, "%s: rmdir", namestr);
}
printf("rmdir %s\n", namestr);
}
void
do_unlink(unsigned name)
{
const char *namestr;
void do_unlink(unsigned name) {
const char *namestr;
namestr = name_get(name);
if (remove(namestr) == -1) {
err(1, "%s: remove", namestr);
}
printf("remove %s\n", namestr);
namestr = name_get(name);
if (remove(namestr) == -1) {
err(1, "%s: remove", namestr);
}
printf("remove %s\n", namestr);
}
void
do_link(unsigned from, unsigned to)
{
const char *fromstr, *tostr;
void do_link(unsigned from, unsigned to) {
const char *fromstr, *tostr;
fromstr = name_get(from);
tostr = name_get(to);
if (link(fromstr, tostr) == -1) {
err(1, "link %s to %s", fromstr, tostr);
}
printf("link %s %s\n", fromstr, tostr);
fromstr = name_get(from);
tostr = name_get(to);
if (link(fromstr, tostr) == -1) {
err(1, "link %s to %s", fromstr, tostr);
}
printf("link %s %s\n", fromstr, tostr);
}
void
do_rename(unsigned from, unsigned to)
{
const char *fromstr, *tostr;
void do_rename(unsigned from, unsigned to) {
const char *fromstr, *tostr;
fromstr = name_get(from);
tostr = name_get(to);
if (rename(fromstr, tostr) == -1) {
err(1, "rename %s to %s", fromstr, tostr);
}
printf("rename %s %s\n", fromstr, tostr);
fromstr = name_get(from);
tostr = name_get(to);
if (rename(fromstr, tostr) == -1) {
err(1, "rename %s to %s", fromstr, tostr);
}
printf("rename %s %s\n", fromstr, tostr);
}
void
do_renamexd(unsigned fromdir, unsigned from, unsigned todir, unsigned to)
{
char frombuf[64];
char tobuf[64];
void do_renamexd(unsigned fromdir, unsigned from, unsigned todir, unsigned to) {
char frombuf[64];
char tobuf[64];
strcpy(frombuf, name_get(fromdir));
strcat(frombuf, "/");
strcat(frombuf, name_get(from));
strcpy(frombuf, name_get(fromdir));
strcat(frombuf, "/");
strcat(frombuf, name_get(from));
strcpy(tobuf, name_get(todir));
strcat(tobuf, "/");
strcat(tobuf, name_get(to));
strcpy(tobuf, name_get(todir));
strcat(tobuf, "/");
strcat(tobuf, name_get(to));
if (rename(frombuf, tobuf) == -1) {
err(1, "rename %s to %s", frombuf, tobuf);
}
printf("rename %s %s\n", frombuf, tobuf);
if (rename(frombuf, tobuf) == -1) {
err(1, "rename %s to %s", frombuf, tobuf);
}
printf("rename %s %s\n", frombuf, tobuf);
}
void
do_chdir(unsigned name)
{
const char *namestr;
void do_chdir(unsigned name) {
const char *namestr;
namestr = name_get(name);
if (chdir(namestr) == -1) {
err(1, "chdir: %s", namestr);
}
printf("chdir %s\n", namestr);
namestr = name_get(name);
if (chdir(namestr) == -1) {
err(1, "chdir: %s", namestr);
}
printf("chdir %s\n", namestr);
}
void
do_chdirup(void)
{
if (chdir("..") == -1) {
err(1, "chdir: ..");
}
printf("chdir ..\n");
void do_chdirup(void) {
if (chdir("..") == -1) {
err(1, "chdir: ..");
}
printf("chdir ..\n");
}
void
do_sync(void)
{
if (sync()) {
warn("sync");
}
printf("sync\n");
printf("----------------------------------------\n");
void do_sync(void) {
if (sync()) {
warn("sync");
}
printf("sync\n");
printf("----------------------------------------\n");
}

5
userland/testbin/frack/do.h
View File

@@ -28,14 +28,13 @@
* SUCH DAMAGE.
*/
int do_opendir(unsigned name);
void do_closedir(int handle, unsigned name);
int do_createfile(unsigned name);
int do_openfile(unsigned name, int dotrunc);
void do_closefile(int handle, unsigned name);
void do_write(int handle, unsigned name, unsigned code, unsigned seq,
off_t pos, off_t len);
void do_write(int handle, unsigned name, unsigned code, unsigned seq, off_t pos,
off_t len);
void do_truncate(int handle, unsigned name, off_t len);
void do_mkdir(unsigned name);
void do_rmdir(unsigned name);

260
userland/testbin/frack/main.c
View File

@@ -37,160 +37,148 @@
#include "main.h"
struct workload {
const char *name;
const char *argname;
union {
void (*witharg)(const char *);
void (*noarg)(void);
} run;
const char *name;
const char *argname;
union {
void (*witharg)(const char *);
void (*noarg)(void);
} run;
};
#define WL(n) { .name = #n, .argname = NULL, .run.noarg = wl_##n }
#define WLA(n,a) { .name = #n, .argname = #a, .run.witharg = wl_##n }
#define WL(n) {.name = #n, .argname = NULL, .run.noarg = wl_##n}
#define WLA(n, a) {.name = #n, .argname = #a, .run.witharg = wl_##n}
static const struct workload workloads[] = {
WLA(createwrite, size),
WLA(rewrite, size),
WLA(randupdate, size),
WLA(truncwrite, size),
WLA(makehole, size),
WLA(fillhole, size),
WLA(truncfill, size),
WLA(append, size),
WLA(trunczero, size),
WLA(trunconeblock, size),
WLA(truncsmallersize, size),
WLA(trunclargersize, size),
WLA(appendandtrunczero, size),
WLA(appendandtruncpartly, size),
WL(mkfile),
WL(mkdir),
WL(mkmanyfile),
WL(mkmanydir),
WL(mktree),
WLA(mkrandtree, seed),
WL(rmfile),
WL(rmdir),
WL(rmfiledelayed),
WL(rmfiledelayedappend),
WL(rmdirdelayed),
WL(rmmanyfile),
WL(rmmanyfiledelayed),
WL(rmmanyfiledelayedandappend),
WL(rmmanydir),
WL(rmmanydirdelayed),
WL(rmtree),
WLA(rmrandtree, seed),
WL(linkfile),
WL(linkmanyfile),
WL(unlinkfile),
WL(unlinkmanyfile),
WL(linkunlinkfile),
WL(renamefile),
WL(renamedir),
WL(renamesubtree),
WL(renamexdfile),
WL(renamexddir),
WL(renamexdsubtree),
WL(renamemanyfile),
WL(renamemanydir),
WL(renamemanysubtree),
WL(copyandrename),
WL(untar),
WL(compile),
WL(cvsupdate),
WLA(writefileseq, seed),
WLA(writetruncseq, seed),
WLA(mkrmseq, seed),
WLA(linkunlinkseq, seed),
WLA(renameseq, seed),
WLA(diropseq, seed),
WLA(genseq, seed),
WLA(createwrite, size),
WLA(rewrite, size),
WLA(randupdate, size),
WLA(truncwrite, size),
WLA(makehole, size),
WLA(fillhole, size),
WLA(truncfill, size),
WLA(append, size),
WLA(trunczero, size),
WLA(trunconeblock, size),
WLA(truncsmallersize, size),
WLA(trunclargersize, size),
WLA(appendandtrunczero, size),
WLA(appendandtruncpartly, size),
WL(mkfile),
WL(mkdir),
WL(mkmanyfile),
WL(mkmanydir),
WL(mktree),
WLA(mkrandtree, seed),
WL(rmfile),
WL(rmdir),
WL(rmfiledelayed),
WL(rmfiledelayedappend),
WL(rmdirdelayed),
WL(rmmanyfile),
WL(rmmanyfiledelayed),
WL(rmmanyfiledelayedandappend),
WL(rmmanydir),
WL(rmmanydirdelayed),
WL(rmtree),
WLA(rmrandtree, seed),
WL(linkfile),
WL(linkmanyfile),
WL(unlinkfile),
WL(unlinkmanyfile),
WL(linkunlinkfile),
WL(renamefile),
WL(renamedir),
WL(renamesubtree),
WL(renamexdfile),
WL(renamexddir),
WL(renamexdsubtree),
WL(renamemanyfile),
WL(renamemanydir),
WL(renamemanysubtree),
WL(copyandrename),
WL(untar),
WL(compile),
WL(cvsupdate),
WLA(writefileseq, seed),
WLA(writetruncseq, seed),
WLA(mkrmseq, seed),
WLA(linkunlinkseq, seed),
WLA(renameseq, seed),
WLA(diropseq, seed),
WLA(genseq, seed),
};
static const unsigned numworkloads = sizeof(workloads) / sizeof(workloads[0]);
#undef WL
#undef WLA
static
const struct workload *
findworkload(const char *name)
{
unsigned i;
static const struct workload *findworkload(const char *name) {
unsigned i;
for (i=0; i<numworkloads; i++) {
if (!strcmp(workloads[i].name, name)) {
return &workloads[i];
}
}
return NULL;
for (i = 0; i < numworkloads; i++) {
if (!strcmp(workloads[i].name, name)) {
return &workloads[i];
}
}
return NULL;
}
static
void
printworkloads(void)
{
unsigned i;
static void printworkloads(void) {
unsigned i;
printf("Supported workloads:\n");
for (i=0; i<numworkloads; i++) {
printf(" %s", workloads[i].name);
if (workloads[i].argname) {
printf(" %s", workloads[i].argname);
}
printf("\n");
}
printf("Supported workloads:\n");
for (i = 0; i < numworkloads; i++) {
printf(" %s", workloads[i].name);
if (workloads[i].argname) {
printf(" %s", workloads[i].argname);
}
printf("\n");
}
}
int
main(int argc, char *argv[])
{
const char *workloadname;
const struct workload *workload;
int checkmode = 0;
int main(int argc, char *argv[]) {
const char *workloadname;
const struct workload *workload;
int checkmode = 0;
if (argc == 2 && !strcmp(argv[1], "list")) {
printworkloads();
exit(0);
}
if (argc == 2 && !strcmp(argv[1], "list")) {
printworkloads();
exit(0);
}
if (argc < 3) {
warnx("Usage: %s do|check workload [arg]", argv[0]);
warnx("Use \"list\" for a list of workloads");
exit(1);
}
if (argc < 3) {
warnx("Usage: %s do|check workload [arg]", argv[0]);
warnx("Use \"list\" for a list of workloads");
exit(1);
}
if (!strcmp(argv[1], "do")) {
checkmode = 0;
}
else if (!strcmp(argv[1], "check")) {
checkmode = 1;
}
else {
errx(1, "Action must be \"do\" or \"check\"");
}
if (!strcmp(argv[1], "do")) {
checkmode = 0;
} else if (!strcmp(argv[1], "check")) {
checkmode = 1;
} else {
errx(1, "Action must be \"do\" or \"check\"");
}
workloadname = argv[2];
workload = findworkload(workloadname);
if (workload == NULL) {
errx(1, "Unknown workload %s\n", workloadname);
printworkloads();
exit(1);
}
setcheckmode(checkmode);
if (workload->argname) {
if (argc != 4) {
errx(1, "%s requires argument %s\n",
workloadname, workload->argname);
}
workload->run.witharg(argv[3]);
}
else {
if (argc != 3) {
errx(1, "Stray argument for workload %s",workloadname);
}
workload->run.noarg();
}
complete();
return 0;
workloadname = argv[2];
workload = findworkload(workloadname);
if (workload == NULL) {
errx(1, "Unknown workload %s\n", workloadname);
printworkloads();
exit(1);
}
setcheckmode(checkmode);
if (workload->argname) {
if (argc != 4) {
errx(1, "%s requires argument %s\n", workloadname, workload->argname);
}
workload->run.witharg(argv[3]);
} else {
if (argc != 3) {
errx(1, "Stray argument for workload %s", workloadname);
}
workload->run.noarg();
}
complete();
return 0;
}

67
userland/testbin/frack/name.c
View File

@@ -37,57 +37,28 @@
#define MAXNAMES 32
static const char *const names[MAXNAMES] = {
"allspice",
"anise",
"basil",
"cardamom",
"cayenne",
"cilantro",
"cinnamon",
"cloves",
"coriander",
"cumin",
"dill",
"fennel",
"fenugreek",
"galangal",
"ginger",
"horseradish",
"lemongrass",
"licorice",
"mace",
"marjoram",
"mustard",
"nutmeg",
"oregano",
"parsley",
"paprika",
"pepper",
"saffron",
"sage",
"rosemary",
"thyme",
"turmeric",
"wasabi",
"allspice", "anise", "basil", "cardamom", "cayenne",
"cilantro", "cinnamon", "cloves", "coriander", "cumin",
"dill", "fennel", "fenugreek", "galangal", "ginger",
"horseradish", "lemongrass", "licorice", "mace", "marjoram",
"mustard", "nutmeg", "oregano", "parsley", "paprika",
"pepper", "saffron", "sage", "rosemary", "thyme",
"turmeric", "wasabi",
};
const char *
name_get(unsigned name)
{
assert(name < MAXNAMES);
return names[name];
const char *name_get(unsigned name) {
assert(name < MAXNAMES);
return names[name];
}
unsigned
name_find(const char *namestr)
{
unsigned i;
unsigned name_find(const char *namestr) {
unsigned i;
for (i=0; i<MAXNAMES; i++) {
if (!strcmp(namestr, names[i])) {
return i;
}
}
errx(1, "Encountered unknown/unexpected name %s", namestr);
return 0;
for (i = 0; i < MAXNAMES; i++) {
if (!strcmp(namestr, names[i])) {
return i;
}
}
errx(1, "Encountered unknown/unexpected name %s", namestr);
return 0;
}

1
userland/testbin/frack/name.h
View File

@@ -28,6 +28,5 @@
* SUCH DAMAGE.
*/
const char *name_get(unsigned name);
unsigned name_find(const char *namestr);

362
userland/testbin/frack/ops.c
View File

@@ -41,26 +41,24 @@
#include "main.h"
struct file {
unsigned name;
unsigned testcode;
unsigned seq;
int handle;
unsigned name;
unsigned testcode;
unsigned seq;
int handle;
};
struct dir {
unsigned name;
int handle;
unsigned name;
int handle;
};
static int checkmode;
void
setcheckmode(int mode)
{
checkmode = mode;
if (checkmode) {
check_setup();
}
void setcheckmode(int mode) {
checkmode = mode;
if (checkmode) {
check_setup();
}
}
////////////////////////////////////////////////////////////
@@ -69,33 +67,27 @@ setcheckmode(int mode)
#define MAXDIRS 32
DECLPOOL(dir, MAXDIRS);
struct dir *
op_opendir(unsigned name)
{
struct dir *ret;
struct dir *op_opendir(unsigned name) {
struct dir *ret;
ret = POOLALLOC(dir);
ret->name = name;
if (checkmode) {
ret->handle = -1;
}
else {
ret->handle = do_opendir(name);
}
return ret;
ret = POOLALLOC(dir);
ret->name = name;
if (checkmode) {
ret->handle = -1;
} else {
ret->handle = do_opendir(name);
}
return ret;
}
void
op_closedir(struct dir *d)
{
if (checkmode) {
/* nothing */
(void)d;
}
else {
do_closedir(d->handle, d->name);
}
POOLFREE(dir, d);
void op_closedir(struct dir *d) {
if (checkmode) {
/* nothing */
(void)d;
} else {
do_closedir(d->handle, d->name);
}
POOLFREE(dir, d);
}
////////////////////////////////////////////////////////////
@@ -104,212 +96,166 @@ op_closedir(struct dir *d)
#define MAXFILES 32
DECLPOOL(file, MAXFILES);
struct file *
op_open(unsigned testcode, unsigned name, unsigned openflags)
{
struct file *ret;
int dotrunc;
struct file *op_open(unsigned testcode, unsigned name, unsigned openflags) {
struct file *ret;
int dotrunc;
if (openflags == O_TRUNC) {
openflags = 0;
dotrunc = 1;
}
else {
dotrunc = 0;
}
if (openflags == O_TRUNC) {
openflags = 0;
dotrunc = 1;
} else {
dotrunc = 0;
}
assert(openflags == 0 || openflags == (O_CREAT|O_EXCL));
assert(openflags == 0 || openflags == (O_CREAT | O_EXCL));
ret = POOLALLOC(file);
ret->name = name;
ret->testcode = testcode;
ret->seq = 0;
if (checkmode) {
if (openflags) {
ret->handle = check_createfile(name);
}
else {
ret->handle = check_openfile(name);
}
}
else {
if (openflags) {
assert(dotrunc == 0);
ret->handle = do_createfile(name);
}
else {
/*
* XXX: as of 2013 OS/161 doesn't provide a
* truncate call - neither truncate() nor
* ftruncate()! You can only O_TRUNC. Oops...
*/
ret->handle = do_openfile(name, dotrunc);
dotrunc = 0;
}
}
if (dotrunc) {
op_truncate(ret, 0);
}
return ret;
ret = POOLALLOC(file);
ret->name = name;
ret->testcode = testcode;
ret->seq = 0;
if (checkmode) {
if (openflags) {
ret->handle = check_createfile(name);
} else {
ret->handle = check_openfile(name);
}
} else {
if (openflags) {
assert(dotrunc == 0);
ret->handle = do_createfile(name);
} else {
/*
* XXX: as of 2013 OS/161 doesn't provide a
* truncate call - neither truncate() nor
* ftruncate()! You can only O_TRUNC. Oops...
*/
ret->handle = do_openfile(name, dotrunc);
dotrunc = 0;
}
}
if (dotrunc) {
op_truncate(ret, 0);
}
return ret;
}
void
op_close(struct file *f)
{
if (checkmode) {
check_closefile(f->handle, f->name);
}
else {
do_closefile(f->handle, f->name);
}
POOLFREE(file, f);
void op_close(struct file *f) {
if (checkmode) {
check_closefile(f->handle, f->name);
} else {
do_closefile(f->handle, f->name);
}
POOLFREE(file, f);
}
void
op_write(struct file *f, off_t pos, off_t len)
{
off_t amount;
void op_write(struct file *f, off_t pos, off_t len) {
off_t amount;
while (len > 0) {
amount = len;
if (amount > DATA_MAXSIZE) {
amount = DATA_MAXSIZE;
}
while (len > 0) {
amount = len;
if (amount > DATA_MAXSIZE) {
amount = DATA_MAXSIZE;
}
if (checkmode) {
check_write(f->handle, f->name, f->testcode, f->seq,
pos, amount);
}
else {
do_write(f->handle, f->name, f->testcode, f->seq,
pos, amount);
}
f->seq++;
pos += amount;
len -= amount;
}
if (checkmode) {
check_write(f->handle, f->name, f->testcode, f->seq, pos, amount);
} else {
do_write(f->handle, f->name, f->testcode, f->seq, pos, amount);
}
f->seq++;
pos += amount;
len -= amount;
}
}
void
op_truncate(struct file *f, off_t len)
{
if (checkmode) {
check_truncate(f->handle, f->name, len);
}
else {
do_truncate(f->handle, f->name, len);
}
void op_truncate(struct file *f, off_t len) {
if (checkmode) {
check_truncate(f->handle, f->name, len);
} else {
do_truncate(f->handle, f->name, len);
}
}
////////////////////////////////////////////////////////////
// dirops
void
op_mkdir(unsigned name)
{
if (checkmode) {
check_mkdir(name);
}
else {
do_mkdir(name);
}
void op_mkdir(unsigned name) {
if (checkmode) {
check_mkdir(name);
} else {
do_mkdir(name);
}
}
void
op_rmdir(unsigned name)
{
if (checkmode) {
check_rmdir(name);
}
else {
do_rmdir(name);
}
void op_rmdir(unsigned name) {
if (checkmode) {
check_rmdir(name);
} else {
do_rmdir(name);
}
}
void
op_unlink(unsigned name)
{
if (checkmode) {
check_unlink(name);
}
else {
do_unlink(name);
}
void op_unlink(unsigned name) {
if (checkmode) {
check_unlink(name);
} else {
do_unlink(name);
}
}
void
op_link(unsigned from, unsigned to)
{
if (checkmode) {
check_link(from, to);
}
else {
do_link(from, to);
}
void op_link(unsigned from, unsigned to) {
if (checkmode) {
check_link(from, to);
} else {
do_link(from, to);
}
}
void
op_rename(unsigned from, unsigned to)
{
if (checkmode) {
check_rename(from, to);
}
else {
do_rename(from, to);
}
void op_rename(unsigned from, unsigned to) {
if (checkmode) {
check_rename(from, to);
} else {
do_rename(from, to);
}
}
void
op_renamexd(unsigned fromdir, unsigned from, unsigned todir, unsigned to)
{
if (checkmode) {
check_renamexd(fromdir, from, todir, to);
}
else {
do_renamexd(fromdir, from, todir, to);
}
void op_renamexd(unsigned fromdir, unsigned from, unsigned todir, unsigned to) {
if (checkmode) {
check_renamexd(fromdir, from, todir, to);
} else {
do_renamexd(fromdir, from, todir, to);
}
}
void
op_chdir(unsigned name)
{
if (checkmode) {
check_chdir(name);
}
else {
do_chdir(name);
}
void op_chdir(unsigned name) {
if (checkmode) {
check_chdir(name);
} else {
do_chdir(name);
}
}
void
op_chdirup(void)
{
if (checkmode) {
check_chdirup();
}
else {
do_chdirup();
}
void op_chdirup(void) {
if (checkmode) {
check_chdirup();
} else {
do_chdirup();
}
}
////////////////////////////////////////////////////////////
// other
void
op_sync(void)
{
if (checkmode) {
check_sync();
}
else {
do_sync();
}
void op_sync(void) {
if (checkmode) {
check_sync();
} else {
do_sync();
}
}
void
complete(void)
{
if (checkmode) {
checkfs();
}
void complete(void) {
if (checkmode) {
checkfs();
}
}

50
userland/testbin/frack/pool.c
View File

@@ -34,37 +34,33 @@
#include "pool.h"
unsigned
poolalloc(struct poolctl *pool)
{
uint32_t mask;
unsigned j, i;
unsigned poolalloc(struct poolctl *pool) {
uint32_t mask;
unsigned j, i;
assert(pool->max % 32 == 0);
for (j=0; j<pool->max/32; j++) {
for (mask=1, i=0; i<32; mask<<=1, i++) {
if ((pool->inuse[j] & mask) == 0) {
pool->inuse[j] |= mask;
return j*32 + i;
}
}
}
errx(1, "Too many %s -- increase %s in %s",
pool->itemtype, pool->maxname, pool->file);
return 0;
assert(pool->max % 32 == 0);
for (j = 0; j < pool->max / 32; j++) {
for (mask = 1, i = 0; i < 32; mask <<= 1, i++) {
if ((pool->inuse[j] & mask) == 0) {
pool->inuse[j] |= mask;
return j * 32 + i;
}
}
}
errx(1, "Too many %s -- increase %s in %s", pool->itemtype, pool->maxname,
pool->file);
return 0;
}
void
poolfree(struct poolctl *pool, unsigned num)
{
uint32_t mask;
unsigned pos;
void poolfree(struct poolctl *pool, unsigned num) {
uint32_t mask;
unsigned pos;
assert(num < pool->max);
assert(num < pool->max);
pos = num / 32;
mask = 1 << (num % 32);
pos = num / 32;
mask = 1 << (num % 32);
assert(pool->inuse[pos] & mask);
pool->inuse[pos] &= ~(uint32_t)mask;
assert(pool->inuse[pos] & mask);
pool->inuse[pos] &= ~(uint32_t)mask;
}

32
userland/testbin/frack/pool.h
View File

@@ -29,26 +29,24 @@
*/
struct poolctl {
uint32_t *inuse;
unsigned max;
const char *itemtype;
const char *maxname;
const char *file;
uint32_t *inuse;
unsigned max;
const char *itemtype;
const char *maxname;
const char *file;
};
#define DIVROUNDUP(a, b) (((a) + (b) - 1) / (b))
#define ROUNDUP(a, b) (DIVROUNDUP(a, b) * (b))
#define DIVROUNDUP(a, b) (((a) + (b) - 1) / (b))
#define ROUNDUP(a, b) (DIVROUNDUP(a, b) * (b))
#define DECLPOOL(T, MAX) \
static struct T pool_space_##T[ROUNDUP(MAX, 32)]; \
static uint32_t pool_inuse_##T[DIVROUNDUP(MAX, 32)]; \
static struct poolctl pool_##T = { \
.inuse = pool_inuse_##T, \
.max = ROUNDUP(MAX, 32), \
.itemtype = "struct " #T, \
.maxname = #MAX, \
.file = __FILE__ \
}
#define DECLPOOL(T, MAX) \
static struct T pool_space_##T[ROUNDUP(MAX, 32)]; \
static uint32_t pool_inuse_##T[DIVROUNDUP(MAX, 32)]; \
static struct poolctl pool_##T = {.inuse = pool_inuse_##T, \
.max = ROUNDUP(MAX, 32), \
.itemtype = "struct " #T, \
.maxname = #MAX, \
.file = __FILE__}
#define POOLALLOC(T) (&pool_space_##T[poolalloc(&pool_##T)])
#define POOLFREE(T, x) (poolfree(&pool_##T, (x) - pool_space_##T))

2193
userland/testbin/frack/workloads.c
View File

File diff suppressed because it is too large Load Diff

1
userland/testbin/frack/workloads.h
View File

@@ -28,7 +28,6 @@
* SUCH DAMAGE.
*/
/*
* The VFS-interface operations that can write to the fs are:
*