static int test_files_as_dirs(int testcase)
{
int ret = 1, fs_id;
PVFS_sys_attr attr;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_look;
PVFS_sysresp_create resp_create;
char *filename;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
PVFS_util_gen_credentials(&credentials);
attr.mask = PVFS_ATTR_SYS_ALL_NOSIZE;
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = 1877;
attr.atime = attr.mtime = attr.ctime = 0xdeadbeef;
if (initialize_sysint() < 0)
{
debug_printf("UNABLE TO INIT THE SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
switch(testcase)
{
case 0:
/* get root */
ret = PVFS_sys_lookup(fs_id, "/", &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return (-1);
}
ret = PVFS_sys_create("foo", resp_look.ref, attr, &credentials,
NULL, NULL, &resp_create);
/* get root */
ret = PVFS_sys_lookup(fs_id, "/foo", &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return (-1);
}
ret = PVFS_sys_create("bar", resp_look.ref, attr, &credentials,
NULL, NULL, &resp_create);
break;
case 1:
/* Need to add some more interesting cases */
break;
}
return ret;
}
int create_lost_and_found(PVFS_fs_id cur_fs,
PVFS_credentials *creds)
{
int ret;
PVFS_object_ref root_ref;
PVFS_sys_attr attr;
PVFS_sysresp_lookup lookup_resp;
PVFS_sysresp_mkdir mkdir_resp;
/* if it's already there, don't bother */
ret = PVFS_sys_lookup(cur_fs,
"/lost+found",
creds,
&lookup_resp,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
if (ret == 0) {
laf_ref = lookup_resp.ref;
return 0;
}
attr.owner = creds->uid;
attr.owner = creds->uid;
attr.group = creds->gid;
attr.perms = PVFS_util_translate_mode(0755, 0);
attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
ret = PVFS_sys_lookup(cur_fs,
"/",
creds,
&lookup_resp,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
assert(ret == 0);
root_ref = lookup_resp.ref;
printf("* %s creating lost+found to hold orphans.\n",
fsck_opts->destructive ? "" : "not");
if (fsck_opts->destructive) {
ret = PVFS_sys_mkdir("lost+found",
root_ref,
attr,
creds,
&mkdir_resp, NULL);
if (ret == 0) {
laf_ref = mkdir_resp.ref;
}
}
else {
ret = 0;
}
return ret;
}
static int lookup( const char *path, pvfs_fuse_handle_t *pfh,
int32_t follow_link )
{
PVFS_sysresp_lookup lk_response;
int ret;
/* we don't have to do a PVFS_util_resolve
* because FUSE resolves the path for us
*/
pvfs_fuse_gen_credentials(&pfh->creds);
memset(&lk_response, 0, sizeof(lk_response));
ret = PVFS_sys_lookup(pvfs2fuse.fs_id,
(char *)path,
&pfh->creds,
&lk_response,
follow_link,
PVFS_HINT_NULL);
if ( ret < 0 ) {
return ret;
}
pfh->ref.handle = lk_response.ref.handle;
pfh->ref.fs_id = pvfs2fuse.fs_id;
return 0;
}
static int test_write_beyond(void){
PVFS_sysresp_lookup resp_lk;
PVFS_Request req_io;
PVFS_Request req_mem;
PVFS_sysresp_io resp_io;
PVFS_credentials credentials;
char *filename;
char *io_buffer;
int fs_id, ret, i;
PVFS_size oldsize;
PVFS_sysresp_getattr resp;
PVFS_offset file_req_offset = 0;
uint32_t attrmask;
attrmask = PVFS_ATTR_SYS_ALL_NOSIZE;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
memset(&req_io, 0, sizeof(PVFS_Request));
memset(&req_mem, 0, sizeof(PVFS_Request));
memset(&resp_io, 0, sizeof(PVFS_sysresp_io));
memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup));
PVFS_util_gen_credentials(&credentials);
if (initialize_sysint() < 0)
{
debug_printf("UNABLE TO INIT THE SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
ret = PVFS_sys_lookup(fs_id, filename, &credentials,
&resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
debug_printf("test_pvfs_datatype_hvector: lookup failed "
"on %s\n", filename);
}
if((ret = PVFS_sys_getattr(resp_lk.ref, attrmask, &credentials, &resp)) < 0)
return ret;
io_buffer = malloc(sizeof(char)*(size_t)resp.attr.size+100);
/* req_io.size = resp_io.size + 100; */
oldsize = resp.attr.size +100;
for(i = 0; i < oldsize; i++)
{
io_buffer[i] = 'a';
}
ret = PVFS_sys_write(resp_lk.ref, req_io, file_req_offset, io_buffer, req_mem,
&credentials, &resp_io);
if(ret < 0){
debug_printf("write failed on %s\n", filename);
}
/* finalize_sysint(); */
return ret;
}
/*
* simple helper to lookup a handle given a filename
*
* returns a handle to the new directory
* -1 if some error happened
*/
int lookup_name(PVFS_object_ref pinode_refn, char *name,
PVFS_object_ref *out_refn)
{
int ret = -1;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
memset(&resp_lookup, 0, sizeof(resp_lookup));
PVFS_util_gen_credentials(&credentials);
ret = PVFS_sys_lookup(pinode_refn.fs_id, name,
&credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return(-1);
}
if (out_refn)
{
memcpy(out_refn, &resp_lookup.ref,
sizeof(PVFS_object_ref));
}
return 0;
}
/* Preconditions: none
* Parameters: none
* Postconditions: returns error from getattr
* Has 2 Test Cases
*/
static int test_getattr(void)
{
int fs_id, ret;
PVFS_credentials credentials;
PVFS_object_ref pinode_refn;
uint32_t attrmask;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_getattr resp_getattr;
char *name;
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "name");
fs_id = 9;
PVFS_util_gen_credentials(&credentials);
if ((ret = PVFS_sys_lookup(
fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0)
{
fprintf(stderr, "lookup failed %d\n", ret);
return ret;
}
pinode_refn = resp_lookup.ref;
attrmask = PVFS_ATTR_SYS_ALL_NOSIZE;
ret = PVFS_sys_getattr(pinode_refn, attrmask, &credentials, &resp_getattr);
return ret;
}
/* Preconditions: none
* Parameters: testcase - the test case that is checked for this function
* Postconditions: returns error code of readdir
* Has 2 test cases
*/
static int test_create(void)
{
int ret, fs_id;
PVFS_sys_attr attr;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_look;
PVFS_sysresp_create resp_create;
char *filename;
ret = -2;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
PVFS_util_gen_credentials(&credentials);
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = 1877;
attr.atime = attr.ctime = attr.mtime = time(NULL);
fs_id = 9;
ret = PVFS_sys_lookup(fs_id, "/", &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return (-1);
}
ret =
PVFS_sys_create(filename, resp_look.ref, attr, &credentials,
NULL, NULL, &resp_create);
return ret;
}
/* Preconditions: none
* Parameters: testcase - the test case that is checked for this function
* Postconditions: returns error code of readdir
* Has 2 tset cases
*/
static int test_remove(void)
{
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_look;
char *filename;
int ret;
int fs_id;
ret = -2;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
PVFS_util_gen_credentials(&credentials);
fs_id = 9;
ret = PVFS_sys_lookup(fs_id, filename, &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return (-1);
}
ret = PVFS_sys_remove(filename, resp_look.ref, &credentials);
return ret;
}
/*
* helper function to fill in the root pinode_refn
* fs_id: fsid of our file system
*
* returns: 0 on success;
* -1 if a problem
*/
int get_root(PVFS_fs_id fs_id, PVFS_object_ref *pinode_refn)
{
int ret = -1;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_look;
char *root = "/";
if (pinode_refn)
{
memset(&resp_look, 0, sizeof(resp_look));
PVFS_util_gen_credentials(&credentials);
printf("looking up the root handle for fsid = %d\n", fs_id);
ret = PVFS_sys_lookup(fs_id, root, &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
}
memcpy(pinode_refn, &resp_look.ref,
sizeof(PVFS_object_ref));
}
return ret;
}
/* Preconditions: none
* Parameters: testcase - the test case that is checked for this function
* Postconditions: returns error code of readdir
* Has 2 test cases
*/
static int test_write(void)
{
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lk;
PVFS_Request req_io;
PVFS_sysresp_io resp_io;
char *filename;
char io_buffer[100];
int fs_id, ret;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
memset(&req_io, 0, sizeof(PVFS_Request));
memset(&resp_io, 0, sizeof(PVFS_sysresp_io));
PVFS_util_gen_credentials(&credentials);
memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup));
fs_id = 9;
ret = PVFS_sys_lookup(fs_id, filename, &credentials,
&resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
debug_printf("test_pvfs_datatype_hvector: lookup failed "
"on %s\n", filename);
}
ret =
PVFS_sys_write(resp_lk.ref, req_io, 0, io_buffer, NULL, &credentials,
&resp_io);
return ret;
}
static int test_io_on_dir(int testcase)
{
int fs_id, ret,i;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
PVFS_Request req_io;
PVFS_Request req_mem;
PVFS_sysresp_io resp_io;
PVFS_offset file_req_offset = 0;
char *name;
char io_buffer[100];
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "/");
if (initialize_sysint() < 0)
{
debug_printf("ERROR UNABLE TO INIT SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
PVFS_util_gen_credentials(&credentials);
if((ret = PVFS_sys_lookup(
fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0)
{
fprintf(stderr,"lookup failed\n");
return ret;
}
memset(&req_io, 0, sizeof(req_io));
memset(&req_mem, 0, sizeof(req_mem));
switch(testcase)
{
case 0:
ret = PVFS_sys_read(resp_lookup.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io);
break;
case 1:
for(i = 0; i < 100; i++)
{
io_buffer[i] = 'a';
}
ret = PVFS_sys_write(resp_lookup.ref, req_io, file_req_offset, io_buffer, req_mem, &credentials, &resp_io);
break;
}
/* finalize_sysint(); */
return ret;
}
static int test_get_set_attr_empty(int testcase)
{
int fs_id, ret;
PVFS_credentials credentials;
PVFS_object_ref pinode_refn;
PVFS_sysresp_lookup resp_lookup;
PVFS_sys_attr attr;
PVFS_sysresp_getattr resp;
uint32_t attrmask;
char *name;
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "nofileyea");
if (initialize_sysint() < 0)
{
debug_printf("ERROR UNABLE TO INIT SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
PVFS_util_gen_credentials(&credentials);
if ((ret = PVFS_sys_lookup(
fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0)
{
fprintf(stderr, "lookup failed which it should but keep going\n");
/* return ret; */
}
pinode_refn = resp_lookup.ref;
attr.mask = PVFS_ATTR_SYS_ALL_NOSIZE;
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = 1877;
attr.atime = attr.mtime = attr.ctime = 0xdeadbeef;
attr.objtype = PVFS_TYPE_METAFILE;
attrmask = PVFS_ATTR_SYS_ALL_NOSIZE;
switch(testcase){
case 0:
ret = PVFS_sys_setattr(pinode_refn, attr, &credentials);
break;
case 1:
ret = PVFS_sys_getattr(pinode_refn, attrmask, &credentials, &resp);
break;
}
return ret;
}
/**
* pvfsios_get_object: lookup an object by path
*
* @param fs the filesystem we are using
* @param path the path to lookup
* @param r put the reference here
* @param c put current creds here too
* @return 0 or -err
*/
static int pvfsios_get_object(PVFS_fs_id fs, char *path, PVFS_object_ref *r,
PVFS_credentials *c, int flags) {
int pev;
PVFS_sysresp_lookup resp;
memset(&resp, 0, sizeof(resp));
c->uid = getuid();
c->gid = getgid();
pev = PVFS_sys_lookup(fs, path, c, &resp, flags);
if (pev < 0)
return(get_err(pev));
r->handle = resp.ref.handle;
r->fs_id = fs;
return(0);
}
static PVFS_handle inode2handle(PVFS_credentials *credentials, fuse_ino_t ino)
{
static PVFS_handle pvfs_root_handle;
if (ino == FUSE_ROOT_ID) {
if (pvfs_root_handle == 0){
PVFS_sysresp_lookup lk_response;
memset(&lk_response, 0, sizeof(lk_response));
int ret = PVFS_sys_lookup(pvfs_fsid, (char *)"/", credentials, &lk_response,
PVFS2_LOOKUP_LINK_NO_FOLLOW, PVFS_HINT_NULL);
if ( ret < 0 )
return -1 * pvfs2errno(ret);
pvfs_root_handle = lk_response.ref.handle;
}
return pvfs_root_handle;
} else {
return ino;
}
}
int traverse_directory_tree(PVFS_fs_id cur_fs,
struct handlelist *hl,
PVFS_BMI_addr_t *addr_array,
int server_count,
PVFS_credentials *creds)
{
int ret, server_idx = 0;
PVFS_sysresp_lookup lookup_resp;
PVFS_sysresp_getattr getattr_resp;
PVFS_object_ref pref;
ret = PVFS_sys_lookup(cur_fs,
"/",
creds,
&lookup_resp,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
assert(ret == 0);
pref = lookup_resp.ref;
PVFS_sys_getattr(pref,
PVFS_ATTR_SYS_ALL_NOHINT,
creds,
&getattr_resp, NULL);
assert(getattr_resp.attr.objtype == PVFS_TYPE_DIRECTORY);
ret = handlelist_find_handle(hl, pref.handle, &server_idx);
assert(ret == 0);
handlelist_remove_handle(hl, pref.handle, server_idx);
ret = match_dirdata(hl,
NULL /* optional second handle list */,
pref,
creds);
if (ret != 0) {
assert(0);
}
descend(cur_fs, hl, NULL, pref, creds);
return 0;
}
/* Preconditions: none
* Parameters: none
* Postconditions: returns the error code given by lookup - thats if it doesn't segfault or other catostrophic failure
* Hase 1 test cases
*/
static int test_lookup(void)
{
int fs_id, ret;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
char *name;
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "name");
fs_id = 9;
PVFS_util_gen_credentials(&credentials);
ret = PVFS_sys_lookup(fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW);
return ret;
}
/* Preconditions: none
* Parameters: testcase - the test case to be run
* Postconditions: returns error code of readdir
* Has 2 Test cases
*/
static int test_readdir(void)
{
int ret;
PVFS_object_ref pinode_refn;
PVFS_ds_position token;
int pvfs_dirent_incount;
PVFS_credentials credentials;
PVFS_sysresp_readdir resp_readdir;
int fs_id;
PVFS_sysresp_lookup resp_lookup;
char *name;
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "name");
fs_id = 9;
PVFS_util_gen_credentials(&credentials);
if ((ret = PVFS_sys_lookup(
fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0)
{
fprintf(stderr, "lookup failed %d\n", ret);
return -1;
}
pinode_refn = resp_lookup.ref;
token = PVFS_READDIR_START;
pvfs_dirent_incount = 1;
ret =
PVFS_sys_readdir(pinode_refn, token, pvfs_dirent_incount, &credentials,
&resp_readdir);
return ret;
}
static int test_remove_nonempty_dir(int testcase)
{
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_look;
char *filename;
int ret;
int fs_id;
ret = -2;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "/");
PVFS_util_gen_credentials(&credentials);
if (initialize_sysint() < 0)
{
debug_printf("UNABLE TO INIT SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
ret = PVFS_sys_lookup(fs_id, filename, &credentials,
&resp_look, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
printf("Lookup failed with errcode = %d\n", ret);
return (-1);
}
switch (testcase)
{
case 0:
ret = PVFS_sys_remove(NULL, resp_look.ref, &credentials);
break;
default:
fprintf(stderr, "Error: invalid case number \n");
}
return ret;
}
/* Preconditions: None
* Parameters: testcase - the test case to be run
* Postconditions: returns the error returned by mkdir
* Has 2 test cases
*/
static int test_mkdir(void)
{
PVFS_object_ref parent_refn;
PVFS_sys_attr attr;
PVFS_sysresp_mkdir resp_mkdir;
int ret = -2;
int fs_id;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
char *name;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "name");
fs_id = 9;
PVFS_util_gen_credentials(&credentials);
if ((ret = PVFS_sys_lookup(
fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW)) < 0)
{
fprintf(stderr, "lookup failed %d\n", ret);
return -1;
}
parent_refn = resp_lookup.ref;
attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = 1877;
attr.atime = attr.ctime = attr.mtime =
time(NULL);
ret = PVFS_sys_mkdir(name, parent_refn, attr, &credentials, &resp_mkdir);
return ret;
}
static int test_lookup_empty(void)
{
int fs_id, ret;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
char *name;
ret = -2;
name = (char *) malloc(sizeof(char) * 100);
name = strcpy(name, "nofileyea");
if (initialize_sysint() < 0)
{
debug_printf("ERROR UNABLE TO INIT SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
PVFS_util_gen_credentials(&credentials);
ret = PVFS_sys_lookup(fs_id, name, &credentials,
&resp_lookup, PVFS2_LOOKUP_LINK_NO_FOLLOW);
return ret;
}
static int test_permissions(int testcase){
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lk;
PVFS_Request req_io;
PVFS_Request req_mem;
PVFS_sysresp_io resp_io;
PVFS_offset file_req_offset;
char *filename;
char io_buffer[100];
int fs_id, ret;
file_req_offset = 0;
filename = (char *) malloc(sizeof(char) * 100);
filename = strcpy(filename, "name");
memset(&req_io, 0, sizeof(PVFS_Request));
memset(&req_mem, 0, sizeof(PVFS_Request));
memset(&resp_io, 0, sizeof(PVFS_sysresp_io));
PVFS_util_gen_credentials(&credentials);
memset(&resp_lk, 0, sizeof(PVFS_sysresp_lookup));
if (initialize_sysint() < 0)
{
debug_printf("UNABLE TO INIT THE SYSTEM INTERFACE\n");
return -1;
}
fs_id = pvfs_helper.fs_id;
ret = PVFS_sys_lookup(fs_id, filename, &credentials,
&resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
debug_printf("test_pvfs_datatype_hvector: lookup failed "
"on %s\n", filename);
}
switch (testcase)
{
case 0:
credentials.uid = 555;
break;
case 1:
credentials.gid = 555;
break;
case 2:
ret = PVFS_sys_lookup(
fs_id, "invalid_perms", &credentials,
&resp_lk, PVFS2_LOOKUP_LINK_NO_FOLLOW);
if (ret < 0)
{
debug_printf("test_pvfs_datatype_hvector: lookup failed "
"on %s\n", filename);
}
break;
}
ret = PVFS_sys_read(resp_lk.ref, req_io, file_req_offset,io_buffer, req_mem,
&credentials, &resp_io);
/* finalize_sysint(); */
return ret;
}
/* pvfs2_geteattr()
*
* changes the mode of the given file to the given permissions
*
* returns zero on success and negative one on failure
*/
int pvfs2_geteattr(int nkey, PVFS_ds_keyval *key_p,
PVFS_ds_keyval *val_p, char *destfile) {
int ret = -1;
char str_buf[PVFS_NAME_MAX] = {0};
char pvfs_path[PVFS_NAME_MAX] = {0};
PVFS_fs_id cur_fs;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_geteattr resp_geteattr;
PVFS_object_ref parent_ref;
PVFS_credentials credentials;
/* translate local path into pvfs2 relative path */
ret = PVFS_util_resolve(destfile,&cur_fs, pvfs_path, PVFS_NAME_MAX);
if(ret < 0)
{
PVFS_perror("PVFS_util_resolve", ret);
return -1;
}
PVFS_util_gen_credentials(&credentials);
/* this if-else statement just pulls apart the pathname into its
* parts....I think...this should be a function somewhere
*/
if (strcmp(pvfs_path,"/") == 0)
{
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_lookup(cur_fs, pvfs_path,
&credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_lookup", ret);
return -1;
}
parent_ref.handle = resp_lookup.ref.handle;
parent_ref.fs_id = resp_lookup.ref.fs_id;
}
else
{
/* get the absolute path on the pvfs2 file system */
if (PINT_remove_base_dir(pvfs_path,str_buf,PVFS_NAME_MAX))
{
if (pvfs_path[0] != '/')
{
fprintf(stderr, "Error: poorly formatted path.\n");
}
fprintf(stderr, "Error: cannot retrieve entry name for "
"creation on %s\n",pvfs_path);
return -1;
}
ret = PINT_lookup_parent(pvfs_path, cur_fs, &credentials,
&parent_ref.handle);
if(ret < 0)
{
PVFS_perror("PINT_lookup_parent", ret);
return -1;
}
else
{
parent_ref.fs_id = cur_fs;
}
}
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_ref_lookup(parent_ref.fs_id, str_buf,
parent_ref, &credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
if (ret != 0)
{
fprintf(stderr, "Target '%s' does not exist!\n", str_buf);
return -1;
}
/* get extended attribute */
resp_geteattr.val_array = val_p;
ret = PVFS_sys_geteattr_list(resp_lookup.ref,
&credentials, nkey, key_p, &resp_geteattr, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_geteattr failed with errcode", ret);
return(-1);
}
return 0;
}
int main(int argc, char * argv[])
{
FILE * f;
int ret;
PVFS_fs_id curfs;
PVFS_Request file_req;
PVFS_Request mem_req;
int count;
char line[255];
int size;
PVFS_offset offset=0;
PVFS_credentials creds;
PVFS_sysresp_create create_resp;
PVFS_sysresp_io io_resp;
PVFS_sysresp_lookup lookup_resp;
PVFS_sys_attr attr;
const char * filename = "test-accesses-file";
int j = 0, i = 0;
char * membuff;
char errormsg[255];
if(argc < 2)
{
fprintf(stderr, "test-accesses <sizes file>\n");
exit(1);
}
f = fopen(argv[1], "r");
if(!f)
{
fprintf(stderr, "error opening file\n");
return errno;
}
if(fgets(line, 255, f) == NULL)
{
fprintf(stderr, "error in file\n");
exit(1);
}
if(sscanf(line, "%d", &count) < 1)
{
fprintf(stderr, "error in file\n");
exit(1);
}
ret = PVFS_util_init_defaults();
if(ret < 0) goto error;
ret = PVFS_util_get_default_fsid(&curfs);
if(ret < 0) goto error;
ret = PVFS_sys_lookup(curfs, "/", &creds, &lookup_resp, 0, NULL);
if(ret < 0) goto error;
PVFS_util_gen_credentials(&creds);
attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
attr.owner = creds.uid;
attr.group = creds.gid;
attr.perms = 0644;
attr.atime = attr.ctime = attr.mtime = time(NULL);
ret = PVFS_sys_create(
(char*)filename,
lookup_resp.ref, attr, &creds, NULL, &create_resp, NULL, NULL);
if(ret < 0) goto error;
for(; i < count; ++i)
{
if(fgets(line, 255, f) == NULL)
{
fprintf(stderr, "error in file\n");
exit(1);
}
if(sscanf(line, "%d", &size) < 1)
{
fprintf(stderr, "error in file\n");
exit(1);
}
membuff = malloc(size);
assert(membuff);
for(j = 0; j < size; ++j)
{
membuff[j] = j;
}
ret = PVFS_Request_contiguous(
size, PVFS_BYTE, &file_req);
if(ret < 0) goto error;
ret = PVFS_Request_contiguous(
size, PVFS_BYTE, &mem_req);
if(ret < 0) goto error;
printf("Performing Write: offset: %llu, size: %d\n",
llu(offset), size);
ret = PVFS_sys_io(
create_resp.ref, file_req, offset, membuff, mem_req,
&creds, &io_resp, PVFS_IO_WRITE, NULL);
if(ret < 0) goto error;
printf("Write response: size: %llu\n", llu(io_resp.total_completed));
offset += size;
PVFS_Request_free(&mem_req);
PVFS_Request_free(&file_req);
free(membuff);
}
return 0;
error:
fclose(f);
PVFS_sys_remove(
(char*)filename,
lookup_resp.ref,
&creds,
NULL);
PVFS_perror_gossip(errormsg, ret);
fprintf(stderr, "%s\n", errormsg);
return PVFS_get_errno_mapping(ret);
}
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);
}
int do_list(
char *full_path,
char *start,
int fs_id,
struct options *opts)
{
int i = 0, printed_dot_info = 0;
int ret = -1;
int pvfs_dirent_incount;
char *name = NULL, *cur_file = NULL;
PVFS_handle cur_handle;
PVFS_sysresp_lookup lk_response;
PVFS_sysresp_readdirplus rdplus_response;
PVFS_sysresp_getattr getattr_response;
PVFS_credentials credentials;
PVFS_object_ref ref;
PVFS_ds_position token;
uint64_t dir_version = 0;
double begin = 0., end;
subdir *current, *head = NULL, *tail = NULL;
name = start;
memset(&lk_response,0,sizeof(PVFS_sysresp_lookup));
PVFS_util_gen_credentials(&credentials);
if (opts->list_recursive || opts->num_starts > 1)
{
printf("%s%s:\n",full_path,start);
}
ret = PVFS_sys_lookup(fs_id, name, &credentials,
&lk_response, PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
if(ret < 0)
{
PVFS_perror("PVFS_sys_lookup", ret);
return -1;
}
ref.handle = lk_response.ref.handle;
ref.fs_id = fs_id;
pvfs_dirent_incount = MAX_NUM_DIRENTS;
memset(&getattr_response,0,sizeof(PVFS_sysresp_getattr));
if (PVFS_sys_getattr(ref, PVFS_ATTR_SYS_ALL,
&credentials, &getattr_response, NULL) == 0)
{
if ((getattr_response.attr.objtype == PVFS_TYPE_METAFILE) ||
(getattr_response.attr.objtype == PVFS_TYPE_SYMLINK) ||
((getattr_response.attr.objtype == PVFS_TYPE_DIRECTORY) &&
(opts->list_directory)))
{
char segment[128] = {0};
PVFS_sysresp_getparent getparent_resp;
PINT_remove_base_dir(name, segment, 128);
if (strcmp(segment,"") == 0)
{
snprintf(segment,128,"/");
}
if (getattr_response.attr.objtype == PVFS_TYPE_DIRECTORY)
{
if (PVFS_sys_getparent(ref.fs_id, name, &credentials,
&getparent_resp, NULL) == 0)
{
print_dot_and_dot_dot_info_if_required(
getparent_resp.parent_ref);
}
}
if (opts->list_long)
{
print_entry_attr(ref.handle, segment,
&getattr_response.attr, opts);
}
else
{
print_entry(segment, ref.handle, ref.fs_id,
NULL,
0,
opts);
}
return 0;
}
}
if (do_timing)
begin = Wtime();
token = 0;
do
{
memset(&rdplus_response, 0, sizeof(PVFS_sysresp_readdirplus));
ret = PVFS_sys_readdirplus(
ref, (!token ? PVFS_READDIR_START : token),
pvfs_dirent_incount, &credentials,
(opts->list_long) ?
PVFS_ATTR_SYS_ALL : PVFS_ATTR_SYS_ALL_NOSIZE,
&rdplus_response,
NULL);
if(ret < 0)
{
PVFS_perror("PVFS_sys_readdir", ret);
return -1;
}
if (dir_version == 0)
{
dir_version = rdplus_response.directory_version;
}
else if (opts->list_verbose)
{
if (dir_version != rdplus_response.directory_version)
{
fprintf(stderr, "*** directory changed! listing may "
"not be correct\n");
dir_version = rdplus_response.directory_version;
}
}
if (!printed_dot_info)
{
/*
the list_all option prints files starting with .;
the almost_all option skips the '.', '..' printing
*/
print_dot_and_dot_dot_info_if_required(ref);
printed_dot_info = 1;
}
for(i = 0; i < rdplus_response.pvfs_dirent_outcount; i++)
{
cur_file = rdplus_response.dirent_array[i].d_name;
cur_handle = rdplus_response.dirent_array[i].handle;
print_entry(cur_file, cur_handle, fs_id,
&rdplus_response.attr_array[i],
rdplus_response.stat_err_array[i],
opts);
PVFS_sys_attr *attr = &rdplus_response.attr_array[i];
if(attr->objtype == PVFS_TYPE_DIRECTORY && opts->list_recursive)
{
int path_len = strlen(start) + strlen(cur_file) + 1;
current = (subdir *) malloc(sizeof(subdir));
/* Prevent duplicate slashes in path */
if(start[strlen(start)-1] == '/')
{
current->path = (char *) malloc(path_len);
snprintf(current->path,path_len,"%s%s",start,cur_file);
}
else
{
current->path = (char *) malloc(path_len + 1);
snprintf(current->path,path_len+1,"%s/%s",start,cur_file);
}
/* Update linked list of subdirectories to recurse */
current->next = NULL;
if(!head)
{
head = current;
tail = current;
}
else
{
tail->next = current;
tail = current;
}
}
}
token = rdplus_response.token;
if (rdplus_response.pvfs_dirent_outcount)
{
free(rdplus_response.dirent_array);
rdplus_response.dirent_array = NULL;
free(rdplus_response.stat_err_array);
rdplus_response.stat_err_array = NULL;
for (i = 0; i < rdplus_response.pvfs_dirent_outcount; i++) {
if (rdplus_response.attr_array)
{
PVFS_util_release_sys_attr(&rdplus_response.attr_array[i]);
}
}
free(rdplus_response.attr_array);
rdplus_response.attr_array = NULL;
}
} while(rdplus_response.pvfs_dirent_outcount == pvfs_dirent_incount);
if (do_timing) {
end = Wtime();
printf("PVFS_sys_readdirplus took %g msecs\n",
(end - begin));
}
if (rdplus_response.pvfs_dirent_outcount)
{
free(rdplus_response.dirent_array);
rdplus_response.dirent_array = NULL;
free(rdplus_response.stat_err_array);
rdplus_response.stat_err_array = NULL;
for (i = 0; i < rdplus_response.pvfs_dirent_outcount; i++) {
if (rdplus_response.attr_array)
{
PVFS_util_release_sys_attr(&rdplus_response.attr_array[i]);
}
}
free(rdplus_response.attr_array);
rdplus_response.attr_array = NULL;
}
if (opts->list_recursive)
{
current = head;
while(current)
{
printf("\n");
do_list(full_path,current->path,fs_id,opts);
current = current->next;
free(head->path);
free(head);
head = current;
}
}
return 0;
}
/* steps for getting a handle: (it gets a little convoluted, but at least
* it's deterministic)
* . lookup the file.
* . if lookup succeeds, but we were passed MPI_MODE_EXCL, that's an error
* . if lookup fails, the file might not exist.
* in that case, create the file if we were passed MPI_MODE_CREATE
* . if the create fails, that means someone else created the file between
* our call to lookup and our call to create (like if N processors all
* open the same file with MPI_COMM_SELF)
*
* the good news is that only one processor does this and broadcasts the
* handle to everyone else in the communicator
*/
static void fake_an_open(PVFS_fs_id fs_id, char *pvfs_name, int access_mode,
int nr_datafiles, int strip_size,
ADIOI_PVFS2_fs *pvfs2_fs,
open_status *o_status)
{
int ret;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_getparent resp_getparent;
PVFS_sysresp_create resp_create;
PVFS_sys_attr attribs;
PVFS_sys_dist* dist;
ADIOI_PVFS2_makeattribs(&attribs);
if (nr_datafiles > 0 ) {
attribs.dfile_count = nr_datafiles;
attribs.mask |= PVFS_ATTR_SYS_DFILE_COUNT;
}
dist = NULL;
memset(&resp_lookup, 0, sizeof(resp_lookup));
memset(&resp_getparent, 0, sizeof(resp_getparent));
memset(&resp_create, 0, sizeof(resp_create));
ret = PVFS_sys_lookup(fs_id, pvfs_name,
&(pvfs2_fs->credentials), &resp_lookup, PVFS2_LOOKUP_LINK_FOLLOW);
if ( (ret < 0) ) { /* XXX: check what the error was */
if (access_mode & ADIO_CREATE) {
ret = PVFS_sys_getparent(fs_id, pvfs_name,
&(pvfs2_fs->credentials), &resp_getparent);
if (ret < 0) {
FPRINTF(stderr, "pvfs_sys_getparent returns with %d\n", ret);
o_status->error = ret;
return;
}
/* Set the distribution strip size if specified */
if (0 < strip_size) {
/* Note that the distribution is hardcoded here */
dist = PVFS_sys_dist_lookup("simple_stripe");
ret = PVFS_sys_dist_setparam(dist,
"strip_size",
&strip_size);
if (ret < 0)
{
FPRINTF(stderr,
"pvfs_sys_dist_setparam returns with %d\n", ret);
o_status->error = ret;
}
}
/* Perform file creation */
ret = PVFS_sys_create(resp_getparent.basename,
resp_getparent.parent_ref, attribs,
&(pvfs2_fs->credentials), dist, &resp_create);
if (ret < 0) { /* XXX: should only do this for EEXISTS */
ret = PVFS_sys_lookup(fs_id, pvfs_name,
&(pvfs2_fs->credentials), &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW);
if ( ret < 0 ) {
o_status->error = ret;
return;
}
o_status->error = ret;
o_status->object_ref = resp_lookup.ref;
return;
}
o_status->object_ref = resp_create.ref;
} else {
FPRINTF(stderr, "cannot create file without MPI_MODE_CREATE\n");
o_status->error = ret;
return;
}
} else if (access_mode & ADIO_EXCL) {
/* lookup should not succeed if opened with EXCL */
o_status->error = -1; /* XXX: what should it be? */
return;
} else {
o_status->object_ref = resp_lookup.ref;
}
o_status->error = ret;
return;
}
static void fake_an_open(PVFS_fs_id id,
const char *pvfs2_name,
int access_mode,
int stripe_width,
PVFS_size stripe_size,
mca_fs_pvfs2 *pvfs2_fs,
open_status *o_status)
{
int ret;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_getparent resp_getparent;
PVFS_sysresp_create resp_create;
PVFS_sys_attr attribs;
PVFS_sys_dist *dist;
memset(&attribs, 0, sizeof(PVFS_sys_attr));
attribs.owner = geteuid();
attribs.group = getegid();
attribs.perms = 0644;
attribs.mask = PVFS_ATTR_SYS_ALL_SETABLE;
attribs.atime = time(NULL);
attribs.mtime = attribs.atime;
attribs.ctime = attribs.atime;
if (stripe_width > 0 ) {
attribs.dfile_count = stripe_width;
attribs.mask |= PVFS_ATTR_SYS_DFILE_COUNT;
}
dist = NULL;
memset(&resp_lookup, 0, sizeof(resp_lookup));
memset(&resp_getparent, 0, sizeof(resp_getparent));
memset(&resp_create, 0, sizeof(resp_create));
ret = PVFS_sys_lookup(id,
pvfs2_name,
&(pvfs2_fs->credentials),
&resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW);
if ( ret == (-PVFS_ENOENT)) {
if (access_mode & MPI_MODE_CREATE) {
ret = PVFS_sys_getparent(id,
pvfs2_name,
&(pvfs2_fs->credentials),
&resp_getparent);
if (ret < 0) {
opal_output (1, "pvfs_sys_getparent returns with %d\n", ret);
o_status->error = ret;
return;
}
/* Set the distribution stripe size if specified */
if (0 < stripe_size) {
/* Note that the distribution is hardcoded here */
dist = PVFS_sys_dist_lookup ("simple_stripe");
ret = PVFS_sys_dist_setparam (dist,
"strip_size",
&stripe_size);
if (ret < 0) {
opal_output (1,
"pvfs_sys_dist_setparam returns with %d\n", ret);
o_status->error = ret;
}
}
/* Perform file creation */
ret = PVFS_sys_create(resp_getparent.basename,
resp_getparent.parent_ref,
attribs,
&(pvfs2_fs->credentials),
dist,
&resp_create);
/*
#ifdef HAVE_PVFS2_CREATE_WITHOUT_LAYOUT
ret = PVFS_sys_create(resp_getparent.basename,
resp_getparent.parent_ref,
attribs,
&(pvfs2_fs->credentials),
dist,
&resp_create);
#else
ret = PVFS_sys_create(resp_getparent.basename,
resp_getparent.parent_ref,
attribs,
&(pvfs2_fs->credentials),
dist,
NULL,
&resp_create);
#endif
*/
/* if many creates are happening in this directory, the earlier
* sys_lookup may have returned ENOENT, but the sys_create could
* return EEXISTS. That means the file has been created anyway, so
* less work for us and we can just open it up and return the
* handle */
if (ret == (-PVFS_EEXIST)) {
ret = PVFS_sys_lookup(id,
pvfs2_name,
&(pvfs2_fs->credentials),
&resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW);
if ( ret < 0 ) {
o_status->error = ret;
return;
}
o_status->error = ret;
o_status->object_ref = resp_lookup.ref;
return;
}
o_status->object_ref = resp_create.ref;
}
else {
opal_output (10, "cannot create file without MPI_MODE_CREATE\n");
o_status->error = ret;
return;
}
}
else if (access_mode & MPI_MODE_EXCL) {
/* lookup should not succeed if opened with EXCL */
o_status->error = -PVFS_EEXIST;
return;
}
else {
o_status->object_ref = resp_lookup.ref;
}
o_status->error = ret;
return;
}
static int do_stat(const char * pszFile,
const char * pszRelativeFile,
const PVFS_fs_id fs_id,
const PVFS_credentials * credentials,
const struct options * opts)
{
int ret = 0;
PVFS_sysresp_lookup lk_response;
PVFS_object_ref ref;
PVFS_sysresp_getattr getattr_response;
/* Initialize memory */
memset(&lk_response, 0, sizeof(lk_response));
memset(&ref, 0, sizeof(ref));
memset(&getattr_response,0, sizeof(getattr_response));
/* Do we want to follow if the file is a symbolic link */
if(opts->nFollowLink)
{
ret = PVFS_sys_lookup(fs_id,
(char *) pszRelativeFile,
(PVFS_credentials *) credentials,
&lk_response,
PVFS2_LOOKUP_LINK_FOLLOW, NULL);
}
else
{
ret = PVFS_sys_lookup(fs_id,
(char *) pszRelativeFile,
(PVFS_credentials *) credentials,
&lk_response,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
}
if(ret < 0)
{
if(opts->nVerbose)
{
fprintf(stderr, "PVFS_sys_lookup call on [%s]\n", pszRelativeFile);
}
PVFS_perror("PVFS_sys_lookup", ret);
return -1;
}
ref.handle = lk_response.ref.handle;
ref.fs_id = fs_id;
ret = PVFS_sys_getattr(ref,
PVFS_ATTR_SYS_ALL_NOHINT,
(PVFS_credentials *) credentials,
&getattr_response, NULL);
if(ret < 0)
{
PVFS_perror("PVFS_sys_getattr", ret);
return -1;
}
/* Display the attributes for the file */
print_stats(&ref,
pszFile,
pszRelativeFile,
&(getattr_response.attr));
return(0);
}
int generic_open(file_object *obj, PVFS_credentials *credentials,
int nr_datafiles, PVFS_size strip_size,
char *srcname, int open_type)
{
struct stat stat_buf;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_getattr resp_getattr;
PVFS_sysresp_create resp_create;
PVFS_object_ref parent_ref;
PVFS_sys_dist *new_dist;
int ret = -1;
char *entry_name; /* name of the pvfs2 file */
char str_buf[PVFS_NAME_MAX]; /* basename of pvfs2 file */
if (obj->fs_type == UNIX_FILE)
{
memset(&stat_buf, 0, sizeof(struct stat));
stat(obj->u.ufs.path, &stat_buf);
if (open_type == OPEN_SRC)
{
if (S_ISDIR(stat_buf.st_mode))
{
fprintf(stderr, "Source cannot be a directory\n");
return(-1);
}
obj->u.ufs.fd = open(obj->u.ufs.path, O_RDONLY);
obj->u.ufs.mode = (int)stat_buf.st_mode;
}
else
{
if (S_ISDIR(stat_buf.st_mode))
{
if (srcname)
{
strncat(obj->u.ufs.path, basename(srcname), NAME_MAX);
}
else
{
fprintf(stderr, "cannot find name for "
"destination. giving up\n");
return(-1);
}
}
obj->u.ufs.fd = open(obj->u.ufs.path,
O_WRONLY|O_CREAT|O_LARGEFILE|O_TRUNC,0666);
}
if (obj->u.ufs.fd < 0)
{
perror("open");
fprintf(stderr, "could not open %s\n", obj->u.ufs.path);
return (-1);
}
}
else
{
entry_name = str_buf;
/* it's a PVFS2 file */
if (strcmp(obj->u.pvfs2.pvfs2_path, "/") == 0)
{
/* special case: PVFS2 root file system, so stuff the end of
* srcfile onto pvfs2_path */
char *segp = NULL, *prev_segp = NULL;
void *segstate = NULL;
/* can only perform this special case if we know srcname */
if (srcname == NULL)
{
fprintf(stderr, "unable to guess filename in "
"toplevel PVFS2\n");
return -1;
}
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_lookup(obj->u.pvfs2.fs_id, obj->u.pvfs2.pvfs2_path,
credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW, hints);
if (ret < 0)
{
PVFS_perror("PVFS_sys_lookup", ret);
return (-1);
}
parent_ref.handle = resp_lookup.ref.handle;
parent_ref.fs_id = resp_lookup.ref.fs_id;
while (!PINT_string_next_segment(srcname, &segp, &segstate))
{
prev_segp = segp;
}
entry_name = prev_segp; /* see... points to basename of srcname */
}
else /* given either a pvfs2 directory or a pvfs2 file */
{
/* get the absolute path on the pvfs2 file system */
/*parent_ref.fs_id = obj->pvfs2.fs_id; */
if (PINT_remove_base_dir(obj->u.pvfs2.pvfs2_path,str_buf,
PVFS_NAME_MAX))
{
if(obj->u.pvfs2.pvfs2_path[0] != '/')
{
fprintf(stderr, "Error: poorly formatted path.\n");
}
fprintf(stderr, "Error: cannot retrieve entry name for "
"creation on %s\n", obj->u.pvfs2.user_path);
return(-1);
}
ret = PINT_lookup_parent(obj->u.pvfs2.pvfs2_path,
obj->u.pvfs2.fs_id, credentials,
&parent_ref.handle);
if (ret < 0)
{
PVFS_perror("PVFS_util_lookup_parent", ret);
return (-1);
}
else /* parent lookup succeeded. if the pvfs2 path is just a
directory, use basename of src for the new file */
{
int len = strlen(obj->u.pvfs2.pvfs2_path);
if (obj->u.pvfs2.pvfs2_path[len - 1] == '/')
{
char *segp = NULL, *prev_segp = NULL;
void *segstate = NULL;
if (srcname == NULL)
{
fprintf(stderr, "unable to guess filename\n");
return(-1);
}
while (!PINT_string_next_segment(srcname,
&segp, &segstate))
{
prev_segp = segp;
}
strncat(obj->u.pvfs2.pvfs2_path, prev_segp, PVFS_NAME_MAX);
entry_name = prev_segp;
}
parent_ref.fs_id = obj->u.pvfs2.fs_id;
}
}
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_ref_lookup(parent_ref.fs_id, entry_name,
parent_ref, credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW, hints);
if ((ret == 0) && (open_type == OPEN_SRC))
{
memset(&resp_getattr, 0, sizeof(PVFS_sysresp_getattr));
ret = PVFS_sys_getattr(resp_lookup.ref, PVFS_ATTR_SYS_ALL_NOHINT,
credentials, &resp_getattr, hints);
if (ret)
{
fprintf(stderr, "Failed to do pvfs2 getattr on %s\n",
entry_name);
return -1;
}
if (resp_getattr.attr.objtype == PVFS_TYPE_SYMLINK)
{
free(resp_getattr.attr.link_target);
resp_getattr.attr.link_target = NULL;
}
obj->u.pvfs2.perms = resp_getattr.attr.perms;
memcpy(&obj->u.pvfs2.attr, &resp_getattr.attr,
sizeof(PVFS_sys_attr));
obj->u.pvfs2.attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
}
/* at this point, we have looked up the file in the parent directory.
* . If we found something, and we are the SRC, then we're done.
* . We will maintain the semantic of pvfs2-import and refuse to
* overwrite existing PVFS2 files, so if we found something, and we
* are the DEST, then that's an error.
* . Otherwise, we found nothing and we will create the destination.
*/
if (open_type == OPEN_SRC)
{
if (ret == 0)
{
obj->u.pvfs2.ref = resp_lookup.ref;
return 0;
}
else
{
PVFS_perror("PVFS_sys_ref_lookup", ret);
return (ret);
}
}
if (open_type == OPEN_DEST)
{
if (ret == 0)
{
obj->u.pvfs2.ref = resp_lookup.ref;
return 0;
}
else
{
memset(&stat_buf, 0, sizeof(struct stat));
/* preserve permissions doing a unix => pvfs2 copy */
stat(srcname, &stat_buf);
make_attribs(&(obj->u.pvfs2.attr), credentials, nr_datafiles,
(int)stat_buf.st_mode);
if (strip_size > 0) {
new_dist = PVFS_sys_dist_lookup("simple_stripe");
ret = PVFS_sys_dist_setparam(new_dist, "strip_size", &strip_size);
if (ret < 0)
{
PVFS_perror("PVFS_sys_dist_setparam", ret);
return -1;
}
}
else {
new_dist=NULL;
}
ret = PVFS_sys_create(entry_name, parent_ref,
obj->u.pvfs2.attr, credentials,
new_dist, &resp_create, NULL, hints);
if (ret < 0)
{
PVFS_perror("PVFS_sys_create", ret);
return -1;
}
obj->u.pvfs2.ref = resp_create.ref;
}
}
}
return 0;
}
int main(int argc, char **argv)
{
PVFS_error pvfs_error;
int i;
char test_file[PATH_MAX];
PVFS_sys_attr attr;
PVFS_fs_id cur_fs;
PVFS_credentials credentials;
PVFS_sysresp_lookup lookup_resp;
PVFS_sysresp_create create_resp;
char basepath[PATH_MAX];
int rank, nprocs, ret;
MPI_Info info;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
parse_args(argc, argv);
/* provide hints if you want */
info = MPI_INFO_NULL;
if (rank == 0)
{
printf("\nprocs: %d\nops: %d\n===========\n", nprocs, opt_nfiles);
}
ret = PVFS_util_init_defaults();
if(ret != 0)
{
PVFS_perror("PVFS_util_init_defaults", ret);
return ret;
}
ret = PVFS_util_resolve(opt_basedir, &cur_fs, basepath, PATH_MAX);
if(ret != 0)
{
PVFS_perror("PVFS_util_resolve", ret);
return ret;
}
PVFS_util_gen_credentials(&credentials);
pvfs_error = PVFS_sys_lookup(
cur_fs, basepath, &credentials, &lookup_resp,
PVFS2_LOOKUP_LINK_NO_FOLLOW);
if(pvfs_error != 0)
{
PVFS_perror("PVFS_sys_lookup", pvfs_error);
return PVFS_get_errno_mapping(pvfs_error);
}
attr.mask = PVFS_ATTR_SYS_ALL_SETABLE;
attr.owner = credentials.uid;
attr.group = credentials.gid;
attr.perms = 1877;
attr.atime = attr.ctime = attr.mtime = time(NULL);
/* synchronize with other clients (if any) */
MPI_Barrier(MPI_COMM_WORLD);
for(i = 0; i < opt_nfiles; ++i)
{
memset(test_file, 0, PATH_MAX);
snprintf(test_file, PATH_MAX, "testfile.%d.%d", rank, i);
test_util_start_timing();
pvfs_error = PVFS_sys_create(test_file, lookup_resp.ref,
attr, &credentials,
NULL, NULL, &create_resp);
test_util_stop_timing();
if(pvfs_error != 0)
{
PVFS_perror("PVFS_sys_craete", pvfs_error);
return PVFS_get_errno_mapping(pvfs_error);
}
test_util_print_timing(rank);
}
for(i = 0; i < opt_nfiles; ++i)
{
memset(test_file, 0, PATH_MAX);
snprintf(test_file, PATH_MAX, "testfile.%d.%d", rank, i);
pvfs_error = PVFS_sys_remove(test_file, lookup_resp.ref, &credentials);
if(pvfs_error != 0)
{
fprintf(stderr, "Failed to remove: %s\n", test_file);
PVFS_perror("PVFS_sys_remove", pvfs_error);
return PVFS_get_errno_mapping(pvfs_error);
}
}
MPI_Finalize();
return 0;
}
