/* 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; }
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; }
/* 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; }
int create_dir(PVFS_object_ref parent_refn, char *name, PVFS_object_ref *out_refn) { int ret = -1; PVFS_sys_attr attr; PVFS_credentials credentials; PVFS_sysresp_mkdir resp_mkdir; memset(&attr, 0, sizeof(PVFS_sys_attr)); memset(&resp_mkdir, 0, sizeof(resp_mkdir)); PVFS_util_gen_credentials(&credentials); attr.owner = credentials.uid; attr.group = credentials.gid; attr.atime = attr.mtime = attr.ctime = time(NULL); attr.perms = (PVFS_U_WRITE | PVFS_U_READ); attr.mask = PVFS_ATTR_SYS_ALL_SETABLE; ret = PVFS_sys_mkdir(name, parent_refn, attr, &credentials, &resp_mkdir); if (ret < 0) { printf("mkdir failed\n"); return (-1); } if (out_refn) { memset(out_refn, 0, sizeof(PVFS_object_ref)); memcpy(out_refn, &resp_mkdir.ref, sizeof(PVFS_object_ref)); } return 0; }
/* * 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; }
/* * 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 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; }
/* 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_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; }
void print_entry( char *entry_name, PVFS_handle handle, PVFS_fs_id fs_id, PVFS_sys_attr *attr, int attr_error, struct options *opts) { int ret = -1; PVFS_object_ref ref; PVFS_credentials credentials; PVFS_sysresp_getattr getattr_response; if (!opts->list_long) { if (opts->list_inode) { printf("%llu %s\n", llu(handle), entry_name); } else { printf("%s\n", entry_name); } return; } if (attr_error == 0) { if(!attr) { /* missing attributes (possibly for . or .. entries); get them * the old fashioned way */ ref.handle = handle; ref.fs_id = fs_id; memset(&getattr_response,0, sizeof(PVFS_sysresp_getattr)); PVFS_util_gen_credentials(&credentials); ret = PVFS_sys_getattr(ref, PVFS_ATTR_SYS_ALL_NOHINT, &credentials, &getattr_response, NULL); if (ret) { fprintf(stderr,"Failed to get attributes on handle %llu,%d\n", llu(handle),fs_id); PVFS_perror("Getattr failure", ret); return; } print_entry_attr(handle, entry_name, &getattr_response.attr, opts); } else { print_entry_attr(handle, entry_name, attr, opts); } } }
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; }
int pvfsInit() { int ret; PVFS_hint_import_env(& hints); ret = PVFS_util_init_defaults(); if(ret < 0) { PVFS_perror("PVFS_util_init_defaults",ret); return -1; } PVFS_util_gen_credentials(&credentials); }
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; }
int main(int argc, char **argv) { int ret = -1; PVFS_fs_id cur_fs; struct options* user_opts = NULL; char pvfs_path[PVFS_NAME_MAX] = {0}; PVFS_credentials creds; /* look at command line arguments */ user_opts = parse_args(argc, argv); if(!user_opts) { fprintf(stderr, "Error: failed to parse command line arguments.\n"); usage(argc, argv); return(-1); } ret = PVFS_util_init_defaults(); if(ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return(-1); } /* translate local path into pvfs2 relative path */ ret = PVFS_util_resolve(user_opts->mnt_point, &cur_fs, pvfs_path, PVFS_NAME_MAX); if(ret < 0) { fprintf(stderr, "Error: could not find filesystem for %s in pvfstab\n", user_opts->mnt_point); return(-1); } PVFS_util_gen_credentials(&creds); ret = PVFS_mgmt_setparam_all(cur_fs, &creds, PVFS_SERV_PARAM_DROP_CACHES, 0, NULL, NULL /* detailed errors */); if(ret < 0) { PVFS_perror("PVFS_mgmt_setparam_all", ret); return(-1); } PVFS_sys_finalize(); return(ret); }
static int pvfs_generate_serverlist(){ int ret, servercount, i; PVFS_credentials credentials; PVFS_util_gen_credentials(&credentials); // What hostname are we using if (!myhostname) myhostname = getenv("HOSTNAME"); if (!myhostname){ myhostname = malloc(HOST_NAME_MAX + 1); gethostname(myhostname, HOST_NAME_MAX); myhostname[HOST_NAME_MAX] = '\0'; } skye_options.servernum = -1; ret = PVFS_mgmt_count_servers(pvfs_fsid,&credentials,PVFS_MGMT_META_SERVER,&servercount); if (ret < 0) return ret; skye_options.serveraddrs = malloc(sizeof(PVFS_BMI_addr_t)*(servercount)); if (!skye_options.serveraddrs) return -ENOMEM; ret = PVFS_mgmt_get_server_array(pvfs_fsid,&credentials,PVFS_MGMT_META_SERVER, skye_options.serveraddrs, &servercount); if (ret < 0) return ret; const char **servers = malloc(sizeof(char*)*(servercount)); if (!servers) return -ENOMEM; for (i = 0; i < servercount; i++){ servers[i] = PVFS_mgmt_map_addr(pvfs_fsid,&credentials,skye_options.serveraddrs[i],NULL); char *start, *end; /* cut out just the server portion of tcp://servername:port */ end = rindex(servers[i], ':'); start = rindex(servers[i], '/'); servers[i] = strndup(start + 1, end - start - 1); if (!servers[i]) return -ENOMEM; if (strcmp(servers[i],myhostname) == 0) skye_options.servernum = i; } skye_options.serverlist = servers; skye_options.servercount = servercount; return 0; }
/* * simple helper to remove a pvfs2 file * * returns 0 on success. * -1 if some error happened. */ int remove_file(PVFS_object_ref parent_refn, char *name) { int ret = -1; PVFS_credentials credentials; PVFS_util_gen_credentials(&credentials); ret = PVFS_sys_remove(name, parent_refn, &credentials); if (ret < 0) { printf("remove failed\n"); return ret; } 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; }
/* * file_delete_pvfs2 * * Function: - deletes a file * Accepts: - file name & info * Returns: - Success if file closed */ int mca_fs_pvfs2_file_delete (char* file_name, struct ompi_info_t *info) { PVFS_credentials credentials; PVFS_sysresp_getparent resp_getparent; int ret; PVFS_fs_id pvfs2_id; char pvfs2_path[OMPIO_MAX_NAME] = {0}; char * ncache_timeout; if (!mca_fs_pvfs2_IS_INITIALIZED) { /* disable the pvfs2 ncache */ ncache_timeout = getenv("PVFS2_NCACHE_TIMEOUT"); if (ncache_timeout == NULL ) setenv("PVFS2_NCACHE_TIMEOUT", "0", 1); ret = PVFS_util_init_defaults(); if (ret < 0) { return OMPI_ERROR; } mca_fs_pvfs2_IS_INITIALIZED = 1; } memset (&credentials, 0, sizeof(PVFS_credentials)); PVFS_util_gen_credentials (&credentials); ret = PVFS_util_resolve(file_name, &pvfs2_id, pvfs2_path, OMPIO_MAX_NAME); if (ret != 0) { return OMPI_ERROR; } ret = PVFS_sys_getparent(pvfs2_id, pvfs2_path, &credentials, &resp_getparent); ret = PVFS_sys_remove(resp_getparent.basename, resp_getparent.parent_ref, &credentials); if (ret != 0) { return OMPI_ERROR; } return OMPI_SUCCESS; }
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 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; }
/* 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; }
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; }
/* given mount information, retrieve the server's configuration by issuing a getconfig operation. on successful response, we parse the configuration and fill in the config object specified. returns 0 on success, -errno on error */ int PVFS_mgmt_get_config( const PVFS_fs_id * fsid, PVFS_BMI_addr_t * addr, char *fs_buf, int fs_buf_size) { int ret = -PVFS_EINVAL; PINT_smcb *smcb = NULL; PINT_client_sm *sm_p = NULL; PVFS_error error = 0; PVFS_credentials creds; struct filesystem_configuration_s *cur_fs = NULL; PVFS_sys_op_id op_id; struct server_configuration_s *config = NULL; struct PVFS_sys_mntent mntent; int server_type = 0; gossip_debug(GOSSIP_CLIENT_DEBUG, "PVFS_mgmt_get_config entered\n"); PVFS_util_gen_credentials(&creds); PINT_smcb_alloc(&smcb, PVFS_SERVER_GET_CONFIG, sizeof(struct PINT_client_sm), client_op_state_get_machine, client_state_machine_terminate, pint_client_sm_context); if(smcb == NULL) { return -PVFS_ENOMEM; } sm_p = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); sm_p->u.get_config.persist_config_buffers = 1; PINT_init_msgarray_params(sm_p, *fsid); PINT_init_sysint_credentials(sm_p->cred_p, &creds); config = PINT_get_server_config_struct(*fsid); mntent.the_pvfs_config_server = (char*)PINT_cached_config_map_addr(*fsid, *addr, &server_type); PINT_put_server_config_struct(config); cur_fs = PINT_config_find_fs_id(config, *fsid); mntent.encoding = cur_fs->encoding; mntent.flowproto = cur_fs->flowproto; mntent.fs_id = *fsid; mntent.pvfs_fs_name = cur_fs->file_system_name; sm_p->u.get_config.config = config; sm_p->msgarray_op.msgpair.enc_type = cur_fs->encoding; sm_p->u.get_config.mntent = &mntent; PINT_msgpair_init(&sm_p->msgarray_op); ret = PINT_client_state_machine_post( smcb, &op_id, NULL); if (ret) { PVFS_perror_gossip("PINT_client_state_machine_post call", ret); error = ret; } else { ret = PVFS_mgmt_wait(op_id, "X-get_config", &error); if (ret) { PVFS_perror_gossip("PVFS_mgmt_wait call", ret); error = ret; } } if (error) { goto exit_path; } gossip_debug(GOSSIP_CLIENT_DEBUG, "PVFS_mgmt_get_config completed\n"); /* make sure strings will be null terminated after strncpy */ fs_buf[fs_buf_size-1] = '\0'; /* The following copies the retrieved configuration buffers into the return buffers */ strncpy(fs_buf, sm_p->u.get_config.fs_config_buf, (fs_buf_size - 1)); exit_path: if (sm_p && sm_p->u.get_config.persist_config_buffers) { free(sm_p->u.get_config.fs_config_buf); sm_p->u.get_config.fs_config_buf = NULL; } PINT_mgmt_release(op_id); return error; }
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) { int ret = -1, in_admin_mode = 0; PVFS_fs_id cur_fs; char pvfs_path[PVFS_NAME_MAX] = {0}; PVFS_credentials creds; int server_count; PVFS_BMI_addr_t *addr_array = NULL; struct handlelist *hl_all, *hl_unrefd, *hl_notree; struct PVFS_mgmt_setparam_value param_value; fsck_opts = parse_args(argc, argv); if (!fsck_opts) { fprintf(stderr, "Error: failed to parse command line arguments.\n"); usage(argc, argv); return -1; } ret = PVFS_util_init_defaults(); if (ret != 0) { PVFS_perror("PVFS_util_init_defaults", ret); return -1; } /* translate local path into pvfs2 relative path */ ret = PVFS_util_resolve(fsck_opts->mnt_point, &cur_fs, pvfs_path, PVFS_NAME_MAX); if (ret != 0) { PVFS_perror("PVFS_util_resolve", ret); return -1; } PVFS_util_gen_credentials(&creds); printf("# Current FSID is %u.\n", cur_fs); /* count how many servers we have */ ret = PVFS_mgmt_count_servers(cur_fs, &creds, PVFS_MGMT_IO_SERVER|PVFS_MGMT_META_SERVER, &server_count); if (ret != 0) { PVFS_perror("PVFS_mgmt_count_servers", ret); return -1; } /* build a list of servers to talk to */ addr_array = (PVFS_BMI_addr_t *) malloc(server_count * sizeof(PVFS_BMI_addr_t)); if (addr_array == NULL) { perror("malloc"); return -1; } ret = PVFS_mgmt_get_server_array(cur_fs, &creds, PVFS_MGMT_IO_SERVER|PVFS_MGMT_META_SERVER, addr_array, &server_count); if (ret != 0) { PVFS_perror("PVFS_mgmt_get_server_array", ret); return -1; } /* create /lost+found, if it isn't there already */ ret = create_lost_and_found(cur_fs, &creds); if (ret != 0) { if (ret == -PVFS_EAGAIN) { printf("Failed to create lost+found: likely the system is " "already in admin mode. Use pvfs2-set-mode to change " "back to normal mode prior to running pvfs2-fsck.\n"); } return -1; } param_value.type = PVFS_MGMT_PARAM_TYPE_UINT64; param_value.u.value = PVFS_SERVER_ADMIN_MODE; /* put the servers into administrative mode */ ret = PVFS_mgmt_setparam_list(cur_fs, &creds, PVFS_SERV_PARAM_MODE, ¶m_value, addr_array, server_count, NULL, /* detailed errors */ NULL); if (ret != 0) { PVFS_perror("PVFS_mgmt_setparam_list", ret); ret = -1; goto exit_now; } in_admin_mode = 1; hl_all = build_handlelist(cur_fs, addr_array, server_count, &creds); if (hl_all == NULL) { ret = -1; goto exit_now; } /* first pass traverses the directory tree: * - cleans up any direntries that refer to missing objects * - verifies that files in the tree have all their datafiles * (or repairs if possible) * - verifies that all directories have their dirdata * (or repairs if possible) */ printf("# first pass: traversing directory tree.\n"); traverse_directory_tree(cur_fs, hl_all, addr_array, server_count, &creds); /* second pass examines handles not in the directory tree: * - finds orphaned "sub trees" and keeps references to head * - verifies files in the sub tree have all datafiles * (or repairs if possible) * - verifies all sub tree directories have their dirdata * (or repairs if possible) * - builds list of metafile, dirdata, and datafiles not referenced * in some sub tree to be processed later */ printf("# second pass: finding orphaned sub trees.\n"); hl_notree = find_sub_trees(cur_fs, hl_all, addr_array, &creds); handlelist_finalize(&hl_all); param_value.type = PVFS_MGMT_PARAM_TYPE_UINT64; param_value.u.value = PVFS_SERVER_NORMAL_MODE; /* drop out of admin mode now that we've traversed the dir tree */ PVFS_mgmt_setparam_list(cur_fs, &creds, PVFS_SERV_PARAM_MODE, ¶m_value, addr_array, server_count, NULL, NULL); in_admin_mode = 0; /* third pass moves salvagable objects into lost+found: * - moves sub trees into lost+found * - verifies that orphaned files have all their datafiles * (or repairs if possible) * - if orphaned file is salvagable, moves into lost+found * - builds list of remaining dirdata and datafiles not * referenced in sub tree or orphaned file */ printf("# third pass: moving orphaned sub trees and files to lost+found.\n"); hl_unrefd = fill_lost_and_found(cur_fs, hl_notree, addr_array, &creds); handlelist_finalize(&hl_notree); /* fourth pass removes orphaned dirdata and datafiles * left from the previous passes. */ printf("# fourth pass: removing unreferenced objects.\n"); cull_leftovers(cur_fs, hl_unrefd, addr_array, &creds); handlelist_finalize(&hl_unrefd); exit_now: if (in_admin_mode) { param_value.type = PVFS_MGMT_PARAM_TYPE_UINT64; param_value.u.value = PVFS_SERVER_NORMAL_MODE; /* get us out of admin mode */ PVFS_mgmt_setparam_list(cur_fs, &creds, PVFS_SERV_PARAM_MODE, ¶m_value, addr_array, server_count, NULL, NULL); } PVFS_sys_finalize(); if (addr_array != NULL) free(addr_array); if (fsck_opts != NULL) free(fsck_opts); return(ret); }
/* * file_open_pvfs2: This is the same strategy as ROMIO's pvfs2 open * * Function: - opens a new file * Accepts: - same arguments as MPI_File_open() * Returns: - Success if new file handle */ int mca_fs_pvfs2_file_open (struct ompi_communicator_t *comm, const char* filename, int access_mode, struct ompi_info_t *info, mca_io_ompio_file_t *fh) { int ret; mca_fs_pvfs2 *pvfs2_fs; PVFS_fs_id pvfs2_id; char pvfs2_path[OMPIO_MAX_NAME] = {0}; char * ncache_timeout; open_status o_status = {0, {0, 0}}; struct ompi_datatype_t *open_status_type; struct ompi_datatype_t *types[2] = {&ompi_mpi_int.dt, &ompi_mpi_byte.dt}; int lens[2] = {1, sizeof(PVFS_object_ref)}; OPAL_PTRDIFF_TYPE offsets[2]; char char_stripe[MPI_MAX_INFO_KEY]; int flag; int fs_pvfs2_stripe_size = -1; int fs_pvfs2_stripe_width = -1; /* We are going to do what ROMIO does with one process resolving * the name and broadcasting to others */ pvfs2_fs = (mca_fs_pvfs2 *) malloc(sizeof(mca_fs_pvfs2)); if (NULL == pvfs2_fs) { opal_output (1, "OUT OF MEMORY\n"); return OMPI_ERR_OUT_OF_RESOURCE; } if (!mca_fs_pvfs2_IS_INITIALIZED) { /* disable the pvfs2 ncache */ ncache_timeout = getenv("PVFS2_NCACHE_TIMEOUT"); if (ncache_timeout == NULL ) { setenv("PVFS2_NCACHE_TIMEOUT", "0", 1); } ret = PVFS_util_init_defaults(); if (ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return OMPI_ERROR; } mca_fs_pvfs2_IS_INITIALIZED = 1; } memset(&(pvfs2_fs->credentials), 0, sizeof(PVFS_credentials)); PVFS_util_gen_credentials(&(pvfs2_fs->credentials)); /* check for stripe size and stripe depth in the info object and update mca_fs_pvfs2_stripe_width and mca_fs_pvfs2_stripe_size before calling fake_an_open() */ ompi_info_get (info, "stripe_size", MPI_MAX_INFO_VAL, char_stripe, &flag); if ( flag ) { sscanf ( char_stripe, "%d", &fs_pvfs2_stripe_size ); } ompi_info_get (info, "stripe_width", MPI_MAX_INFO_VAL, char_stripe, &flag); if ( flag ) { sscanf ( char_stripe, "%d", &fs_pvfs2_stripe_width ); } if (fs_pvfs2_stripe_size < 0) { fs_pvfs2_stripe_size = mca_fs_pvfs2_stripe_size; } if (fs_pvfs2_stripe_width < 0) { fs_pvfs2_stripe_width = mca_fs_pvfs2_stripe_width; } if (OMPIO_ROOT == fh->f_rank) { ret = PVFS_util_resolve(filename, &pvfs2_id, pvfs2_path, OMPIO_MAX_NAME); if (ret < 0 ) { PVFS_perror("PVFS_util_resolve", ret); o_status.error = -1; } else { fake_an_open (pvfs2_id, pvfs2_path, access_mode, fs_pvfs2_stripe_width, (PVFS_size)fs_pvfs2_stripe_size, pvfs2_fs, &o_status); } pvfs2_fs->object_ref = o_status.object_ref; fh->f_fs_ptr = pvfs2_fs; } /* broadcast status and (possibly valid) object reference */ offsets[0] = (MPI_Aint)(&o_status.error); offsets[1] = (MPI_Aint)(&o_status.object_ref); ompi_datatype_create_struct (2, lens, offsets, types, &open_status_type); ompi_datatype_commit (&open_status_type); fh->f_comm->c_coll.coll_bcast (MPI_BOTTOM, 1, open_status_type, OMPIO_ROOT, fh->f_comm, fh->f_comm->c_coll.coll_bcast_module); ompi_datatype_destroy (&open_status_type); if (o_status.error != 0) { /* No need to free the pvfs2_fs structure, since it will be deallocated in file_close in case of an error */ fh->f_fs_ptr = NULL; return OMPI_ERROR; } pvfs2_fs->object_ref = o_status.object_ref; fh->f_fs_ptr = pvfs2_fs; /* update the internal ompio structure to store stripe size and stripe depth correctly. Hadi(to be done): For this read the stripe size and stripe depth from the file itself */ if (fs_pvfs2_stripe_size > 0 && fs_pvfs2_stripe_width > 0) { fh->f_stripe_size = fs_pvfs2_stripe_size; fh->f_stripe_count = fs_pvfs2_stripe_width; } return OMPI_SUCCESS; }
int main(int argc, char **argv) { int ret = -1, i = 0; char ** ppszPvfsPath = NULL; PVFS_fs_id * pfs_id = NULL; PVFS_credentials credentials; struct options user_opts; /* Initialize any memory */ memset(&user_opts, 0, sizeof(user_opts)); memset(&credentials, 0, sizeof(credentials)); ret = parse_args(argc, argv, &user_opts); if(ret < 0) { fprintf(stderr, "Error: failed to parse command line arguments.\n"); usage(argc, argv); return(-1); } if(user_opts.nVerbose) { fprintf(stdout, "Starting pvfs2-stat\n"); } /* Allocate space to hold the relative pvfs2 path & fs_id for each * requested file */ ppszPvfsPath = (char **)calloc(user_opts.nNumFiles, sizeof(char *)); if(ppszPvfsPath == NULL) { fprintf(stderr, "Unable to allocate memory\n"); return(-1); } /* Allocate enough space to hold file system id for each directory */ pfs_id = (PVFS_fs_id *)calloc(user_opts.nNumFiles, sizeof(PVFS_fs_id)); if(pfs_id == NULL) { fprintf(stderr, "Unable to allocate memory\n"); return(-1); } for(i = 0; i < user_opts.nNumFiles; i++) { ppszPvfsPath[i] = (char *)calloc(PVFS_NAME_MAX, sizeof(char)); if(ppszPvfsPath[i] == NULL) { fprintf(stderr, "Unable to allocate memory\n"); return(-1); } } ret = PVFS_util_init_defaults(); if(ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return(-1); } /* Let's verify that all the given files reside on a PVFS2 filesytem */ for(i = 0; i < user_opts.nNumFiles; i++) { ret = PVFS_util_resolve(user_opts.pszFiles[i], &pfs_id[i], ppszPvfsPath[i], PVFS_NAME_MAX); if (ret < 0) { fprintf(stderr, "Error: could not find file system for %s\n", user_opts.pszFiles[i]); return(-1); } } /* We will re-use the same credentials for each call */ PVFS_util_gen_credentials(&credentials); for(i = 0; i < user_opts.nNumFiles; i++) { ret = do_stat(user_opts.pszFiles[i], ppszPvfsPath[i], pfs_id[i], &credentials, &user_opts); if(ret != 0) { fprintf(stderr, "Error stating [%s]\n", user_opts.pszFiles[i]); } } PVFS_sys_finalize(); /* Deallocate any allocated memory */ if(user_opts.pszFiles != NULL) { free(user_opts.pszFiles); } if(ppszPvfsPath != NULL) { for(i=0;i<user_opts.nNumFiles;i++) { if(ppszPvfsPath[i] != NULL) { free(ppszPvfsPath[i]); } } free(ppszPvfsPath); } if(pfs_id != NULL) { free(pfs_id); } return(0); }
int main(int argc,char **argv) { int ret = -1; char str_buf[256] = {0}; char *filename = (char *)0; PVFS_fs_id cur_fs; char* entry_name; PVFS_object_ref parent_refn; PVFS_credentials credentials; if (argc != 2) { printf("usage: %s file_to_remove\n", argv[0]); return 1; } filename = argv[1]; ret = PVFS_util_init_defaults(); if (ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return (-1); } ret = PVFS_util_get_default_fsid(&cur_fs); if (ret < 0) { PVFS_perror("PVFS_util_get_default_fsid", ret); return (-1); } if (PINT_remove_base_dir(filename,str_buf,256)) { if (filename[0] != '/') { printf("You forgot the leading '/'\n"); } printf("Cannot retrieve entry name for creation on %s\n", filename); return(-1); } printf("File to be removed is %s\n",str_buf); entry_name = str_buf; PVFS_util_gen_credentials(&credentials); ret = PINT_lookup_parent(filename, cur_fs, &credentials, &parent_refn.handle); if(ret < 0) { PVFS_perror("PVFS_util_lookup_parent", ret); return(-1); } parent_refn.fs_id = cur_fs; ret = PVFS_sys_remove(entry_name, parent_refn, &credentials, NULL); if (ret < 0) { PVFS_perror("remove failed ", ret); return(-1); } printf("===================================\n"); printf("file named %s has been removed.\n", filename); //close it down ret = PVFS_sys_finalize(); if (ret < 0) { printf("finalizing sysint failed with errcode = %d\n", ret); return (-1); } return(0); }
int main(int argc, char **argv) { int ret = -1; char str_buf[256] = {0}; char *filename = (char *)0; PVFS_fs_id cur_fs; PVFS_sysresp_symlink resp_sym; char* entry_name = NULL; char *target = NULL; PVFS_object_ref parent_refn; PVFS_sys_attr attr; PVFS_credentials credentials; if (argc != 3) { fprintf(stderr,"Usage: %s filename target\n",argv[0]); return ret; } filename = argv[1]; target = argv[2]; ret = PVFS_util_init_defaults(); if (ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return (-1); } ret = PVFS_util_get_default_fsid(&cur_fs); if (ret < 0) { PVFS_perror("PVFS_util_get_default_fsid", ret); return (-1); } if (PINT_remove_base_dir(filename,str_buf,256)) { if (filename[0] != '/') { printf("You forgot the leading '/'\n"); } printf("Cannot retrieve link name for creation on %s\n", filename); return(-1); } printf("Link to be created is %s\n",str_buf); memset(&resp_sym, 0, sizeof(PVFS_sysresp_symlink)); PVFS_util_gen_credentials(&credentials); entry_name = str_buf; 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 = PINT_lookup_parent(filename, cur_fs, &credentials, &parent_refn.handle); if(ret < 0) { PVFS_perror("PVFS_util_lookup_parent", ret); return(-1); } parent_refn.fs_id = cur_fs; ret = PVFS_sys_symlink(entry_name, parent_refn, target, attr, &credentials, &resp_sym, NULL); if (ret < 0) { printf("symlink failed with errcode = %d\n", ret); return(-1); } printf("--symlink--\n"); printf("Handle: %lld\n", lld(resp_sym.ref.handle)); ret = PVFS_sys_finalize(); if (ret < 0) { printf("finalizing sysint failed with errcode = %d\n", ret); return (-1); } return(0); }