void ADIOI_PVFS2_Delete(const char *filename, int *error_code)
{
PVFS_credentials credentials;
PVFS_sysresp_getparent resp_getparent;
int ret;
PVFS_fs_id cur_fs;
static char myname[] = "ADIOI_PVFS2_DELETE";
char pvfs_path[PVFS_NAME_MAX] = {0};
ADIOI_PVFS2_Init(error_code);
/* --BEGIN ERROR HANDLING-- */
if (*error_code != MPI_SUCCESS)
{
/* ADIOI_PVFS2_INIT handles creating error codes itself */
return;
}
/* --END ERROR HANDLING-- */
/* in most cases we'll store the credentials in the fs struct, but we don't
* have one of those in Delete */
ADIOI_PVFS2_makecredentials(&credentials);
/* given the filename, figure out which pvfs filesystem it is on */
ret = PVFS_util_resolve(filename, &cur_fs, pvfs_path, PVFS_NAME_MAX);
/* --BEGIN ERROR HANDLING-- */
if (ret != 0) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
ADIOI_PVFS2_error_convert(ret),
"Error in PVFS_util_resolve", 0);
return;
}
/* --END ERROR HANDLING-- */
ret = PVFS_sys_getparent(cur_fs, pvfs_path, &credentials, &resp_getparent);
ret = PVFS_sys_remove(resp_getparent.basename,
resp_getparent.parent_ref, &credentials);
/* --BEGIN ERROR HANDLING-- */
if (ret != 0) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
ADIOI_PVFS2_error_convert(ret),
"Error in PVFS_sys_remove", 0);
return;
}
/* --END ERROR HANDLING-- */
*error_code = MPI_SUCCESS;
return;
}
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);
}
/* resolve_filename:
* given 'filename', find the PVFS2 fs_id and relative pvfs_path. In case of
* error, assume 'filename' is a unix file.
*/
int resolve_filename(file_object *obj, char *filename)
{
int ret;
ret = PVFS_util_resolve(filename, &(obj->u.pvfs2.fs_id),
obj->u.pvfs2.pvfs2_path, PVFS_NAME_MAX);
if (ret < 0)
{
obj->fs_type = UNIX_FILE;
strncpy(obj->u.ufs.path, filename, NAME_MAX);
} else {
obj->fs_type = PVFS2_FILE;
strncpy(obj->u.pvfs2.user_path, filename, PVFS_NAME_MAX);
}
return 0;
}
/*
* 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;
}
/*
* 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, 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,
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, i = 0;
char pvfs_path[MAX_NUM_PATHS][PVFS_NAME_MAX];
PVFS_fs_id fs_id_array[MAX_NUM_PATHS] = {0};
const PVFS_util_tab* tab;
struct options* user_opts = NULL;
char current_dir[PVFS_NAME_MAX] = {0};
int found_one = 0;
process_name = argv[0];
user_opts = parse_args(argc, argv);
if (!user_opts)
{
fprintf(stderr, "Error: failed to parse command line "
"arguments.\n");
usage(argc, argv);
return(-1);
}
tab = PVFS_util_parse_pvfstab(NULL);
if (!tab)
{
fprintf(stderr, "Error: failed to parse pvfstab.\n");
return(-1);
}
for(i = 0; i < MAX_NUM_PATHS; i++)
{
memset(pvfs_path[i],0,PVFS_NAME_MAX);
}
ret = PVFS_sys_initialize(GOSSIP_NO_DEBUG);
if (ret < 0)
{
PVFS_perror("PVFS_sys_initialize", ret);
return(-1);
}
/* initialize each file system that we found in the tab file */
for(i = 0; i < tab->mntent_count; i++)
{
ret = PVFS_sys_fs_add(&tab->mntent_array[i]);
if (ret == 0)
{
found_one = 1;
}
}
if (!found_one)
{
fprintf(stderr, "Error: could not initialize any file systems "
"from %s\n", tab->tabfile_name);
PVFS_sys_finalize();
return(-1);
}
if (user_opts->num_starts == 0)
{
snprintf(current_dir,PVFS_NAME_MAX,"%s/",
tab->mntent_array[0].mnt_dir);
user_opts->start[0] = current_dir;
user_opts->num_starts = 1;
}
for(i = 0; i < user_opts->num_starts; i++)
{
ret = PVFS_util_resolve(user_opts->start[i],
&fs_id_array[i], pvfs_path[i], PVFS_NAME_MAX);
if ((ret == 0) && (pvfs_path[i][0] == '\0'))
{
strcpy(pvfs_path[i], "/");
}
if (ret < 0)
{
fprintf(stderr, "Error: could not find file system "
"for %s in pvfstab\n", user_opts->start[i]);
return(-1);
}
}
for(i = 0; i < user_opts->num_starts; i++)
{
char *substr = strstr(user_opts->start[i],pvfs_path[i]);
char *index = user_opts->start[i];
char *search = substr;
int j = 0;
/* Keep the mount path info to mimic /bin/ls output */
if( strncmp(pvfs_path[i],"/",strlen(pvfs_path[i])) )
{
/* Get last matching substring */
while (search)
{
substr = search;
search = strstr(++search,pvfs_path[i]);
}
}
else /* Root directory case has nothing to match */
{
substr = &user_opts->start[i][strlen(user_opts->start[i])-1];
}
while ((index != substr) && (substr != NULL))
{
index++;
j++;
}
user_opts->start[i][j] = '\0';
do_list(user_opts->start[i], pvfs_path[i], fs_id_array[i], user_opts);
if (user_opts->num_starts > 1)
{
printf("\n");
}
}
PVFS_sys_finalize();
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);
}
/* ADIOI_PVFS2_Open:
* one process opens (or creates) the file, then broadcasts the result to the
* remaining processors.
*
* ADIO_Open used to perform an optimization when MPI_MODE_CREATE (and before
* that, MPI_MODE_EXCL) was set. Because PVFS2 handles file lookup and
* creation more scalably than other file systems, ADIO_Open now skips any
* special handling when CREATE is set. */
void ADIOI_PVFS2_Open(ADIO_File fd, int *error_code)
{
int rank, ret;
PVFS_fs_id cur_fs;
static char myname[] = "ADIOI_PVFS2_OPEN";
char pvfs_path[PVFS_NAME_MAX] = {0};
ADIOI_PVFS2_fs *pvfs2_fs;
/* since one process is doing the open, that means one process is also
* doing the error checking. define a struct for both the object reference
* and the error code to broadcast to all the processors */
open_status o_status = {0, {0, 0}};
MPI_Datatype open_status_type;
MPI_Datatype types[2] = {MPI_INT, MPI_BYTE};
int lens[2] = {1, sizeof(PVFS_object_ref)};
MPI_Aint offsets[2];
pvfs2_fs = (ADIOI_PVFS2_fs *) ADIOI_Malloc(sizeof(ADIOI_PVFS2_fs));
/* --BEGIN ERROR HANDLING-- */
if (pvfs2_fs == NULL) {
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_UNKNOWN,
"Error allocating memory", 0);
return;
}
/* --END ERROR HANDLING-- */
MPI_Comm_rank(fd->comm, &rank);
ADIOI_PVFS2_Init(error_code);
if (*error_code != MPI_SUCCESS)
{
/* ADIOI_PVFS2_INIT handles creating error codes on its own */
return;
}
/* currently everyone gets their own credentials */
ADIOI_PVFS2_makecredentials(&(pvfs2_fs->credentials));
/* one process resolves name and will later bcast to others */
if (rank == fd->hints->ranklist[0] && fd->fs_ptr == NULL) {
/* given the filename, figure out which pvfs filesystem it is on */
ret = PVFS_util_resolve(fd->filename, &cur_fs,
pvfs_path, PVFS_NAME_MAX);
if (ret < 0 ) {
PVFS_perror("PVFS_util_resolve", ret);
/* TODO: pick a good error for this */
o_status.error = -1;
} else {
fake_an_open(cur_fs, pvfs_path,
fd->access_mode, fd->hints->striping_factor,
fd->hints->striping_unit,
pvfs2_fs, &o_status);
}
/* store credentials and object reference in fd */
pvfs2_fs->object_ref = o_status.object_ref;
fd->fs_ptr = pvfs2_fs;
}
/* broadcast status and (possibly valid) object reference */
MPI_Address(&o_status.error, &offsets[0]);
MPI_Address(&o_status.object_ref, &offsets[1]);
MPI_Type_struct(2, lens, offsets, types, &open_status_type);
MPI_Type_commit(&open_status_type);
/* Assertion: if we hit this Bcast, then all processes collectively
* called this open.
*
* That's because deferred open never happens with PVFS2.
*/
MPI_Bcast(MPI_BOTTOM, 1, open_status_type, fd->hints->ranklist[0],
fd->comm);
MPI_Type_free(&open_status_type);
/* --BEGIN ERROR HANDLING-- */
if (o_status.error != 0)
{
ADIOI_Free(pvfs2_fs);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
ADIOI_PVFS2_error_convert(o_status.error),
"Unknown error", 0);
/* TODO: FIX STRING */
return;
}
/* --END ERROR HANDLING-- */
pvfs2_fs->object_ref = o_status.object_ref;
fd->fs_ptr = pvfs2_fs;
*error_code = MPI_SUCCESS;
return;
}
/* pvfs2_geteattr()
*
* changes the mode of the given file to the given permissions
*
* returns zero on success and negative one on failure
*/
int pvfs2_geteattr(int nkey, PVFS_ds_keyval *key_p,
PVFS_ds_keyval *val_p, char *destfile) {
int ret = -1;
char str_buf[PVFS_NAME_MAX] = {0};
char pvfs_path[PVFS_NAME_MAX] = {0};
PVFS_fs_id cur_fs;
PVFS_sysresp_lookup resp_lookup;
PVFS_sysresp_geteattr resp_geteattr;
PVFS_object_ref parent_ref;
PVFS_credentials credentials;
/* translate local path into pvfs2 relative path */
ret = PVFS_util_resolve(destfile,&cur_fs, pvfs_path, PVFS_NAME_MAX);
if(ret < 0)
{
PVFS_perror("PVFS_util_resolve", ret);
return -1;
}
PVFS_util_gen_credentials(&credentials);
/* this if-else statement just pulls apart the pathname into its
* parts....I think...this should be a function somewhere
*/
if (strcmp(pvfs_path,"/") == 0)
{
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_lookup(cur_fs, pvfs_path,
&credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_lookup", ret);
return -1;
}
parent_ref.handle = resp_lookup.ref.handle;
parent_ref.fs_id = resp_lookup.ref.fs_id;
}
else
{
/* get the absolute path on the pvfs2 file system */
if (PINT_remove_base_dir(pvfs_path,str_buf,PVFS_NAME_MAX))
{
if (pvfs_path[0] != '/')
{
fprintf(stderr, "Error: poorly formatted path.\n");
}
fprintf(stderr, "Error: cannot retrieve entry name for "
"creation on %s\n",pvfs_path);
return -1;
}
ret = PINT_lookup_parent(pvfs_path, cur_fs, &credentials,
&parent_ref.handle);
if(ret < 0)
{
PVFS_perror("PINT_lookup_parent", ret);
return -1;
}
else
{
parent_ref.fs_id = cur_fs;
}
}
memset(&resp_lookup, 0, sizeof(PVFS_sysresp_lookup));
ret = PVFS_sys_ref_lookup(parent_ref.fs_id, str_buf,
parent_ref, &credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL);
if (ret != 0)
{
fprintf(stderr, "Target '%s' does not exist!\n", str_buf);
return -1;
}
/* get extended attribute */
resp_geteattr.val_array = val_p;
ret = PVFS_sys_geteattr_list(resp_lookup.ref,
&credentials, nkey, key_p, &resp_geteattr, NULL);
if (ret < 0)
{
PVFS_perror("PVFS_sys_geteattr failed with errcode", ret);
return(-1);
}
return 0;
}
