LS_API bool
spud_create_id(spud_tube_id* id,
ls_err* err)
{
if (id == NULL)
{
LS_ERROR(err, LS_ERR_INVALID_ARG);
return false;
}
if ( !get_rand_buf(id, sizeof(*id), err) )
{
return false;
}
return true;
}
static int directio_test(void)
{
int ret, fd;
char dest[PATH_MAX];
int sub_testno = 1;
int o_flags_rw, o_flags_ro;
unsigned long write_size = 0, read_size = 0;
unsigned long append_size = 0, truncate_size = 0;
unsigned long interval, offset = 0;
unsigned long align_slice = 512;
unsigned long align_filesz = align_slice;
o_flags_rw = open_rw_flags;
o_flags_ro = open_ro_flags;
open_rw_flags |= O_DIRECT;
open_ro_flags |= O_DIRECT;
while (align_filesz < file_size)
align_filesz += align_slice;
root_printf("Test %d: Multi-nodes O_DIRECT test.\n", testno++);
snprintf(orig_path, PATH_MAX, "%s/multi_original_directio_refile",
workplace);
root_printf(" *SubTest %d:Prepare original inode %s.\n",
sub_testno++, orig_path);
if (!rank) {
ret = prep_orig_file_dio(orig_path, align_filesz);
should_exit(ret);
}
MPI_Barrier_Sync();
/*
* All ranks try to reflink the original to increment the
* refcount concurrently.
*/
root_printf(" *SubTest %d:Reflinking inode %s among nodes.\n",
sub_testno++, orig_path);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
ret = reflink(orig_path, dest, 1);
should_exit(ret);
}
MPI_Barrier_Sync();
/*
* All ranks try to do cow to decrement the
* refcount concurrently.
*/
root_printf(" *SubTest %d:Cowing reflinks by O_DIRECT writes among"
" nodes.\n", sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
interval = DIRECTIO_SLICE;
offset = 0;
while (offset < align_filesz) {
write_size = DIRECTIO_SLICE;
if (offset + write_size > align_filesz)
write_size = align_filesz - offset;
get_rand_buf(dio_buf, write_size);
ret = write_at_file(dest, dio_buf, write_size, offset);
should_exit(ret);
offset += write_size + interval;
}
}
MPI_Barrier_Sync();
/*
* All ranks try to read reflinks concurrently
*/
root_printf(" *SubTest %d:O_DIRECT reading reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
interval = DIRECTIO_SLICE;
offset = 0;
while (offset < align_filesz) {
read_size = DIRECTIO_SLICE;
if (offset + read_size > align_filesz)
read_size = align_filesz - offset;
ret = read_at_file(dest, dio_buf, read_size, offset);
should_exit(ret);
offset = offset + read_size + interval;
}
}
MPI_Barrier_Sync();
/*
* All ranks try to append reflinks concurrently
*/
root_printf(" *SubTest %d:Appending reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
fd = open64(dest, open_rw_flags | O_APPEND);
if (fd < 0) {
fd = errno;
abort_printf("open file %s failed:%d:%s\n",
dest, fd, strerror(fd));
}
append_size = DIRECTIO_SLICE;
get_rand_buf(dio_buf, append_size);
ret = write(fd, dio_buf, append_size);
if (ret < 0) {
ret = errno;
abort_printf("write file %s failed:%d:%s\n",
dest, ret, strerror(ret));
}
close(fd);
}
MPI_Barrier_Sync();
/*
* All ranks try to truncate reflinks concurrently
*/
root_printf(" *SubTest %d:Truncating reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
truncate_size = get_rand(0, align_filesz / DIRECTIO_SLICE) *
DIRECTIO_SLICE;
ret = truncate(dest, truncate_size);
if (ret < 0) {
ret = errno;
abort_printf("truncate file %s failed:%d:%s\n",
dest, ret, strerror(ret));
}
}
MPI_Barrier_Sync();
if (rank) {
ret = do_unlink(dest);
should_exit(ret);
} else {
ret = do_unlink(orig_path);
should_exit(ret);
}
open_rw_flags = o_flags_rw;
open_ro_flags = o_flags_ro;
MPI_Barrier_Sync();
return 0;
}
static int stress_test(void)
{
unsigned long i, j;
int ret = 0, sub_testno = 1;
char *write_buf = NULL, dest[PATH_MAX];
char tmp_dest[PATH_MAX], tmp_orig[PATH_MAX];
char *pattern_buf = NULL, *verify_buf = NULL;
unsigned long offset = 0, write_size = 0, interval = 0;
unsigned long verify_size = 0, verify_offset = 0;
write_buf = (char *)malloc(HUNK_SIZE * 2);
pattern_buf = (char *)malloc(HUNK_SIZE * 2);
verify_buf = (char *)malloc(HUNK_SIZE * 2);
root_printf("Test %d: Multi-nodes stress refcount test.\n", testno++);
root_printf(" *SubTest %d: Stress test with tremendous refcount "
"trees.\n", sub_testno++);
for (i = 0; i < ref_trees; i++) {
snprintf(orig_path, PATH_MAX, "%s/multi_original_stress_"
"refile_rank%d_%ld", workplace, rank, i);
snprintf(dest, PATH_MAX, "%s_target", orig_path);
ret = prep_orig_file(orig_path, 32 * 1024, 1);
if (ret)
goto bail;
ret = reflink(orig_path, dest, 1);
if (ret)
goto bail;
}
for (i = 0; i < ref_trees; i++) {
snprintf(orig_path, PATH_MAX, "%s/multi_original_stress_refile_"
"rank%d_%ld", workplace, rank, i);
snprintf(dest, PATH_MAX, "%s_target", orig_path);
offset = get_rand(0, 32 * 1024 - 1);
write_size = 1;
get_rand_buf(write_buf, write_size);
ret = write_at_file(dest, write_buf, write_size, offset);
if (ret)
goto bail;
}
for (i = 0; i < ref_trees; i++) {
snprintf(orig_path, PATH_MAX, "%s/multi_original_stress_refile_"
"rank%d_%ld", workplace, rank, i);
snprintf(dest, PATH_MAX, "%s_target", orig_path);
ret = do_unlink(orig_path);
if (ret)
goto bail;
ret = do_unlink(dest);
if (ret)
goto bail;
}
MPI_Barrier_Sync();
root_printf(" *SubTest %d: Stress test with tremendous shared inodes "
"on one refcount tree.\n", sub_testno++);
snprintf(orig_path, PATH_MAX, "%s/multi_original_stress_refile",
workplace);
snprintf(dest, PATH_MAX, "%s_target", orig_path);
if (!rank) {
ret = prep_orig_file(orig_path, 10 * HUNK_SIZE, 1);
if (ret)
goto bail;
for (i = 1; i < size; i++) {
snprintf(ref_path, PATH_MAX, "%s_%ld", dest, i);
ret = reflink(orig_path, ref_path, 1);
if (ret)
goto bail;
}
}
MPI_Barrier_Sync();
if (rank) {
snprintf(ref_path, PATH_MAX, "%s_%d", dest, rank);
ret = do_reflinks(ref_path, ref_path, ref_counts, 1);
if (ret)
goto bail;
for (i = 0; i < ref_counts; i++) {
if (get_rand(0, 1))
continue;
snprintf(ref_path, PATH_MAX, "%s_%dr%ld", dest, rank,
i);
offset = get_rand(0, 10 * HUNK_SIZE - 1);
write_size = get_rand(1, HUNK_SIZE);
if (offset + write_size > 10 * HUNK_SIZE)
write_size = 10 * HUNK_SIZE - offset;
get_rand_buf(write_buf, write_size);
ret = write_at_file(ref_path, write_buf, write_size,
offset);
if (ret)
goto bail;
}
}
MPI_Barrier_Sync();
if (rank) {
for (i = 0; i < ref_counts; i++) {
if (get_rand(0, 1))
continue;
snprintf(ref_path, PATH_MAX, "%s_%dr%ld", orig_path,
rank, i);
truncate(ref_path, 0);
}
}
MPI_Barrier_Sync();
if (rank) {
snprintf(ref_path, PATH_MAX, "%s_%d", dest, rank);
ret = do_unlinks(ref_path, ref_counts);
if (ret)
goto bail;
} else {
for (i = 1; i < size; i++) {
snprintf(ref_path, PATH_MAX, "%s_%ld", dest, i);
ret = do_unlink(ref_path);
if (ret)
goto bail;
}
ret = do_unlink(orig_path);
if (ret)
goto bail;
}
MPI_Barrier_Sync();
root_printf(" *SubTest %d: Stress test with HUGEFILE reflinked.\n",
sub_testno++);
snprintf(orig_path, PATH_MAX, "%s/multi_original_stress_huge_refile",
workplace);
snprintf(dest, PATH_MAX, "%s_target", orig_path);
strcpy(tmp_dest, dest);
strcpy(tmp_orig, orig_path);
if (!rank) {
ret = prep_orig_file(orig_path, file_size, 1);
if (ret)
goto bail;
ret = reflink(orig_path, dest, 1);
if (ret)
goto bail;
}
MPI_Barrier_Sync();
if (rank) {
offset = 0;
interval = file_size / 1000;
i = 0;
while (offset < file_size) {
snprintf(dest, PATH_MAX, "%s_%d_%ld", tmp_dest,
rank, i);
ret = reflink(orig_path, dest, 1);
if (ret)
goto bail;
write_size = get_rand(1, M_SIZE);
get_rand_buf(write_buf, write_size);
verify_size = get_rand(M_SIZE, 2 * M_SIZE);
if (offset < (verify_size - write_size) / 2)
verify_offset = 0;
else
verify_offset = offset -
(verify_size - write_size) / 2;
if (verify_offset + verify_size > file_size)
verify_size = file_size - verify_offset;
ret = read_at_file(orig_path, pattern_buf, verify_size,
verify_offset);
if (ret)
goto bail;
ret = write_at_file(dest, write_buf, write_size,
offset);
if (ret)
goto bail;
ret = read_at_file(orig_path, verify_buf, verify_size,
verify_offset);
if (ret)
goto bail;
if (memcmp(pattern_buf, verify_buf, verify_size)) {
abort_printf("Verify original file date failed"
" after writting to snapshot!\n");
ret = -1;
goto bail;
}
offset = offset + write_size + interval;
strcpy(orig_path, dest);
i++;
}
for (j = 0; j < i; j++) {
snprintf(dest, PATH_MAX, "%s_%d_%ld", tmp_dest,
rank, j);
ret = do_unlink(dest);
if (ret)
goto bail;
}
strcpy(dest, tmp_dest);
offset = 0;
interval = file_size / 1000;
while (offset < file_size) {
write_size = get_rand(1, M_SIZE * 2);
get_rand_buf(write_buf, write_size);
ret = write_at_file(dest, write_buf,
write_size, offset);
if (ret)
goto bail;
offset = offset + write_size + interval;
}
}
MPI_Barrier_Sync();
if (!rank) {
ret = do_unlink(dest);
if (ret)
goto bail;
ret = do_unlink(orig_path);
if (ret)
goto bail;
}
bail:
if (write_buf)
free(write_buf);
if (pattern_buf)
free(pattern_buf);
if (verify_buf)
free(verify_buf);
should_exit(ret);
return ret;
}
static int basic_test(void)
{
int ret = 0, fd;
char dest[PATH_MAX];
int sub_testno = 1;
char *write_buf = NULL, *read_buf = NULL;
unsigned long write_size = 0, read_size = 0;
unsigned long append_size = 0, truncate_size = 0;
unsigned long interval, offset = 0;
write_buf = (char *)malloc(HUNK_SIZE * 2);
read_buf = (char *)malloc(HUNK_SIZE * 2);
root_printf("Test %d: Multi-nodes basic refcount test.\n", testno++);
snprintf(orig_path, PATH_MAX, "%s/multi_original_basic_refile",
workplace);
root_printf(" *SubTest %d:Prepare original inode %s.\n",
sub_testno++, orig_path);
if (!rank) {
ret = prep_orig_file(orig_path, file_size, 1);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
/*
* All ranks try to reflink the original to increment the
* refcount concurrently.
*/
root_printf(" *SubTest %d:Reflinking inode %s among nodes.\n",
sub_testno++, orig_path);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
ret = reflink(orig_path, dest, 1);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
if (!rank) {
ret = verify_orig_file(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
/*
* All ranks try to do cow to decrement the
* refcount concurrently.
*/
root_printf(" *SubTest %d:Cowing reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
interval = file_size / 100;
offset = 0;
while (offset < file_size) {
if (test_flags & RAND_TEST)
write_size = get_rand(1, M_SIZE * 2);
else
write_size = 1;
if (offset + write_size > file_size)
write_size = file_size - offset;
get_rand_buf(write_buf, write_size);
if (test_flags & MMAP_TEST)
ret = mmap_write_at_file(dest, write_buf,
write_size, offset);
else
ret = write_at_file(dest, write_buf, write_size,
offset);
if (ret)
goto bail_free;
if (test_flags & RAND_TEST)
offset += write_size + get_rand(1, interval);
else
offset += write_size + interval;
}
}
MPI_Barrier_Sync();
if (!rank) {
ret = verify_orig_file(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
/*
* All ranks try to read reflinks concurrently
*/
root_printf(" *SubTest %d:Reading reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
interval = file_size / 100;
offset = 0;
while (offset < file_size) {
if (test_flags & RAND_TEST)
read_size = get_rand(1, M_SIZE * 2);
else
read_size = 1;
if (offset + read_size > file_size)
read_size = file_size - offset;
if (test_flags & MMAP_TEST)
ret = mmap_read_at_file(dest, read_buf,
read_size, offset);
else
ret = read_at_file(dest, read_buf, read_size,
offset);
if (ret)
goto bail_free;
if (test_flags & RAND_TEST)
offset = offset + read_size +
get_rand(1, interval);
else
offset = offset + read_size + interval;
}
}
MPI_Barrier_Sync();
if (!rank) {
ret = verify_orig_file(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
if (test_flags & MMAP_TEST)
goto bail;
/*
* All ranks try to append reflinks concurrently
*/
root_printf(" *SubTest %d:Appending reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
fd = open64(dest, open_rw_flags | O_APPEND);
if (fd < 0) {
if (write_buf)
free(write_buf);
if (read_buf)
free(read_buf);
fd = errno;
abort_printf("open file %s failed:%d:%s\n",
dest, fd, strerror(fd));
}
if (test_flags & RAND_TEST)
append_size = get_rand(1, HUNK_SIZE);
else
append_size = HUNK_SIZE;
get_rand_buf(write_buf, append_size);
ret = write(fd, write_buf, append_size);
if (ret < 0) {
if (write_buf)
free(write_buf);
if (read_buf)
free(read_buf);
ret = errno;
abort_printf("write file %s failed:%d:%s\n",
dest, ret, strerror(ret));
}
close(fd);
}
MPI_Barrier_Sync();
if (!rank) {
ret = verify_orig_file(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
/*
* All ranks try to truncate reflinks concurrently
*/
root_printf(" *SubTest %d:Truncating reflinks among nodes.\n",
sub_testno++);
if (rank) {
snprintf(dest, PATH_MAX, "%s-%s-%d", orig_path, hostname, rank);
if (test_flags & RAND_TEST)
truncate_size = get_rand(0, file_size);
else
truncate_size = file_size / (rank + 1);
ret = truncate(dest, truncate_size);
if (ret < 0) {
if (write_buf)
free(write_buf);
if (read_buf)
free(read_buf);
ret = errno;
abort_printf("truncate file %s failed:%d:%s\n",
dest, ret, strerror(ret));
}
}
MPI_Barrier_Sync();
if (!rank) {
ret = verify_orig_file(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
bail:
if (rank) {
ret = do_unlink(dest);
if (ret)
goto bail_free;
} else {
ret = do_unlink(orig_path);
if (ret)
goto bail_free;
}
MPI_Barrier_Sync();
bail_free:
if (write_buf)
free(write_buf);
if (read_buf)
free(read_buf);
should_exit(ret);
return ret;
}
static int do_xattr_data_cows(char *ref_pfx, unsigned long iter, int ea_nums)
{
unsigned long i, j;
char dest[PATH_MAX];
int fd, ret = 0, o_ret;
unsigned long offset = 0, write_size = 0;
char *write_buf = NULL;
write_buf = (char *)malloc(HUNK_SIZE);
for (i = 0; i < iter; i++) {
snprintf(dest, PATH_MAX, "%sr%ld", ref_pfx, i);
fd = open64(dest, open_rw_flags);
if (fd < 0) {
o_ret = fd;
fd = errno;
fprintf(stderr, "open file %s failed:%d:%s\n",
dest, fd, strerror(fd));
fd = o_ret;
goto bail;
}
strcpy(filename, dest);
for (j = 0; j < ea_nums; j++) {
/* Update xattr*/
strcpy(xattr_name, xattr_name_list_set[j]);
xattr_value_sz = get_rand(1, XATTR_VALUE_MAX_SZ);
if (xattr_value_sz > xattr_name_sz + 50)
xattr_value_constructor(j);
else
xattr_value_generator(j, xattr_value_sz,
xattr_value_sz);
ret = add_or_update_ea(NORMAL, fd, XATTR_REPLACE,
"update");
if (ret < 0)
ret = add_or_update_ea(NORMAL, fd, XATTR_CREATE,
"add");
if (ret < 0)
continue;
if (xattr_value_sz > xattr_name_sz + 50) {
ret = read_ea(NORMAL, fd);
if (ret < 0)
goto bail;
ret = xattr_value_validator(j);
if (ret < 0)
goto bail;
}
/* Update file data*/
offset = get_rand(0, file_size - 1);
write_size = get_rand(1, HUNK_SIZE);
if (offset + write_size > file_size)
write_size = file_size - offset;
get_rand_buf(write_buf, write_size);
ret = write_at(fd, write_buf, write_size, offset);
if (ret < 0)
goto bail;
}
close(fd);
}
bail:
if (write_buf)
free(write_buf);
return ret;
}
