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: 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; }
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_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 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; }
void ADIOI_PVFS2_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) { int ret; ADIOI_PVFS2_fs *pvfs_fs; PVFS_sysresp_getattr resp_getattr; static char myname[] = "ADIOI_PVFS2_FCNTL"; pvfs_fs = (ADIOI_PVFS2_fs*)fd->fs_ptr; switch(flag) { case ADIO_FCNTL_GET_FSIZE: ret = PVFS_sys_getattr(pvfs_fs->object_ref, PVFS_ATTR_SYS_SIZE, &(pvfs_fs->credentials), &resp_getattr); if (ret != 0 ) { /* --BEGIN ERROR HANDLING-- */ *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, ADIOI_PVFS2_error_convert(ret), "Error in PVFS_sys_getattr", 0); /* --END ERROR HANDLING-- */ } else { *error_code = MPI_SUCCESS; } fcntl_struct->fsize = resp_getattr.attr.size; return; case ADIO_FCNTL_SET_DISKSPACE: ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); break; /* --BEGIN ERROR HANDLING-- */ case ADIO_FCNTL_SET_ATOMICITY: default: *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ARG, "**flag", "**flag %d", flag); /* --END ERROR HANDLING-- */ } }
/** * PVFSIOStore::Readlink: read symbolic link * * @param link the link to read * @param buf the place the write the result * @param the size of the result buffer * @param readlen return size * @return PLFS_SUCCESS or PLFS_E* on error */ plfs_error_t PVFSIOStore::Readlink(const char *link, char *buf, size_t bufsize, ssize_t *readlen) { char *cpath; PVFS_object_ref ref; PVFS_credentials creds; size_t l; int nev, pev, cpy; PVFS_sysresp_getattr resp; cpath = pvfsios_dedup_slash(link); if (cpath) { nev = pvfsios_get_object(this->fsid, cpath, &ref, &creds, PVFS2_LOOKUP_LINK_NO_FOLLOW); free(cpath); } else { nev = -ENOMEM; } *readlen = -1; if (nev < 0) { return errno_to_plfs_error(-nev); } pev = PVFS_sys_getattr(ref, PVFS_ATTR_SYS_ALL_NOHINT, &creds, &resp); if (pev < 0) { return errno_to_plfs_error(-get_err(pev)); } if (resp.attr.objtype != PVFS_TYPE_SYMLINK) { nev = -EINVAL; } else { l = strlen(resp.attr.link_target); cpy = (l < bufsize - 1) ? l : bufsize; memcpy(buf, resp.attr.link_target, cpy); buf[cpy] = 0; *readlen = l; /* need to return length */ /* nev still zero from get_obj call, no need to reset */ } /* XXX: pvfs2fuse didn't release, memory leak? */ PVFS_util_release_sys_attr(&resp.attr); /* frees memory chained off ats */ return errno_to_plfs_error(-nev); }
void cull_leftovers(PVFS_fs_id cur_fs, struct handlelist *hl_all, PVFS_BMI_addr_t *addr_array, PVFS_credentials *creds) { int ret; int server_idx; PVFS_handle handle; /* recall that return_handle removes from list */ while (handlelist_return_handle(hl_all, &handle, &server_idx) == 0) { PVFS_object_ref handle_ref; PVFS_sysresp_getattr getattr_resp; handle_ref.handle = handle; handle_ref.fs_id = cur_fs; ret = PVFS_sys_getattr(handle_ref, PVFS_ATTR_SYS_ALL_NOHINT, creds, &getattr_resp, NULL); if (ret) { printf("warning: problem calling getattr on %llu\n", llu(handle)); getattr_resp.attr.objtype = 0; } /* metafile and directory handles should have been removed * in the previous pass. */ assert(getattr_resp.attr.objtype != PVFS_TYPE_METAFILE); assert(getattr_resp.attr.objtype != PVFS_TYPE_DIRECTORY); ret = remove_object(handle_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); } }
int descend(PVFS_fs_id cur_fs, struct handlelist *hl, struct handlelist *alt_hl, PVFS_object_ref dir_ref, PVFS_credentials *creds) { int i, count; PVFS_ds_position token; PVFS_sysresp_readdir readdir_resp; PVFS_sysresp_getattr getattr_resp; PVFS_object_ref entry_ref = {0, 0}; count = 64; token = 0; do { memset(&readdir_resp, 0, sizeof(PVFS_sysresp_readdir)); PVFS_sys_readdir(dir_ref, (!token ? PVFS_READDIR_START : token), count, creds, &readdir_resp, NULL); for (i = 0; i < readdir_resp.pvfs_dirent_outcount; i++) { int server_idx = 0, ret, in_main_list = 0, in_alt_list = 0; char *cur_file; PVFS_handle cur_handle; cur_handle = readdir_resp.dirent_array[i].handle; cur_file = readdir_resp.dirent_array[i].d_name; entry_ref.handle = cur_handle; entry_ref.fs_id = cur_fs; if (handlelist_find_handle(hl, cur_handle, &server_idx) == 0) { in_main_list = 1; } if (!in_main_list && alt_hl && handlelist_find_handle(alt_hl, cur_handle, &server_idx) == 0) { in_alt_list = 1; } if (!in_main_list && !in_alt_list) { ret = remove_directory_entry(dir_ref, entry_ref, cur_file, creds); assert(ret == 0); continue; } ret = PVFS_sys_getattr(entry_ref, PVFS_ATTR_SYS_ALL_NOHINT, creds, &getattr_resp, NULL); if (ret != 0) { ret = remove_directory_entry(dir_ref, entry_ref, cur_file, creds); assert(ret == 0); /* handle removed from list below */ } else { switch (getattr_resp.attr.objtype) { case PVFS_TYPE_METAFILE: if (verify_datafiles(cur_fs, hl, alt_hl, entry_ref, getattr_resp.attr.dfile_count, creds) < 0) { /* not recoverable; remove */ printf("* File %s (%llu) is not recoverable.\n", cur_file, llu(cur_handle)); /* verify_datafiles() removed the datafiles */ ret = remove_object(entry_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); ret = remove_directory_entry(dir_ref, entry_ref, cur_file, creds); assert(ret == 0); } break; case PVFS_TYPE_DIRECTORY: ret = match_dirdata(hl, alt_hl, entry_ref, creds); if (ret != 0) { printf("* Directory %s (%llu) is missing DirData.\n", cur_file, llu(cur_handle)); ret = remove_object(entry_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); ret = remove_directory_entry(dir_ref, entry_ref, cur_file, creds); break; } if (in_main_list) { ret = descend(cur_fs, hl, alt_hl, entry_ref, creds); assert(ret == 0); } break; case PVFS_TYPE_SYMLINK: /* nothing to do */ break; default: /* whatever this is, blow it away now. */ ret = remove_object(entry_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); ret = remove_directory_entry(dir_ref, entry_ref, cur_file, creds); assert(ret == 0); break; } } /* remove from appropriate handle list */ if (in_alt_list) { handlelist_remove_handle(alt_hl, cur_handle, server_idx); } else if (in_main_list) { handlelist_remove_handle(hl, cur_handle, server_idx); } } token = readdir_resp.token; if (readdir_resp.pvfs_dirent_outcount) { free(readdir_resp.dirent_array); readdir_resp.dirent_array = NULL; } } while (readdir_resp.pvfs_dirent_outcount == count); if (readdir_resp.pvfs_dirent_outcount) { free(readdir_resp.dirent_array); readdir_resp.dirent_array = NULL; } return 0; }
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); }
static int test_truncat(int testcase) { int ret, fs_id; PVFS_credentials credentials; PVFS_sysresp_lookup resp_look; PVFS_size size = 0, oldsize = 0; PVFS_sysresp_getattr resp; uint32_t attrmask; char *filename; attrmask = PVFS_ATTR_SYS_ALL_NOSIZE; filename = (char *) malloc(sizeof(char) * 100); filename = strcpy(filename, "altrun"); 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; /* get file */ 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); } if((ret = PVFS_sys_getattr(resp_look.ref, attrmask, &credentials, &resp)) < 0) return ret; oldsize = resp.attr.size; switch(testcase) { case 0: size = 1000000; ret = PVFS_sys_truncate(resp_look.ref, size, &credentials); break; case 1: size = 100000; ret = PVFS_sys_truncate(resp_look.ref, size, &credentials); break; case 2: size = 5; ret = PVFS_sys_truncate(resp_look.ref, size, &credentials); break; } /* get file */ 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); } if((ret = PVFS_sys_getattr(resp_look.ref, attrmask, &credentials, &resp)) < 0) return ret; if(resp.attr.size != (oldsize - size)) { return -1; } 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; }
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); }
struct handlelist *find_sub_trees(PVFS_fs_id cur_fs, struct handlelist *hl_all, PVFS_BMI_addr_t *addr_array, PVFS_credentials *creds) { int ret; int server_idx; PVFS_handle handle; struct handlelist *alt_hl; /* TODO: DON'T DIRECTLY USE THESE MEMBERS... */ alt_hl = handlelist_initialize(hl_all->size_array, hl_all->server_ct); /* make a pass working on directories first */ /* Q: do we want to try to figure out who the root of the tree * really is? that could be tricky. we could build this though. */ while (handlelist_return_handle(hl_all, &handle, &server_idx) == 0) { PVFS_object_ref handle_ref; PVFS_sysresp_getattr getattr_resp; handle_ref.handle = handle; handle_ref.fs_id = cur_fs; ret = PVFS_sys_getattr(handle_ref, PVFS_ATTR_SYS_ALL_NOHINT, creds, &getattr_resp, NULL); if (ret) { /* remove anything we can't get attributes on */ ret = remove_object(handle_ref, 0, creds); continue; } switch (getattr_resp.attr.objtype) { case PVFS_TYPE_METAFILE: /* just hold onto this for now */ handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_DIRECTORY: /* add to directory list */ printf("# looking for dirdata match to %llu.\n", llu(handle)); descend(cur_fs, hl_all, alt_hl, handle_ref, creds); handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_DATAFILE: /* save for later */ handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_DIRDATA: handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_SYMLINK: handlelist_add_handle(alt_hl, handle, server_idx); break; default: ret = remove_object(handle_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); break; } } return alt_hl; }
/** * pvfsios_object_stat: stat a pvfs object * * @param rp the object to state * @param cp the creds used to do the stat * @param stb the stat buffer to fill out * @return 0 or -err */ static int pvfsios_object_stat(PVFS_object_ref *rp, PVFS_credentials *cp, struct stat *stb) { PVFS_sysresp_getattr reply; PVFS_sys_attr *ats; int pev, m; memset(stb, 0, sizeof(*stb)); memset(&reply, 0, sizeof(reply)); /* do the RPC */ pev = PVFS_sys_getattr(*rp, PVFS_ATTR_SYS_ALL_NOHINT, cp, &reply); if (pev != 0) { return(get_err(pev)); } ats = &reply.attr; /* set st_blocks, st_size and type bits of st_mode */ switch (ats->objtype) { case PVFS_TYPE_METAFILE: /* a file */ stb->st_mode |= S_IFREG; if (ats->mask & PVFS_ATTR_SYS_SIZE) { stb->st_size = ats->size; stb->st_blocks = (((ats->size + 4095)/4096)*4096)/512; } break; case PVFS_TYPE_SYMLINK: stb->st_mode |= S_IFLNK; if (ats->link_target) stb->st_size = strlen(ats->link_target); break; case PVFS_TYPE_DIRECTORY: stb->st_mode |= S_IFDIR; break; default: /* just leave the values at zero */ break; } stb->st_nlink = 1; stb->st_uid = ats->owner; stb->st_gid = ats->group; stb->st_atime = ats->atime; stb->st_mtime = ats->mtime; stb->st_ctime = ats->ctime; m = 0; /* yuck */ if (ats->perms & PVFS_O_EXECUTE) m |= S_IXOTH; if (ats->perms & PVFS_O_WRITE) m |= S_IWOTH; if (ats->perms & PVFS_O_READ) m |= S_IROTH; if (ats->perms & PVFS_G_EXECUTE) m |= S_IXGRP; if (ats->perms & PVFS_G_WRITE) m |= S_IWGRP; if (ats->perms & PVFS_G_READ) m |= S_IRGRP; if (ats->perms & PVFS_U_EXECUTE) m |= S_IXUSR; if (ats->perms & PVFS_U_WRITE) m |= S_IWUSR; if (ats->perms & PVFS_U_READ) m |= S_IRUSR; if (ats->perms & PVFS_G_SGID) m |= S_ISGID; if (ats->perms & PVFS_U_SUID) m |= S_ISUID; stb->st_mode |= m; stb->st_dev = rp->fs_id; stb->st_ino = rp->handle; stb->st_rdev = 0; stb->st_blksize = 4096; PVFS_util_release_sys_attr(ats); /* frees memory chained off ats */ return(0); }
struct handlelist *fill_lost_and_found(PVFS_fs_id cur_fs, struct handlelist *hl_all, PVFS_BMI_addr_t *addr_array, PVFS_credentials *creds) { int ret; int server_idx; PVFS_handle handle; struct handlelist *alt_hl; static char filename[64] = "lostfile."; static char dirname[64] = "lostdir."; /* TODO: DON'T DIRECTLY USE THESE MEMBERS... */ alt_hl = handlelist_initialize(hl_all->size_array, hl_all->server_ct); /* recall that return_handle removes from list */ while (handlelist_return_handle(hl_all, &handle, &server_idx) == 0) { PVFS_object_ref handle_ref; PVFS_sysresp_getattr getattr_resp; handle_ref.handle = handle; handle_ref.fs_id = cur_fs; ret = PVFS_sys_getattr(handle_ref, PVFS_ATTR_SYS_ALL_NOHINT, creds, &getattr_resp, NULL); if (ret) { printf("warning: problem calling getattr on %llu; assuming datafile for now.\n", llu(handle)); getattr_resp.attr.objtype = PVFS_TYPE_DATAFILE; } switch (getattr_resp.attr.objtype) { case PVFS_TYPE_METAFILE: printf("# trying to salvage %s %lld.\n", get_type_str(getattr_resp.attr.objtype), llu(handle)); if (verify_datafiles(cur_fs, hl_all, alt_hl, handle_ref, getattr_resp.attr.dfile_count, creds) != 0) { ret = remove_object(handle_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); } else { sprintf(filename + 9, "%llu", llu(handle)); ret = create_dirent(laf_ref, filename, handle, creds); assert(ret == 0); } break; case PVFS_TYPE_DIRECTORY: /* assumption: we will often suceed in creating a new entry, * but if the file system is messed up we may not be able to * find dirdata, so match_dirdata before create_dirent */ if (match_dirdata(hl_all, alt_hl, handle_ref, creds) != 0) { ret = remove_object(handle_ref, getattr_resp.attr.objtype, creds); assert(ret == 0); } sprintf(dirname + 8, "%llu", llu(handle)); ret = create_dirent(laf_ref, dirname, handle, creds); if (ret != 0) { ret = remove_object(handle_ref, getattr_resp.attr.objtype, creds); } break; case PVFS_TYPE_DATAFILE: #if 0 printf("# saving %llu (datafile) for later.\n", llu(handle)); #endif handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_DIRDATA: #if 0 printf("# saving %llu (dirdata) for later.\n", llu(handle)); #endif handlelist_add_handle(alt_hl, handle, server_idx); break; case PVFS_TYPE_SYMLINK: default: /* delete on handle -- unknown type */ printf("* delete handle %llu (unknown type).\n", llu(handle)); break; } } return alt_hl; }
/** * PVFSIOStore::Access: permission check * * @param path the path we are checking * @param mode the mode to check * @return PLFS_SUCCESS or PLFS_E* on error */ plfs_error_t PVFSIOStore::Access(const char* path, int mode) { char *cpath; PVFS_object_ref ref; PVFS_credentials creds; int nev, pev; PVFS_sysresp_getattr rep; PVFS_uid auid; PVFS_gid agid; PVFS_permissions aperms; cpath = pvfsios_dedup_slash(path); if (cpath) { nev = pvfsios_get_object(this->fsid, cpath, &ref, &creds, PVFS2_LOOKUP_LINK_FOLLOW); free(cpath); } else { nev = -ENOMEM; } if (nev < 0) { return errno_to_plfs_error(-nev); } /* root or exist check */ if (creds.uid == 0 || mode == F_OK) { return PLFS_SUCCESS; } pev = PVFS_sys_getattr(ref, PVFS_ATTR_SYS_ALL_NOHINT, &creds, &rep); if (pev < 0) { return errno_to_plfs_error(get_err(pev)); } #if 0 /* * XXXCDC: we'd really like to call PINT_check_mode, but libpvfs2 * includes don't provide a prototype for it even though it is * present in the lib. does that mean it is a private interface? */ pev = PINT_check_mode(&rep.attr, creds.uid, credis.gid, 0); PVFS_util_release_sys_attr(&rep.attr); /* frees memory chained off ats */ return(get_err(pev)); #endif /* * XXX: pvfs2fuse doesn't call PVFS_util_release_sys_attr on * repl.attr for access. this seems like a memory leak mistake to * me. */ auid = rep.attr.owner; agid = rep.attr.group; aperms = rep.attr.perms; PVFS_util_release_sys_attr(&rep.attr); /* frees memory chained off ats */ if (auid == creds.uid) { if ((mode & R_OK) && (aperms & PVFS_U_READ)) return PLFS_SUCCESS; if ((mode & W_OK) && (aperms & PVFS_U_WRITE)) return PLFS_SUCCESS; if ((mode & X_OK) && (aperms & PVFS_U_EXECUTE)) return PLFS_SUCCESS; } /* XXXCDC: doesn't check group list, e.g. getgroups() */ if (agid == creds.gid) { if ((mode & R_OK) && (aperms & PVFS_G_READ)) return PLFS_SUCCESS; if ((mode & W_OK) && (aperms & PVFS_G_WRITE)) return PLFS_SUCCESS; if ((mode & X_OK) && (aperms & PVFS_G_EXECUTE)) return PLFS_SUCCESS; } if ((mode & R_OK) && (aperms & PVFS_O_READ)) return PLFS_SUCCESS; if ((mode & W_OK) && (aperms & PVFS_O_WRITE)) return PLFS_SUCCESS; if ((mode & X_OK) && (aperms & PVFS_O_EXECUTE)) return PLFS_SUCCESS; return PLFS_EACCES; }
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; }
static int test_read_sparse_files(void){ PVFS_credentials credentials; PVFS_sysresp_lookup resp_lk; PVFS_Request req_io; PVFS_Request req_mem; PVFS_sysresp_io resp_io; PVFS_sysresp_getattr resp; PVFS_offset file_req_offset = 0; uint32_t attrmask; char *filename; char io_buffer[100]; int fs_id, ret, i; attrmask = PVFS_ATTR_SYS_ALL_NOSIZE; filename = (char *) malloc(sizeof(char) * 100); filename = strcpy(filename, "sparse2"); 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); } if((ret = PVFS_sys_getattr(resp_lk.ref, attrmask, &credentials, &resp)) < 0) return ret; assert(0); /* TODO: what's this? we shouldn't edit these fields directly -Phil */ #if 0 switch(testcase) { case 0: req_io->offset = 78000; break; case 1: req_io->offset = 150000; break; case 2: req_io->offset = 330000; break; } #endif for(i = 0; i < 100; 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); } ret = PVFS_sys_read(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(); */ for(i = 0; i < 100; i++) { if(io_buffer[i] != 0){ return -1; } } /* check for whats in the buffer */ return 0; }