int main(int argc, char **argv) { int ret = -1; struct options* user_opts = NULL; struct PVFS_sys_mntent* tmp_ent = NULL; char config_server[256]; /* 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); } sprintf(config_server, "%.50s://%.150s:%d", user_opts->network_proto, user_opts->hostname, user_opts->port); /* build mnt entry */ tmp_ent = PVFS_util_gen_mntent(config_server, user_opts->fsname); if(!tmp_ent) { fprintf(stderr, "Error: failed to build mnt entry.\n"); return(-1); } ret = PVFS_sys_initialize(GOSSIP_NO_DEBUG); if(ret < 0) { fprintf(stderr, "Error: failed to initialize PVFS2 library.\n"); return(-1); } ret = PVFS_sys_fs_add(tmp_ent); if(ret < 0) { PVFS_perror("Error: could not retrieve configuration from server", ret); return(-1); } PVFS_sys_finalize(); PVFS_util_gen_mntent_release(tmp_ent); return(ret); }
int pvfs_connect(char *fs_spec) { int ret = 0; struct PVFS_sys_mntent *me = &pvfs_mntent; char *cp; int cur_server; /* the following is copied from PVFS_util_init_defaults() in fuse/lib/pvfs2-util.c */ /* initialize pvfs system interface */ ret = PVFS_sys_initialize(GOSSIP_NO_DEBUG); if (ret < 0) { return(ret); } /* the following is copied from PVFS_util_parse_pvfstab() in fuse/lib/pvfs2-util.c */ memset( me, 0, sizeof(pvfs_mntent) ); /* Enable integrity checks by default */ me->integrity_check = 1; /* comma-separated list of ways to contact a config server */ me->num_pvfs_config_servers = 1; for (cp=fs_spec; *cp; cp++) if (*cp == ',') ++me->num_pvfs_config_servers; /* allocate room for our copies of the strings */ me->pvfs_config_servers = malloc(me->num_pvfs_config_servers * sizeof(*me->pvfs_config_servers)); if (!me->pvfs_config_servers) exit(-1); memset(me->pvfs_config_servers, 0, me->num_pvfs_config_servers * sizeof(*me->pvfs_config_servers)); me->mnt_dir = NULL; me->mnt_opts = NULL; cp = fs_spec; cur_server = 0; for (;;) { char *tok; int slashcount; char *slash; char *last_slash; tok = strsep(&cp, ","); if (!tok) break; slash = tok; slashcount = 0; while ((slash = index(slash, '/'))) { slash++; slashcount++; } if (slashcount != 3) { fprintf(stderr,"Error: invalid FS spec: %s\n", fs_spec); exit(-1); } /* find a reference point in the string */ last_slash = rindex(tok, '/'); *last_slash = '\0'; /* config server and fs name are a special case, take one * string and split it in half on "/" delimiter */ me->pvfs_config_servers[cur_server] = strdup(tok); if (!me->pvfs_config_servers[cur_server]) exit(-1); ++last_slash; if (cur_server == 0) { me->pvfs_fs_name = strdup(last_slash); if (!me->pvfs_fs_name) exit(-1); } else { if (strcmp(last_slash, me->pvfs_fs_name) != 0) { fprintf(stderr, "Error: different fs names in server addresses: %s\n", fs_spec); exit(-1); } } ++cur_server; } /* FIXME flowproto should be an option */ me->flowproto = FLOWPROTO_DEFAULT; /* FIXME encoding should be an option */ me->encoding = PVFS2_ENCODING_DEFAULT; /* FIXME default_num_dfiles should be an option */ ret = PVFS_sys_fs_add(me); if( ret < 0 ) { PVFS_perror("Could not add mnt entry", ret); return(-1); } pvfs_fsid = me->fs_id; ret = pvfs_generate_serverlist(); /* XXX: Turn off attribute caches, they screw with us. In the future, we * might want to investigate invalidating them only when needed. */ PVFS_sys_set_info(PVFS_SYS_NCACHE_TIMEOUT_MSECS, 0); PVFS_sys_set_info(PVFS_SYS_ACACHE_TIMEOUT_MSECS, 0); return ret; }
int main(int argc, char *argv[]) { int ret; if (argc != 4){ usage(argv[0]); exit(1); } pvfs2fuse.fs_spec = argv[1]; pvfs2fuse.scratch_dir = argv[2]; struct PVFS_sys_mntent *me = &pvfs2fuse.mntent; char *cp; int cur_server; /* the following is copied from PVFS_util_init_defaults() in fuse/lib/pvfs2-util.c */ /* initialize pvfs system interface */ ret = PVFS_sys_initialize(GOSSIP_NO_DEBUG); if (ret < 0) { return(ret); } /* the following is copied from PVFS_util_parse_pvfstab() in fuse/lib/pvfs2-util.c */ memset( me, 0, sizeof(pvfs2fuse.mntent) ); /* Enable integrity checks by default */ me->integrity_check = 1; /* comma-separated list of ways to contact a config server */ me->num_pvfs_config_servers = 1; for (cp=pvfs2fuse.fs_spec; *cp; cp++) if (*cp == ',') ++me->num_pvfs_config_servers; /* allocate room for our copies of the strings */ me->pvfs_config_servers = malloc(me->num_pvfs_config_servers * sizeof(*me->pvfs_config_servers)); if (!me->pvfs_config_servers) exit(-1); memset(me->pvfs_config_servers, 0, me->num_pvfs_config_servers * sizeof(*me->pvfs_config_servers)); me->mnt_dir = NULL; me->mnt_opts = NULL; me->encoding = PVFS2_ENCODING_DEFAULT; cp = pvfs2fuse.fs_spec; cur_server = 0; for (;;) { char *tok; int slashcount; char *slash; char *last_slash; tok = strsep(&cp, ","); if (!tok) break; slash = tok; slashcount = 0; while ((slash = index(slash, '/'))) { slash++; slashcount++; } if (slashcount != 3) { fprintf(stderr,"Error: invalid FS spec: %s\n", pvfs2fuse.fs_spec); exit(-1); } /* find a reference point in the string */ last_slash = rindex(tok, '/'); *last_slash = '\0'; /* config server and fs name are a special case, take one * string and split it in half on "/" delimiter */ me->pvfs_config_servers[cur_server] = strdup(tok); if (!me->pvfs_config_servers[cur_server]) exit(-1); ++last_slash; if (cur_server == 0) { me->pvfs_fs_name = strdup(last_slash); if (!me->pvfs_fs_name) exit(-1); } else { if (strcmp(last_slash, me->pvfs_fs_name) != 0) { fprintf(stderr, "Error: different fs names in server addresses: %s\n", pvfs2fuse.fs_spec); exit(-1); } } ++cur_server; } me->flowproto = FLOWPROTO_DEFAULT; ret = PVFS_sys_fs_add(me); if( ret < 0 ) { PVFS_perror("Could not add mnt entry", ret); return(-1); } pvfs2fuse.fs_id = me->fs_id; signal(SIGALRM, alarmhandler); do_test(atol(argv[3])); return 0; }
/** * PVFSIOStore::PVFSIOStore_xnew: make a new PVFSIOStore * * @param phys_path the physical path of the backing store * @param prelenp return the length of the prefix here * @param bmpointp return the bmpoint string here * @param res_store return the newly allocated class or NULL on error * @return PLFS_SUCCESS or PLFS_E* on error */ plfs_error_t PVFSIOStore::PVFSIOStore_xnew(char *phys_path, int *prelenp, char **bmpointp, class PVFSIOStore **res_store) { char *p, *sl, *cp; int plen, rv, pev; class PVFSIOStore *pio; *res_store = NULL; if (strncmp(phys_path, "pvfs://", sizeof("pvfs://")-1) != 0) { return PLFS_TBD; /* should never happen, but play it safe */ } p = phys_path + sizeof("pvfs://") - 1; sl = strchr(p, '/'); /* find start of bmpoint */ if (sl == NULL) { return PLFS_TBD; } plen = sl - phys_path; /* start initing and allocating stuff */ pio = NULL; /* make a writable copy of the spec so we can parse it */ cp = (char *) malloc(sl - p + 1); if (cp == NULL) { goto error; } strncpy(cp, p, sl - p); pio = new PVFSIOStore; if (pio == NULL) { goto error; } rv = pvfsios_load_mnt(cp, &pio->pvmnt); if (rv < 0) { goto error; } pio->pvmnt.integrity_check = 1; /* XXX: mnt_dir (logical mount point): why does it need this? */ pio->pvmnt.mnt_dir = NULL; pio->pvmnt.mnt_opts = NULL; pev = PVFS_sys_initialize(GOSSIP_NO_DEBUG); if (pev < 0) { goto error; } pio->pvmnt.flowproto = FLOWPROTO_DEFAULT; pio->pvmnt.encoding = PVFS2_ENCODING_DEFAULT; pev = PVFS_sys_fs_add(&pio->pvmnt); if (pev < 0) { goto error; } pio->fsid = pio->pvmnt.fs_id; *prelenp = plen; *bmpointp = sl; *res_store = pio; return PLFS_SUCCESS; error: if (cp != NULL) { free(cp); } if (pio != NULL) { pvfsios_free_mnt(&pio->pvmnt); delete pio; } return PLFS_TBD; }
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); }