static
void
domapread(unsigned offset, unsigned size)
{
unsigned pg_offset;
unsigned map_size;
char *p;
offset -= offset % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_MAPREAD, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_MAPREAD, offset, size);
return;
}
log4(OP_MAPREAD, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet && ((progressinterval &&
testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu mapread\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
pg_offset = offset & page_mask;
map_size = pg_offset + size;
if ((p = (char *)mmap(0, map_size, PROT_READ, MAP_FILE | MAP_SHARED, fd,
(off_t)(offset - pg_offset))) == (char *)-1) {
prterr("domapread: mmap");
report_failure(190);
}
if (setjmp(jmpbuf) == 0) {
jmpbuf_good = 1;
memcpy(temp_buf, p + pg_offset, size);
check_eofpage("Read", offset, p, size);
jmpbuf_good = 0;
} else {
report_failure(1901);
}
if (munmap(p, map_size) != 0) {
prterr("domapread: munmap");
report_failure(191);
}
check_buffers(offset, size);
}
bool cpiPython::CallAll(int func, w_Targs* args) // the default handler: returns true unless the calback returns 0
{
if (!online) return true;
w_Targs* result;
bool ret = true;
long l;
if (func != W_OnTimer) log2("PY: CallAll %s: parameters %s\n", lib_hookname(func), lib_packprint(args)) // no ';' since this would break 'else'
else log4("PY: CallAll %s\n", lib_hookname(func));
if(Size())
{
tvPythonInterpreter::iterator it;
for(it = mPython.begin(); it != mPython.end(); ++it)
{
result = (*it)->CallFunction(func, args);
if(!result)
{
// callback doesn't exist or a failure
if (func != W_OnTimer) log4("PY: CallAll %s: returned NULL\n", lib_hookname(func));
continue;
}
if(lib_unpack(result, "l", &l)) // default return value is 1L meaning: further processing,
{
if (func != W_OnTimer) log3("PY: CallAll %s: returned l:%ld\n", lib_hookname(func), l);
if (!l) ret = false; // 0L means no more processing outside this plugin
}
else // something unknown was returned... we will let the hub call other plugins
{
log1("PY: CallAll %s: unexpected return value %s\n", lib_hookname(func), lib_packprint(result));
}
free(result);
}
}
free(args); // WARNING: args is freed, do not try to access it after calling CallAll!
return ret;
}
void
dowrite(unsigned offset, unsigned size)
{
ssize_t ret;
off_t newsize;
offset -= offset % writebdy;
if (o_direct)
size -= size % writebdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount && !o_direct)
prt("skipping zero size write\n");
log4(OP_SKIPPED, OP_WRITE, offset, size);
return;
}
log4(OP_WRITE, offset, size, file_size);
gendata(original_buf, good_buf, offset, size);
if (file_size < offset + size) {
newsize = ceil(((double)offset + size) / truncbdy) * truncbdy;
if (file_size < newsize)
memset(good_buf + file_size, '\0', newsize - file_size);
file_size = newsize;
if (lite) {
warn("Lite file size bug in fsx!");
report_failure(149);
}
ret = rbd_resize(image, newsize);
if (ret < 0) {
prterrcode("dowrite: resize", ret);
report_failure(150);
}
}
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu write\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = rbd_write(image, offset, size, good_buf + offset);
if (ret != size) {
if (ret < 0)
prterrcode("dowrite: rbd_write", ret);
else
prt("short write: 0x%x bytes instead of 0x%x\n",
ret, size);
report_failure(151);
}
if (flush) {
doflush(offset, size);
}
}
static
void
dowrite(unsigned offset, unsigned size)
{
off_t ret;
unsigned iret;
offset -= offset % writebdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero size write\n");
log4(OP_SKIPPED, OP_WRITE, offset, size);
return;
}
log4(OP_WRITE, offset, size, file_size);
gendata(original_buf, good_buf, offset, size);
if (file_size < offset + size) {
if (file_size < offset)
memset(good_buf + file_size, '\0', offset - file_size);
file_size = offset + size;
if (lite) {
warn("Lite file size bug in fsx!");
report_failure(149);
}
}
if (testcalls <= simulatedopcount)
return;
if (!quiet && ((progressinterval &&
testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu write\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = lseek(fd, (off_t)offset, SEEK_SET);
if (ret == (off_t)-1) {
prterr("dowrite: lseek");
report_failure(150);
}
iret = write(fd, good_buf + offset, size);
if (iret != size) {
if (iret == -1)
prterr("dowrite: write");
else
prt("short write: 0x%x bytes instead of 0x%x\n",
iret, size);
report_failure(151);
}
}
void
doread(unsigned offset, unsigned size)
{
off_t ret;
unsigned iret;
offset -= offset % readbdy;
if (o_direct)
size -= size % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount && !o_direct)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
log4(OP_READ, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = lseek(fd, (off_t)offset, SEEK_SET);
if (ret == (off_t)-1) {
prterr("doread: lseek");
report_failure(140);
}
iret = fsxread(fd, temp_buf, size, offset);
if (iret != size) {
if (iret == -1)
prterr("doread: read");
else
prt("short read: 0x%x bytes instead of 0x%x\n",
iret, size);
report_failure(141);
}
check_buffers(offset, size);
}
void
do_punch_hole(unsigned offset, unsigned length)
{
unsigned end_offset;
int max_offset = 0;
int max_len = 0;
int ret;
offset -= offset % holebdy;
length -= length % holebdy;
if (length == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero length punch hole\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
if (file_size <= (loff_t)offset) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping hole punch off the end of the file\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
end_offset = offset + length;
log4(OP_PUNCH_HOLE, offset, length, 0);
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(debug && (monitorstart == -1 || monitorend == -1 ||
end_offset <= monitorend))) {
prt("%lu punch\tfrom 0x%x to 0x%x, (0x%x bytes)\n", testcalls,
offset, offset+length, length);
}
ret = ops->discard(&ctx, (unsigned long long)offset,
(unsigned long long)length);
if (ret < 0) {
prterrcode("do_punch_hole: ops->discard", ret);
report_failure(161);
}
max_offset = offset < file_size ? offset : file_size;
max_len = max_offset + length <= file_size ? length :
file_size - max_offset;
memset(good_buf + max_offset, '\0', max_len);
}
/* fallocate is basically a no-op unless extending, then a lot like a truncate */
void
do_preallocate(unsigned offset, unsigned length)
{
unsigned end_offset;
int keep_size;
if (length == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero length fallocate\n");
log4(OP_SKIPPED, OP_FALLOCATE, offset, length);
return;
}
keep_size = random() % 2;
end_offset = keep_size ? 0 : offset + length;
if (end_offset > biggest) {
biggest = end_offset;
if (!quiet && testcalls > simulatedopcount)
prt("fallocating to largest ever: 0x%x\n", end_offset);
}
/*
* last arg matches fallocate string array index in logdump:
* 0: allocate past EOF
* 1: extending prealloc
* 2: interior prealloc
*/
log4(OP_FALLOCATE, offset, length, (end_offset > file_size) ? (keep_size ? 0 : 1) : 2);
if (end_offset > file_size) {
memset(good_buf + file_size, '\0', end_offset - file_size);
file_size = end_offset;
}
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug && (monitorstart == -1 || monitorend == -1 ||
end_offset <= monitorend)))
prt("%lu falloc\tfrom 0x%x to 0x%x (0x%x bytes)\n", testcalls,
offset, offset + length, length);
if (fallocate(fd, keep_size ? FALLOC_FL_KEEP_SIZE : 0, (loff_t)offset, (loff_t)length) == -1) {
prt("fallocate: %x to %x\n", offset, length);
prterr("do_preallocate: fallocate");
report_failure(161);
}
}
void
dotruncate(unsigned size)
{
int oldsize = file_size;
size -= size % truncbdy;
if (size > biggest) {
biggest = size;
if (!quiet && testcalls > simulatedopcount)
prt("truncating to largest ever: 0x%x\n", size);
}
log4(OP_TRUNCATE, size, (unsigned)file_size, 0);
if (size > file_size)
memset(good_buf + file_size, '\0', size - file_size);
file_size = size;
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug && (monitorstart == -1 || monitorend == -1 ||
size <= monitorend)))
prt("%lu trunc\tfrom 0x%x to 0x%x\n", testcalls, oldsize, size);
if (ftruncate(fd, (off_t)size) == -1) {
prt("ftruncate1: %x\n", size);
prterr("dotruncate: ftruncate");
report_failure(160);
}
}
void
dotruncate(unsigned size)
{
int oldsize = file_size;
int ret;
size -= size % truncbdy;
if (size > biggest) {
biggest = size;
if (!quiet && testcalls > simulatedopcount)
prt("truncating to largest ever: 0x%x\n", size);
}
log4(OP_TRUNCATE, size, (unsigned)file_size, 0);
if (size > file_size)
memset(good_buf + file_size, '\0', size - file_size);
else if (size < file_size)
memset(good_buf + size, '\0', file_size - size);
file_size = size;
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(debug && (monitorstart == -1 || monitorend == -1 ||
size <= monitorend)))
prt("%lu trunc\tfrom 0x%x to 0x%x\n", testcalls, oldsize, size);
if ((ret = rbd_resize(image, size)) < 0) {
prt("rbd_resize: %x\n", size);
prterrcode("dotruncate: ftruncate", ret);
report_failure(160);
}
}
/* @Core */
Mat PDCounter::detect(Mat& input) {
string log1("Begin detecting...\n");
Mat output = input.clone();
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
(*it).detect(output, Trackers);// NO parallel
}
string log2("All areas are detected...\n");
string lost = i_to_s(Trackers.tracking(output)); // NO parallel
string log3("Tracking completed...\nThe trackers lost " + lost + " pedestrians in this frame.\n");
if (showPedestrian) {
drawFounds(output, Trackers.getCurrRects(), PEDESTRIAN_COLOR);
}
if (showArea) {
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
drawArea(output, (*it).getArea(), AREA_COLOR);
}
}
if (showTrajectory) {
for (int i = 0; i < Trackers.getSize(); i++) {
drawTrajectory(output, Trackers[i].getTrajectory(), Trajectory_COLOR);
}
}
string log4("Drawing completed");
lastLog = log1 + log2 + log3 + log4;
return output;
}
w_Targs* cpiPython::SQL (int id, w_Targs* args) // (char *query)
{
char *query;
string q;
long limit;
if (!lib_begin || !lib_pack || !lib_unpack || !lib_packprint || !mQuery) return NULL;
if (!lib_unpack(args, "sl", &query, &limit)) return NULL;
if (!query) return NULL;
if (limit < 1) limit = 100;
log4("PY: SQL query: %s\n", query);
q = string() + query;
mQuery->OStream() << q;
if (mQuery->Query() < 0) { mQuery->Clear(); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); } // error
int rows = mQuery->StoreResult();
if (limit < rows) rows = limit;
if (rows < 1) { mQuery->Clear(); return lib_pack("lllp", (long)1, (long)0, (long)0, (void*)NULL); }
int cols = mQuery->Cols();
char * nil = (char*)"NULL";
char ** res = (char **) calloc (cols*rows, sizeof(char*));
if (!res) { log1("PY: SQL malloc failed\n"); mQuery->Clear(); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); }
for (int r = 0 ; r < rows; r++)
{
mQuery->DataSeek(r);
MYSQL_ROW row;
row = mQuery->Row();
if (!row)
{ log1("PY: SQL failed to fetch row: %d\n", r); mQuery->Clear(); free(res); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); }
for (int i = 0; i < cols; i++)
res[(r*cols)+i] = strdup( (row[i]) ? row[i] : nil );
}
mQuery->Clear();
return lib_pack("lllp", (long)1, (long)rows, (long)cols, (void*)res);
}
static unsigned int compute_subdivisions(const BezierPath::Point& p0,
const BezierPath::Point& p1,
const BezierPath::Point& p2,
const BezierPath::Point& p3,
BezierPath::Coord flat)
{
vector2d<BezierPath::Coord> d01(p1.x() - p0.x(), p1.y() - p0.y());
vector2d<BezierPath::Coord> d12(p2.x() - p1.x(), p2.y() - p1.y());
vector2d<BezierPath::Coord> d23(p3.x() - p2.x(), p3.y() - p2.y());
vector2d<BezierPath::Coord> d03(p3.x() - p0.x(), p3.y() - p0.y());
vector2d<BezierPath::Coord> d01_12 = d12 - d01;
vector2d<BezierPath::Coord> d12_23 = d23 - d12;
double dist = norm(d03);
double dist2;
if (dist != 0) {
dist2 = __myabs(cross(d01_12, d03) / dist);
double tmp = __myabs(cross(d12_23, d03) / dist);
if (tmp > dist2) {
dist2 = tmp;
}
} else {
vector2d<BezierPath::Coord> d0(p0.x(), p0.y());
dist2 = norm(vector2d<BezierPath::Coord>(d01_12 - d0));
double tmp = norm(vector2d<BezierPath::Coord>(d12_23 - d0));
if (tmp > dist2) {
dist2 = tmp;
}
}
unsigned int subdivisions = 0;
if (dist2 > 0) {
subdivisions = log4(long((3.0 / 4.0) * dist2 / flat + 0.5));
}
return subdivisions;
}
void
do_punch_hole(unsigned offset, unsigned length)
{
unsigned end_offset;
int max_offset = 0;
int max_len = 0;
int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
if (length == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero length punch hole\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
if (file_size <= (loff_t)offset) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping hole punch off the end of the file\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
end_offset = offset + length;
log4(OP_PUNCH_HOLE, offset, length, 0);
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug && (monitorstart == -1 || monitorend == -1 ||
end_offset <= monitorend))) {
prt("%lu punch\tfrom 0x%x to 0x%x, (0x%x bytes)\n", testcalls,
offset, offset+length, length);
}
if (fallocate(fd, mode, (loff_t)offset, (loff_t)length) == -1) {
prt("%punch hole: %x to %x\n", offset, length);
prterr("do_punch_hole: fallocate");
report_failure(161);
}
max_offset = offset < file_size ? offset : file_size;
max_len = max_offset + length <= file_size ? length :
file_size - max_offset;
memset(good_buf + max_offset, '\0', max_len);
}
void
doread(unsigned offset, unsigned size)
{
int ret;
offset -= offset % readbdy;
if (o_direct)
size -= size % readbdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount && !o_direct)
prt("skipping zero size read\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
if (size + offset > file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping seek/read past end of file\n");
log4(OP_SKIPPED, OP_READ, offset, size);
return;
}
log4(OP_READ, offset, size, 0);
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
ret = ops->read(&ctx, offset, size, temp_buf);
if (ret != (int)size) {
if (ret < 0)
prterrcode("doread: ops->read", ret);
else
prt("short read: 0x%x bytes instead of 0x%x\n",
ret, size);
report_failure(141);
}
check_buffers(good_buf, temp_buf, offset, size);
}
void
do_flatten()
{
int ret;
if (!rbd_image_has_parent(&ctx)) {
log4(OP_SKIPPED, OP_FLATTEN, 0, 0);
return;
}
log4(OP_FLATTEN, 0, 0, 0);
prt("%lu flatten\n", testcalls);
ret = ops->flatten(&ctx);
if (ret < 0) {
prterrcode("writefileimage: ops->flatten", ret);
exit(177);
}
}
void
do_clone()
{
char filename[1024];
char imagename[1024];
char lastimagename[1024];
int ret, fd;
int order = 0, stripe_unit = 0, stripe_count = 0;
if (randomize_striping) {
order = 18 + rand() % 8;
stripe_unit = 1ull << (order - 1 - (rand() % 8));
stripe_count = 2 + rand() % 14;
}
log4(OP_CLONE, 0, 0, 0);
++num_clones;
prt("%lu clone\t%d order %d su %d sc %d\n", testcalls, num_clones, order, stripe_unit, stripe_count);
clone_filename(filename, sizeof(filename), num_clones);
if ((fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) {
simple_err("do_clone: open", -errno);
exit(162);
}
save_buffer(good_buf, file_size, fd);
if ((ret = close(fd)) < 0) {
simple_err("do_clone: close", -errno);
exit(163);
}
if ((ret = rbd_snap_create(image, "snap")) < 0) {
simple_err("do_clone: rbd create snap", ret);
exit(164);
}
if ((ret = rbd_snap_protect(image, "snap")) < 0) {
simple_err("do_clone: rbd protect snap", ret);
exit(164);
}
clone_imagename(imagename, sizeof(imagename), num_clones);
clone_imagename(lastimagename, sizeof(lastimagename),
num_clones - 1);
ret = rbd_clone2(ioctx, lastimagename, "snap", ioctx, imagename,
RBD_FEATURES_ALL, &order, stripe_unit, stripe_count);
if (ret < 0) {
simple_err("do_clone: rbd clone", ret);
exit(165);
}
rbd_close(image);
if ((ret = rbd_open(ioctx, imagename, &image, NULL)) < 0) {
simple_err("do_clone: rbd open", ret);
exit(166);
}
}
void
do_collapse_range(unsigned offset, unsigned length)
{
unsigned end_offset;
int mode = FALLOC_FL_COLLAPSE_RANGE;
if (length == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero length collapse range\n");
log4(OP_SKIPPED, OP_COLLAPSE_RANGE, offset, length);
return;
}
end_offset = offset + length;
if ((loff_t)end_offset >= file_size) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping collapse range behind EOF\n");
log4(OP_SKIPPED, OP_COLLAPSE_RANGE, offset, length);
return;
}
log4(OP_COLLAPSE_RANGE, offset, length, 0);
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(debug && (monitorstart == -1 || monitorend == -1 ||
end_offset <= monitorend))) {
prt("%lu collapse\tfrom 0x%x to 0x%x, (0x%x bytes)\n", testcalls,
offset, offset+length, length);
}
if (fallocate(fd, mode, (loff_t)offset, (loff_t)length) == -1) {
prt("collapse range: %x to %x\n", offset, length);
prterr("do_collapse_range: fallocate");
report_failure(161);
}
memmove(good_buf + offset, good_buf + end_offset,
file_size - end_offset);
file_size -= length;
}
double cwf(unsigned long long base_counts[], unsigned long long window)
{
assert(window != 0);
assert(base_counts != NULL);
unsigned long long i = 0;
unsigned long long count = 0;
mpfr_t val;
mpfr_init(val);
mpfr_set_ui(val, 1, RND);
mpfr_t loop_result;
mpfr_init(loop_result);
mpfr_set_ui(loop_result, 1, RND);
mpfr_t log_result;
mpfr_init(log_result);
mpfr_set_ui(log_result, 1, RND);
for (i = 0; i < NUM_BASES; i++) {
count = base_counts[i];
assert(count > 0);
fact(val, count);
/* loop_result *= val */
mpfr_mul(loop_result, loop_result, val, RND);
}
assert(mpfr_cmp_ui(loop_result, 0) != 0);
/* val = factorial(window) */
fact(val, window);
/* val = val / loop_result */
mpfr_div(val, val, loop_result, RND);
/* log_result = log4(val) */
log4(log_result, val);
/* val = log_result * (1.0 / window) */
mpfr_mul_d(val, log_result, (1.0 / window), RND);
double output = 0.0;
output = mpfr_get_d(val, RND);
mpfr_clear(val);
mpfr_clear(loop_result);
mpfr_clear(log_result);
return output;
}
/**
* Apply the given NAKs to the naklist
*/
void apply_naks(unsigned char *naklist, struct finfo_t *finfo,
int blocks_this_sec, int section_offset)
{
int nakidx, listidx, i;
for (i = 0; i < blocks_this_sec; i++) {
// Each bit represents a NAK; check each one
// Simplified: (naklist[listidx / 8] & (1 << (listidx % 8)))
nakidx = i + section_offset;
listidx = i;
if ((naklist[listidx >> 3] & (1 << (listidx & 7))) != 0) {
log4(0, 0, "Got NAK for %d", nakidx);
finfo->naklist[nakidx] = 1;
}
}
}
TEST(LoggerTest, LevelTest)
{
std::ostringstream ss;
Logger log1(ss, Logger::TRACE_);
Logger log2(ss, Logger::VERBOSE_);
Logger log3(ss, Logger::DEBUG_);
Logger log4(ss, Logger::INFO_);
Logger log5(ss, Logger::WARN_);
Logger log6(ss, Logger::ERROR_);
ASSERT_TRUE(log1.t());
ASSERT_TRUE(log1.v());
ASSERT_TRUE(log1.d());
ASSERT_TRUE(log1.i());
ASSERT_FALSE(log2.t());
ASSERT_TRUE(log2.v());
ASSERT_TRUE(log2.d());
ASSERT_TRUE(log2.i());
ASSERT_FALSE(log3.t());
ASSERT_FALSE(log3.v());
ASSERT_TRUE(log3.d());
ASSERT_TRUE(log3.i());
ASSERT_FALSE(log4.t());
ASSERT_FALSE(log4.v());
ASSERT_FALSE(log4.d());
ASSERT_TRUE(log4.i());
ASSERT_FALSE(log5.t());
ASSERT_FALSE(log5.v());
ASSERT_FALSE(log5.d());
ASSERT_FALSE(log5.i());
ASSERT_FALSE(log6.t());
ASSERT_FALSE(log6.v());
ASSERT_FALSE(log6.d());
ASSERT_FALSE(log6.i());
}
void
test(void)
{
unsigned long offset;
unsigned long size = maxoplen;
unsigned long rv = random();
unsigned long op;
if (simulatedopcount > 0 && testcalls == simulatedopcount)
writefileimage();
testcalls++;
if (closeprob)
closeopen = (rv >> 3) < (1u << 28) / (unsigned)closeprob;
if (debugstart > 0 && testcalls >= debugstart)
debug = 1;
if (!quiet && testcalls < simulatedopcount && testcalls % 100000 == 0)
prt("%lu...\n", testcalls);
offset = random();
if (randomoplen)
size = random() % (maxoplen + 1);
/* calculate appropriate op to run */
if (lite)
op = rv % OP_MAX_LITE;
else
op = rv % OP_MAX_FULL;
switch (op) {
case OP_MAPREAD:
if (!mapped_reads)
op = OP_READ;
break;
case OP_MAPWRITE:
if (!mapped_writes)
op = OP_WRITE;
break;
case OP_FALLOCATE:
if (!fallocate_calls) {
log4(OP_SKIPPED, OP_FALLOCATE, offset, size);
goto out;
}
break;
case OP_PUNCH_HOLE:
if (!punch_hole_calls) {
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, size);
goto out;
}
break;
}
switch (op) {
case OP_READ:
TRIM_OFF_LEN(offset, size, file_size);
doread(offset, size);
break;
case OP_WRITE:
TRIM_OFF_LEN(offset, size, maxfilelen);
dowrite(offset, size);
break;
case OP_MAPREAD:
TRIM_OFF_LEN(offset, size, file_size);
exit(183);
break;
case OP_MAPWRITE:
TRIM_OFF_LEN(offset, size, maxfilelen);
exit(182);
break;
case OP_TRUNCATE:
if (!style)
size = random() % maxfilelen;
dotruncate(size);
break;
case OP_PUNCH_HOLE:
TRIM_OFF_LEN(offset, size, file_size);
do_punch_hole(offset, size);
break;
default:
prterr("test: unknown operation");
report_failure(42);
break;
}
out:
if (sizechecks && testcalls > simulatedopcount)
check_size();
if (closeopen)
docloseopen();
}
static void DefParams(int MinHitLength, double MinId, int SeqLengthT, int SeqLengthQ,
bool Self, double MaxMem, FilterParams *ptrFP, DPParams *ptrDP)
{
if (MinId < 0 || MinId > 1.0)
Quit("DefParams: bad MinId=%g", MinId);
if (MinHitLength <= 4)
Quit("DefParams: bad MinHitLength=%d", MinHitLength);
const char *strTubeOffset = ValueOpt("tubeoffset");
const int TubeOffset = (0 == strTubeOffset) ? -1 : atoi(strTubeOffset);
// Lower bound on word length k by requiring manageable index.
// Given kmer occurs once every 4^k positions.
// Hence average number of index entries is i = N/(4^k) for random
// string of length N.
// Require i <= I, then k > log_4(N/i).
const double dSeqLengthA = (double) SeqLengthT;
const int MinWordSize = (int) (log4(dSeqLengthA) - log4(MAX_AVG_INDEX_LIST_LENGTH) + 0.5);
// First choice is that filter criteria are same as DP criteria,
// but this may not be possible.
int SeedLength = MinHitLength;
int SeedDiffs = (int) (MinHitLength*(1.0 - MinId));
// Find filter valid filter parameters,
// starting from preferred case.
int WordSize = -1;
for (;;)
{
int MinWords = -1;
for (WordSize = MAX_WORD_LENGTH; WordSize >= MinWordSize; --WordSize)
{
ptrFP->WordSize = WordSize;
ptrFP->SeedLength = SeedLength;
ptrFP->SeedDiffs = SeedDiffs;
ptrFP->TubeOffset = TubeOffset > 0 ? TubeOffset : ptrFP->SeedDiffs + TUBE_OFFSET_DELTA;
double Mem = TotalMemRequired(SeqLengthT, SeqLengthQ, Self, *ptrFP);
if (MaxMem > 0 && Mem > MaxMem)
{
Log("Parameters n=%d k=%d e=%d, mem=%.0f Mb > maxmem=%.0f Mb\n",
ptrFP->SeedLength,
ptrFP->WordSize,
ptrFP->SeedDiffs,
Mem/1e6,
MaxMem/1e6);
MinWords = -1;
continue;
}
MinWords = MinWordsPerFilterHit(SeedLength, WordSize, SeedDiffs);
if (MinWords <= 0)
{
Log("Parameters n=%d k=%d e=%d, B=%d\n",
ptrFP->SeedLength,
ptrFP->WordSize,
ptrFP->SeedDiffs,
MinWords);
MinWords = -1;
continue;
}
const double Len = AvgIndexListLength(SeqLengthT, *ptrFP);
if (Len > MAX_AVG_INDEX_LIST_LENGTH)
{
Log("Parameters n=%d k=%d e=%d, B=%d avgixlen=%g > max = %d\n",
ptrFP->SeedLength,
ptrFP->WordSize,
ptrFP->SeedDiffs,
MinWords,
Len,
MAX_AVG_INDEX_LIST_LENGTH);
MinWords = -1;
continue;
}
break;
}
if (MinWords > 0)
break;
// Failed to find filter parameters, try
// fewer errors and shorter seed.
if (SeedLength >= MinHitLength/4)
{
SeedLength /= 2;
continue;
}
if (SeedDiffs > 0)
{
--SeedDiffs;
continue;
}
Quit("Failed to find filter parameters");
}
ptrDP->MinHitLength = MinHitLength;
ptrDP->MinId = MinId;
}
void
do_clone()
{
char filename[1024];
char imagename[1024];
char lastimagename[1024];
int ret, fd;
int order = 0, stripe_unit = 0, stripe_count = 0;
uint64_t newsize = file_size;
log4(OP_CLONE, 0, 0, 0);
++num_clones;
if (randomize_striping) {
order = 18 + get_random() % 8;
stripe_unit = 1ull << (order - 1 - (get_random() % 8));
stripe_count = 2 + get_random() % 14;
}
prt("%lu clone\t%d order %d su %d sc %d\n", testcalls, num_clones,
order, stripe_unit, stripe_count);
clone_imagename(imagename, sizeof(imagename), num_clones);
clone_imagename(lastimagename, sizeof(lastimagename),
num_clones - 1);
assert(strcmp(lastimagename, ctx.name) == 0);
ret = ops->clone(&ctx, "snap", imagename, &order, stripe_unit,
stripe_count);
if (ret < 0) {
prterrcode("do_clone: ops->clone", ret);
exit(165);
}
if (randomize_parent_overlap && rbd_image_has_parent(&ctx)) {
int rand = get_random() % 16 + 1; // [1..16]
if (rand < 13) {
uint64_t overlap;
ret = rbd_get_overlap(ctx.image, &overlap);
if (ret < 0) {
prterrcode("do_clone: rbd_get_overlap", ret);
exit(1);
}
if (rand < 10) { // 9/16
newsize = overlap * ((double)rand / 10);
newsize -= newsize % truncbdy;
} else { // 3/16
newsize = 0;
}
assert(newsize != (uint64_t)file_size);
prt("truncating image %s from 0x%llx (overlap 0x%llx) to 0x%llx\n",
ctx.name, file_size, overlap, newsize);
ret = ops->resize(&ctx, newsize);
if (ret < 0) {
prterrcode("do_clone: ops->resize", ret);
exit(1);
}
} else if (rand < 15) { // 2/16
prt("flattening image %s\n", ctx.name);
ret = ops->flatten(&ctx);
if (ret < 0) {
prterrcode("do_clone: ops->flatten", ret);
exit(1);
}
} else { // 2/16
prt("leaving image %s intact\n", ctx.name);
}
}
clone_filename(filename, sizeof(filename), num_clones);
if ((fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) {
simple_err("do_clone: open", -errno);
exit(162);
}
save_buffer(good_buf, newsize, fd);
if ((ret = close(fd)) < 0) {
simple_err("do_clone: close", -errno);
exit(163);
}
/*
* Close parent.
*/
if ((ret = ops->close(&ctx)) < 0) {
prterrcode("do_clone: ops->close", ret);
exit(174);
}
/*
* Open freshly made clone.
*/
if ((ret = ops->open(imagename, &ctx)) < 0) {
prterrcode("do_clone: ops->open", ret);
exit(166);
}
if (num_clones > 1)
check_clone(num_clones - 2);
}
/**
* For messages that send a list of clients in the body, append all clients
* in the specified state to the packet, then send the message of the given
* type when either the body is full or the end of the client list has been
* reached. All header fields besides uftp_h.blsize and message.destcount
* must be populated before calling.
* Returns 1 on success, 0 on fail.
*/
int send_multiple(const struct finfo_t *finfo, unsigned char *packet,
int message, int attempt, uint32_t *addrlist, int state,
uint16_t *mes_destcount, int encrypt,
const struct sockaddr_in *destaddr, int regconf)
{
struct uftp_h *header;
int hsize, payloadlen;
int maxdest, packetcnt, dests, i;
unsigned char *mheader, *encpacket, *outpacket;
header = (struct uftp_h *)packet;
mheader = packet + sizeof(struct uftp_h);
hsize = (unsigned char *)addrlist - mheader;
maxdest = ((encrypt ? encpayloadsize : payloadsize) - hsize) /
sizeof(struct in_addr);
packetcnt = 1;
if (encrypt) {
encpacket = calloc(mtu + keylen, 1);
if (encpacket == NULL) {
syserror(0, 0, "calloc failed!");
exit(1);
}
} else {
encpacket = NULL;
}
for (i = 0, dests = 0; i < destcount; i++) {
if (message == REG_CONF) {
// Only send REG_CONF for a particular client if either it's
// behind a proxy or we're sending them to everyone.
// Also, don't send if we already sent one and we haven't
// gotten another REGISTER
if ((destlist[i].status == state) &&
(!finfo->deststate[i].conf_sent) &&
(regconf || (destlist[i].proxyidx != -1))) {
addrlist[dests++] = destlist[i].addr.s_addr;
finfo->deststate[i].conf_sent = 1;
}
} else if (message == DONE_CONF) {
// As with REG_CONF, don't send a DONE_CONF for a client
// if we already sent one and we haven't gotten another COMPLETE
if ((destlist[i].status == state) &&
(!finfo->deststate[i].conf_sent)) {
addrlist[dests++] = destlist[i].addr.s_addr;
finfo->deststate[i].conf_sent = 1;
}
} else if (destlist[i].status == state) {
addrlist[dests++] = destlist[i].addr.s_addr;
}
if ((dests >= maxdest) || ((i == destcount - 1) && (dests > 0))) {
payloadlen = hsize + (dests * sizeof(uint32_t));
*mes_destcount = htons(dests);
if (encrypt) {
if (!encrypt_and_sign(packet, &encpacket, payloadlen, mtu,
keytype, groupkey, groupsalt, ivlen, hashtype,
grouphmackey, hmaclen, sigtype, privkey, rsalen)) {
log0(0, 0, "Error encrypting %s", func_name(message));
free(encpacket);
return 0;
}
outpacket = encpacket;
payloadlen = ntohs(((struct uftp_h *)outpacket)->blsize);
} else {
outpacket = packet;
header->blsize = htons(payloadlen);
}
log2(0, 0, "Sending %s %d.%d", func_name(message),
attempt, packetcnt);
log4(0, 0, "Sending to %08X", ntohl(destaddr->sin_addr.s_addr));
if (nb_sendto(sock, outpacket, payloadlen + sizeof(struct uftp_h),0,
(struct sockaddr *)destaddr,
sizeof(*destaddr)) == SOCKET_ERROR) {
sockerror(0, 0, "Error sending %s", func_name(message));
sleep(1);
free(encpacket);
return 0;
}
if (packet_wait) usleep(packet_wait);
memset(addrlist, 0, maxdest * sizeof(uint32_t));
dests = 0;
packetcnt++;
}
}
free(encpacket);
return 1;
}
/**
* Performs the Transfer phase for a particular file
* Returns 1 if at least one client finished, 0 if all are dropped or aborted
*/
int transfer_phase(struct finfo_t *finfo)
{
unsigned char *packet, *encpacket, *data;
char path[MAXPATHNAME];
struct uftp_h *header;
struct fileseg_h *fileseg;
int max_time, alldone, numbytes, sent_blocks, current_naks;
unsigned int pass, section, numnaks, block;
struct timeval start_time, last_sent, current_sent;
int64_t avgwait, waitcnt, overage, tdiff;
f_offset_t offset, curr_offset;
int file, i;
if (finfo->file_id != 0) {
// First check to see if all clients are already done for this file.
// This can happen on a restart when the file finished on the
// last attempt and responded to the FILEINFO with a COMPLETE
for (i = 0, alldone = 1; (i < destcount) && alldone; i++) {
alldone = alldone && ((destlist[i].status == DEST_DONE) ||
(client_error(i)) || (destlist[i].clientcnt != -1));
}
if (alldone) {
gettimeofday(&start_time, NULL);
print_status(finfo, start_time);
return 1;
}
}
// If rate is -1, use 100Mbps for purpose of calculating max time
max_time = (int)floor(((double)weight / 100) *
((double)finfo->size / (((rate == -1) ? 100000 : rate) / 8) / 1024));
if (max_time < min_time) {
max_time = min_time;
}
if ((finfo->file_id != 0) && (finfo->ftype == FTYPE_REG)) {
log(0, 0, "Maximum file transfer time: %d seconds", max_time);
snprintf(path, sizeof(path), "%s%c%s", finfo->basedir, PATH_SEP,
finfo->filename);
if ((file = open(path, OPENREAD, 0)) == -1) {
syserror(0, 0, "Error opening file");
return 1;
}
} else {
// At end of group, all non-errored client are DEST_DONE from the
// last file, so reset them to DEST_ACTIVE to get the final COMPLETE.
for (i = 0; i < destcount; i++) {
if (!client_error(i)) {
destlist[i].status = DEST_ACTIVE;
}
}
}
packet = calloc(mtu, 1);
encpacket = calloc(mtu, 1);
if ((packet == NULL) || (encpacket == NULL)) {
syserror(0, 0, "calloc failed!");
exit(1);
}
header = (struct uftp_h *)packet;
fileseg = (struct fileseg_h *)(packet + sizeof(struct uftp_h));
data = (unsigned char *)fileseg + sizeof(struct fileseg_h);
set_uftp_header(header, FILESEG, finfo, &receive_dest);
pass = 1;
alldone = 0;
gettimeofday(&start_time, NULL);
do {
avgwait = 0;
waitcnt = 0;
numnaks = 0;
overage = 0;
section = 1;
curr_offset = 0;
sent_blocks = 0;
gettimeofday(&last_sent, NULL);
if (finfo->file_id != 0) {
log(0, 0, "Sending file...pass %d", pass);
lseek_func(file, 0, SEEK_SET);
} else {
log(0, 0, "Finishing group");
}
fileseg->func = FILESEG;
fileseg->file_id = htons(finfo->file_id);
fileseg->pass = pass;
fileseg->section = htons(section);
for (block = 0; block < finfo->blocks; block++) {
// If all clients received this file partially on a prior attempt
// and it's the first pass, request NAKs for all sections
// right away and don't send any data packets.
if (((pass == 1) || finfo->naklist[block]) &&
!((pass == 1) && finfo->partial)) {
if (diff_sec(last_sent, start_time) > max_time) {
log0(0, 0, "Max file transfer time exceeded");
send_abort(finfo, "Max file transfer time exceeded",
&receive_dest, NULL, (keytype != KEY_NONE),
!quit_on_error);
alldone = 1;
for (i = 0; i < destcount; i++) {
if (quit_on_error || ((destlist[i].status == DEST_ACTIVE) &&
destlist[i].clientcnt == -1 )) {
destlist[i].status = DEST_ABORT;
}
}
break;
}
// On the first pass, go straight through the file.
// On later passes, seek to the next packet.
if (pass != 1) {
log4(0, 0, "Resending %d", block);
if (!seek_block(file, block, &offset, curr_offset)) {
continue;
}
}
if ((numbytes = read(file, data, blocksize)) == -1) {
syserror(0, 0, "read failed");
continue;
}
if (pass != 1) {
curr_offset = offset + numbytes;
}
// Keep track of how long we really slept compared to how
// long we expected to sleep. If we went over, subtract the
// time over from the next sleep time. This way we maintain
// the proper average sleep time. This can result in multiple
// packets going out at once, potentially losing packets.
if (packet_wait > overage) {
usleep(packet_wait - (int32_t)overage);
}
gettimeofday(¤t_sent, NULL);
tdiff = diff_usec(current_sent, last_sent);
avgwait += tdiff;
waitcnt++;
if (packet_wait) overage += tdiff - packet_wait;
last_sent = current_sent;
fileseg->seq_num = htonl(block);
send_data(finfo, packet, numbytes, encpacket);
sent_blocks++;
}
if ((block % (blocksize * 8) == (blocksize * 8) - 1) ||
(block == finfo->blocks - 1)) {
if ((pass == 1) || sent_blocks) {
current_naks = get_naks(finfo, pass, section, &alldone);
numnaks += current_naks;
if ((rate != -1) && (cc_count > 0)) {
if (!read_cc_config(cc_config)) {
log1(0, 0, "Error rereading congestion control "
"config, using prior values");
}
adjust_rate(current_naks, sent_blocks);
}
overage = 0;
if (alldone) break;
}
sent_blocks = 0;
gettimeofday(&last_sent, NULL);
fileseg->section = htons(++section);
}
}
if ((finfo->size == 0) && !alldone) {
// If it's the end of the group, or an empty file, a DONE was
// never sent, so send it now
numnaks += get_naks(finfo, pass, section, &alldone);
}
if (finfo->file_id != 0) {
log(0, 0, "Average wait time = %.2f us",
(waitcnt == 0) ? 0 : (float)avgwait / waitcnt);
log(0, 0, "Received %d distinct NAKs for pass %d", numnaks, pass);
}
pass++;
} while (!alldone);
if ((finfo->file_id != 0) && (finfo->ftype == FTYPE_REG)) {
close(file);
}
print_status(finfo, start_time);
free(packet);
free(encpacket);
for (i = 0; i < destcount; i++) {
if (quit_on_error) {
// Check to see that all finished
if ((destlist[i].status != DEST_DONE) &&
(destlist[i].clientcnt == -1)) {
return 0;
}
} else {
// Check to see if at least one finished
if (destlist[i].status == DEST_DONE) {
return 1;
}
}
}
if (quit_on_error) {
return 1;
} else {
return 0;
}
}
void
domapwrite(unsigned offset, unsigned size)
{
unsigned pg_offset;
unsigned map_size;
off_t cur_filesize;
char *p;
offset -= offset % writebdy;
if (size == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero size write\n");
log4(OP_SKIPPED, OP_MAPWRITE, offset, size);
return;
}
cur_filesize = file_size;
log4(OP_MAPWRITE, offset, size, 0);
gendata(original_buf, good_buf, offset, size);
if (file_size < offset + size) {
if (file_size < offset)
memset(good_buf + file_size, '\0', offset - file_size);
file_size = offset + size;
if (lite) {
warn("Lite file size bug in fsx!");
report_failure(200);
}
}
if (testcalls <= simulatedopcount)
return;
if (!quiet &&
((progressinterval && testcalls % progressinterval == 0) ||
(fsx_debug &&
(monitorstart == -1 ||
(offset + size > monitorstart &&
(monitorend == -1 || offset <= monitorend))))))
prt("%lu mapwrite\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls,
offset, offset + size - 1, size);
if (file_size > cur_filesize) {
if (ftruncate(fd, file_size) == -1) {
prterr("domapwrite: ftruncate");
exit(201);
}
}
pg_offset = offset & PAGE_MASK;
map_size = pg_offset + size;
if ((p = (char *)mmap(0, map_size, PROT_READ | PROT_WRITE,
MAP_FILE | MAP_SHARED, fd,
(off_t)(offset - pg_offset))) == (char *)-1) {
prterr("domapwrite: mmap");
report_failure(202);
}
memcpy(p + pg_offset, good_buf + offset, size);
if (msync(p, map_size, MS_SYNC) != 0) {
prterr("domapwrite: msync");
report_failure(203);
}
check_eofpage("Write", offset, p, size);
if (munmap(p, map_size) != 0) {
prterr("domapwrite: munmap");
report_failure(204);
}
}