int initialize_sysint(void) { int ret = -1; memset(&pvfs_helper,0,sizeof(pvfs_helper)); ret = PVFS_util_init_defaults(); if(ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return(ret); } ret = PVFS_util_get_default_fsid(&pvfs_helper.fs_id); if(ret < 0) { PVFS_perror("PVFS_util_get_default_fsid", ret); return(ret); } pvfs_helper.initialized = 1; pvfs_helper.num_test_files = NUM_TEST_FILES; gossip_debug(GOSSIP_CLIENT_DEBUG,"sysint intialized\n"); return 0; }
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); }
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); }
int main(int argc, char **argv) { int ret = 0; struct options* user_opts = NULL; int i, k; /* look at command line arguments */ user_opts = parse_args(argc, argv); if(!user_opts) { fprintf(stderr, "Error: failed to parse " "command line arguments.\n"); return(-1); } ret = PVFS_util_init_defaults(); if(ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return(-1); } /* * for each file the user specified * for each file the user specified */ for (i = 0; i < user_opts->target_count; i++) { ret = pvfs2_geteattr(user_opts->nkey, user_opts->key, user_opts->val, user_opts->destfiles[i]); if (ret != 0) { printf("geteattr returned error code - exiting\n"); break; } for (k = 0; k < user_opts->nkey; k++) { printf("key[%d]:%s Value:\n%s\n",k, (char *)user_opts->key[k].buffer, (char *)user_opts->val[k].buffer); } /* TODO: need to free the request descriptions */ } PVFS_sys_finalize(); 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; }
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); }
/* * 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[]) { 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); }
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); }
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) { 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; }
int main(int argc, char **argv) { int ret = -1; options_t *user_opts = NULL; PVFS_object_ref ref; PVFS_credentials credentials; user_opts = parse_args(argc, argv); if (!user_opts) { usage(argc, argv); return ret; } ref.fs_id = user_opts->fs_id; if (user_opts->remove_object_only) { ref.handle = user_opts->object_handle; if ((ref.handle == PVFS_HANDLE_NULL) || (ref.fs_id == PVFS_FS_ID_NULL)) { fprintf(stderr, "Invalid object reference specified: " "%llu,%d\n", llu(ref.handle), ref.fs_id); return ret; } } else { ref.handle = user_opts->parent_handle; if ((ref.handle == PVFS_HANDLE_NULL) || (ref.fs_id == PVFS_FS_ID_NULL)) { fprintf(stderr, "Invalid parent reference specified: " "%llu,%d\n", llu(ref.handle), ref.fs_id); return ret; } if (!user_opts->dirent_name) { fprintf(stderr, "No dirent name specified under parent " "%llu,%d\n", llu(ref.handle), ref.fs_id); return ret; } } ret = PVFS_util_init_defaults(); if (ret < 0) { PVFS_perror("PVFS_util_init_defaults", ret); return -1; } PVFS_util_gen_credentials(&credentials); if (user_opts->remove_object_only) { fprintf(stderr,"Attempting to remove object %llu,%d\n", llu(ref.handle), ref.fs_id); ret = PVFS_mgmt_remove_object(ref, &credentials, NULL); if (ret) { PVFS_perror("PVFS_mgmt_remove_object", ret); } } else { fprintf(stderr,"Attempting to remove dirent \"%s\" under %llu,%d" "\n", user_opts->dirent_name, llu(ref.handle), ref.fs_id); ret = PVFS_mgmt_remove_dirent( ref, user_opts->dirent_name, &credentials, NULL); if (ret) { PVFS_perror("PVFS_mgmt_remove_dirent", ret); } } free(user_opts); return ret; }
int main(int argc, char **argv) { int ret = -1; char *retc = NULL; PVFS_fs_id cur_fs; struct options* user_opts = NULL; char pvfs_path[PVFS_NAME_MAX] = {0}; int i; PVFS_credentials creds; int io_server_count; int64_t **perf_matrix; uint64_t* end_time_ms_array; uint32_t* next_id_array; PVFS_BMI_addr_t *addr_array, server_addr; char *cmd_buffer = (char *)malloc(CMD_BUF_SIZE); int max_keys, key_count; /* 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); } PVFS_util_gen_credentials(&creds); if (user_opts->server_addr_set) { if (PVFS_util_get_default_fsid(&cur_fs) < 0) { /* Can't find a file system */ fprintf(stderr, "Error: failed to find a file system.\n"); usage(argc, argv); return(-1); } if (user_opts->server_addr && (BMI_addr_lookup (&server_addr, user_opts->server_addr) == 0)) { /* set up single server */ addr_array = (PVFS_BMI_addr_t *)malloc(sizeof(PVFS_BMI_addr_t)); addr_array[0] = server_addr; io_server_count = 1; } else { /* bad argument - address not found */ fprintf(stderr, "Error: failed to parse server address.\n"); usage(argc, argv); return(-1); } } else { /* will sample all servers */ /* 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) { PVFS_perror("PVFS_util_resolve", ret); return(-1); } /* count how many I/O servers we have */ ret = PVFS_mgmt_count_servers(cur_fs, &creds, PVFS_MGMT_IO_SERVER, &io_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(io_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, addr_array, &io_server_count); if (ret < 0) { PVFS_perror("PVFS_mgmt_get_server_array", ret); return -1; } } /* count keys */ for (max_keys = 0; key_table[max_keys].key_number >= 0; max_keys++); /* allocate a 2 dimensional array for statistics */ perf_matrix = (int64_t **)malloc(io_server_count * sizeof(int64_t *)); if (!perf_matrix) { perror("malloc"); return(-1); } for(i=0; i<io_server_count; i++) { perf_matrix[i] = (int64_t *)malloc(HISTORY * (max_keys + 2) * sizeof(int64_t)); if (perf_matrix[i] == NULL) { perror("malloc"); return -1; } } /* allocate an array to keep up with what iteration of statistics * we need from each server */ next_id_array = (uint32_t *) malloc(io_server_count * sizeof(uint32_t)); if (next_id_array == NULL) { perror("malloc"); return -1; } memset(next_id_array, 0, io_server_count*sizeof(uint32_t)); /* allocate an array to keep up with end times from each server */ end_time_ms_array = (uint64_t *)malloc(io_server_count * sizeof(uint64_t)); if (end_time_ms_array == NULL) { perror("malloc"); return -1; } /* loop for ever, grabbing stats when requested */ while (1) { int srv = 0; time_t snaptime = 0; const char *returnType = NULL; int64_t returnValue = 0; /* wait for a request from SNMP driver */ retc = fgets(cmd_buffer, CMD_BUF_SIZE, stdin); if (!retc) { /* error on read */ return -1; } /* if PING output PONG */ if (!strncasecmp(cmd_buffer, "PING", 4)) { fprintf(stdout,"PONG\n"); fflush(stdout); continue; } /* try to parse GET command */ if (!strncasecmp(cmd_buffer, "GET", 3)) { char *c; /* found GET read OID */ retc = fgets(cmd_buffer, CMD_BUF_SIZE, stdin); if (!retc) { /* error on read */ return -1; } /* replace newlines with null char */ for(c = cmd_buffer; *c != '\0'; c++) if (*c == '\n') *c = '\0'; } else { /* bad command */ fprintf(stdout, "NONE\n"); fflush(stdout); continue; } /* good command - read counters */ if (time(NULL) - snaptime > 60) { snaptime = time(NULL); key_count = max_keys; ret = PVFS_mgmt_perf_mon_list(cur_fs, &creds, perf_matrix, end_time_ms_array, addr_array, next_id_array, io_server_count, &key_count, HISTORY, NULL, NULL); if (ret < 0) { PVFS_perror("PVFS_mgmt_perf_mon_list", ret); return -1; } } /* format requested OID */ if (perf_matrix[srv][key_count] != 0) { int k; /* this is a valid measurement */ for(k = 0; k < max_keys && strcmp(cmd_buffer, key_table[k].key_oid); k++); /* out of for loop k equals selected key */ if (k < max_keys) { returnType = key_table[k].key_type; returnValue = perf_matrix[srv][key_table[k].key_number]; } else { /* invalid command */ fprintf(stdout,"NONE\n"); fflush(stdout); continue; } } else { /* invalid measurement */ fprintf(stdout,"NONE\n"); fflush(stdout); continue; } fprintf(stdout, "%s\n%llu\n", returnType, llu(returnValue)); fflush(stdout); /* return to top for next command */ } PVFS_sys_finalize(); return(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); }