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; }