/* verify_datafiles()
*
* Discovers the datafile handles for a given metafile,
* verifies that they exist, and removes them from the handlelist.
*
* TODO: RENAME AS I FIGURE OUT WHAT EXACTLY I WANT THIS TO DO?
*/
int verify_datafiles(PVFS_fs_id cur_fs,
struct handlelist *hl,
struct handlelist *alt_hl,
PVFS_object_ref mf_ref,
int df_count,
PVFS_credentials *creds)
{
int ret, i, server_idx = 0, error = 0;
PVFS_handle *df_handles;
df_handles = (PVFS_handle *) malloc(df_count * sizeof(PVFS_handle));
if (df_handles == NULL)
{
assert(0);
}
ret = PVFS_mgmt_get_dfile_array(mf_ref, creds, df_handles, df_count, NULL);
if (ret != 0)
{
/* what does this mean? */
assert(0);
}
for (i = 0; i < df_count; i++)
{
int in_main_list = 0, in_alt_list = 0;
if (handlelist_find_handle(hl, df_handles[i], &server_idx) == 0)
{
in_main_list = 1;
}
else if (alt_hl &&
(handlelist_find_handle(alt_hl,
df_handles[i],
&server_idx) == 0))
{
in_alt_list = 1;
}
if ((!in_main_list) && (!in_alt_list))
{
printf("# datafile handle %llu missing from list\n",
llu(df_handles[i]));
/* if possible, rebuild the datafile. */
/* otherwise delete datafiles, return error to get
* handle and dirent removed.
*/
df_handles[i] = PVFS_HANDLE_NULL;
error++;
}
}
for (i = 0; i < df_count; i++)
{
if (df_handles[i] != PVFS_HANDLE_NULL) {
/* TODO: THIS IS A HACK; NEED BETTER WAY TO REMOVE FROM
* ONE OF TWO LISTS...
*/
if (handlelist_find_handle(hl, df_handles[i], &server_idx) == 0)
{
handlelist_remove_handle(hl,
df_handles[i],
server_idx);
}
else {
handlelist_remove_handle(alt_hl,
df_handles[i],
server_idx);
}
}
}
free(df_handles);
return (error) ? -1 : 0;
}
int main(int argc, char **argv)
{
PVFS_sysresp_lookup resp_lk;
PVFS_sysresp_create resp_cr;
PVFS_sysresp_io resp_io;
char *filename = NULL;
int ret = -1, io_size = DEFAULT_IO_SIZE;
int *io_buffer = NULL;
int i, errors, buffer_size;
PVFS_fs_id fs_id;
char name[512] = {0};
char *entry_name = NULL;
PVFS_credentials credentials;
PVFS_object_ref parent_refn;
PVFS_sys_attr attr;
PVFS_object_ref pinode_refn;
PVFS_Request file_req;
PVFS_Request mem_req;
void *buffer = NULL;
PVFS_sysresp_getattr resp_getattr;
PVFS_handle *dfile_array = NULL;
if (argc != 2)
{
fprintf(stderr, "Usage: %s <file name>\n", argv[0]);
return (-1);
}
/* create a buffer for running I/O on */
io_buffer = (int *) malloc(io_size * sizeof(int));
if (!io_buffer)
{
return (-1);
}
/* put some data in the buffer so we can verify */
for (i = 0; i < io_size; i++)
{
io_buffer[i] = i;
}
ret = PVFS_util_init_defaults();
if (ret < 0)
{
PVFS_perror("PVFS_util_init_defaults", ret);
return (-1);
}
ret = PVFS_util_get_default_fsid(&fs_id);
if (ret < 0)
{
PVFS_perror("PVFS_util_get_default_fsid", ret);
return (-1);
}
if (argv[1][0] == '/')
{
snprintf(name, 512, "%s", argv[1]);
}
else
{
snprintf(name, 512, "/%s", argv[1]);
}
PVFS_util_gen_credentials(&credentials);
ret = PVFS_sys_lookup(fs_id, name, &credentials,
&resp_lk, PVFS2_LOOKUP_LINK_FOLLOW, NULL);
if (ret == -PVFS_ENOENT)
{
PVFS_sysresp_getparent gp_resp;
printf("IO-TEST: lookup failed; creating new file.\n");
memset(&gp_resp, 0, sizeof(PVFS_sysresp_getparent));
ret = PVFS_sys_getparent(fs_id, name, &credentials, &gp_resp, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_getparent failed", ret);
return ret;
}
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = PVFS_U_WRITE | PVFS_U_READ;
attr.atime = attr.ctime = attr.mtime = time(NULL);
attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
parent_refn = gp_resp.parent_ref;
entry_name = rindex(name, (int)'/');
assert(entry_name);
entry_name++;
assert(entry_name);
ret = PVFS_sys_create(entry_name, parent_refn, attr,
&credentials, NULL, &resp_cr, NULL, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_create() failure", ret);
return (-1);
}
pinode_refn.fs_id = fs_id;
pinode_refn.handle = resp_cr.ref.handle;
}
else
{
printf("IO-TEST: lookup succeeded; performing I/O on "
"existing file.\n");
pinode_refn.fs_id = fs_id;
pinode_refn.handle = resp_lk.ref.handle;
}
/**************************************************************
* carry out I/O operation
*/
printf("IO-TEST: performing write on handle: %ld, fs: %d\n",
(long) pinode_refn.handle, (int) pinode_refn.fs_id);
buffer = io_buffer;
buffer_size = io_size * sizeof(int);
/*
file datatype is tiled, so we can get away with a trivial type
here
*/
file_req = PVFS_BYTE;
ret = PVFS_Request_contiguous(io_size * sizeof(int),
PVFS_BYTE, &(mem_req));
if (ret < 0)
{
PVFS_perror("PVFS_request_contiguous failure", ret);
return (-1);
}
ret = PVFS_sys_write(pinode_refn, file_req, 0, buffer, mem_req,
&credentials, &resp_io, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_write failure", ret);
return (-1);
}
printf("IO-TEST: wrote %d bytes.\n", (int) resp_io.total_completed);
/* uncomment and try out the readback-and-verify stuff that follows
* once reading back actually works */
memset(io_buffer, 0, io_size * sizeof(int));
/* verify */
printf("IO-TEST: performing read on handle: %ld, fs: %d\n",
(long) pinode_refn.handle, (int) pinode_refn.fs_id);
ret = PVFS_sys_read(pinode_refn, file_req, 0, buffer, mem_req,
&credentials, &resp_io, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_read failure", ret);
return (-1);
}
printf("IO-TEST: read %d bytes.\n", (int) resp_io.total_completed);
if ((io_size * sizeof(int)) != resp_io.total_completed)
{
fprintf(stderr, "Error: SHORT READ! skipping verification...\n");
}
else
{
errors = 0;
for (i = 0; i < io_size; i++)
{
if (i != io_buffer[i])
{
fprintf(stderr,
"error: element %d differs: should be %d, is %d\n", i,
i, io_buffer[i]);
errors++;
}
}
if (errors != 0)
{
fprintf(stderr, "ERROR: found %d errors\n", errors);
}
else
{
printf("IO-TEST: no errors found.\n");
}
}
/* test out some of the mgmt functionality */
ret = PVFS_sys_getattr(pinode_refn, PVFS_ATTR_SYS_ALL_NOSIZE,
&credentials, &resp_getattr, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_getattr", ret);
return (-1);
}
printf("Target file had %d datafiles:\n", resp_getattr.attr.dfile_count);
dfile_array = (PVFS_handle *) malloc(resp_getattr.attr.dfile_count
* sizeof(PVFS_handle));
if (!dfile_array)
{
perror("malloc");
return (-1);
}
ret = PVFS_mgmt_get_dfile_array(pinode_refn, &credentials,
dfile_array, resp_getattr.attr.dfile_count, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_mgmt_get_dfile_array", ret);
return (-1);
}
for (i = 0; i < resp_getattr.attr.dfile_count; i++)
{
printf("%llu\n", llu(dfile_array[i]));
}
/**************************************************************
* shut down pending interfaces
*/
ret = PVFS_sys_finalize();
if (ret < 0)
{
fprintf(stderr, "Error: PVFS_sys_finalize() failed with errcode = %d\n",
ret);
return (-1);
}
free(filename);
free(io_buffer);
return (0);
}
