int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_fd_t *fd = NULL; int ret = 1; if (argc != 4) { fprintf (stderr, "Syntax: %s <host> <volname> <file-path> \n", argv[0]); return 1; } fs = glfs_new (argv[2]); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); if (ret != 0) { fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret); goto out; } ret = glfs_set_logging (fs, "/var/log/glusterfs/glfs-dis.log", 7); if (ret != 0) { fprintf (stderr, "glfs_set_logging: returned %d\n", ret); goto out; } ret = glfs_init (fs); if (ret != 0) { fprintf (stderr, "glfs_init: returned %d\n", ret); goto out; } fd = glfs_open (fs, argv[3], O_RDWR); if (fd == NULL) { fprintf (stderr, "glfs_open: returned NULL\n"); goto out; } /* Zero-fill "foo" with 10MB of data */ ret = glfs_zerofill (fd, 0, 10485760); if (ret <= 0) { fprintf (stderr, "glfs_zerofill: returned %d\n", ret); goto out; } glfs_close(fd); ret = 0; out: glfs_fini (fs); return ret; }
static struct glfs *qemu_gluster_init(GlusterConf *gconf, const char *filename, Error **errp) { struct glfs *glfs = NULL; int ret; int old_errno; ret = qemu_gluster_parseuri(gconf, filename); if (ret < 0) { error_setg(errp, "Usage: file=gluster[+transport]://[server[:port]]/" "volname/image[?socket=...]"); errno = -ret; goto out; } glfs = glfs_new(gconf->volname); if (!glfs) { goto out; } ret = glfs_set_volfile_server(glfs, gconf->transport, gconf->server, gconf->port); if (ret < 0) { goto out; } /* * TODO: Use GF_LOG_ERROR instead of hard code value of 4 here when * GlusterFS makes GF_LOG_* macros available to libgfapi users. */ ret = glfs_set_logging(glfs, "-", 4); if (ret < 0) { goto out; } ret = glfs_init(glfs); if (ret) { error_setg_errno(errp, errno, "Gluster connection failed for server=%s port=%d " "volume=%s image=%s transport=%s", gconf->server, gconf->port, gconf->volname, gconf->image, gconf->transport); goto out; } return glfs; out: if (glfs) { old_errno = errno; glfs_fini(glfs); errno = old_errno; } return NULL; }
static void uwsgi_glusterfs_add_mountpoint(char *arg, size_t arg_len) { char *ugfs_mountpoint = NULL; char *ugfs_server = NULL; char *ugfs_volfile = NULL; char *ugfs_volume = NULL; if (uwsgi_kvlist_parse(arg, arg_len, ',', '=', "mountpoint", &ugfs_mountpoint, "server", &ugfs_server, "servers", &ugfs_server, "volfile", &ugfs_volfile, "volume", &ugfs_volume, NULL)) { uwsgi_log("unable to parse glusterfs mountpoint definition\n"); exit(1); } if (!ugfs_mountpoint || (!ugfs_server && !ugfs_volfile) || !ugfs_volume) { uwsgi_log("[glusterfs] mount requires a mountpoint, a volume and at least one server or volfile\n"); exit(1); } int id = uwsgi_apps_cnt; time_t now = uwsgi_now(); uwsgi_log("[glusterfs] mounting %s ...\n", ugfs_mountpoint); // this should fail only if memory is not available glfs_t *volume = glfs_new(ugfs_volume); if (!volume) { uwsgi_error("unable to initialize glusterfs mountpoint: glfs_new()"); exit(1); } if (ugfs_volfile) { if (glfs_set_volfile(volume, ugfs_volfile)) { uwsgi_error("unable to set glusterfs volfile: glfs_set_volfile\n"); exit(1); } } /* here we pass ugfs_server as the callable field. After fork() if this field is defined we will start trying to connect to each one of the configuratio nodes This is required to have fallback management */ struct uwsgi_app *ua = uwsgi_add_app(id, glusterfs_plugin.modifier1, ugfs_mountpoint, strlen(ugfs_mountpoint), volume, ugfs_server); if (!ua) { uwsgi_log("[glusterfs] unable to mount %s\n", ugfs_mountpoint); exit(1); } ua->started_at = now; ua->startup_time = uwsgi_now() - now; uwsgi_log("GlusterFS app/mountpoint %d (%s) loaded in %d seconds at %p\n", id, ugfs_mountpoint, (int) ua->startup_time, volume); }
int main(int argc, char *argv[]) { int ret = 0; char *hostname = NULL; char *volname = NULL; char *logfile = NULL; glfs_t *fs = NULL; if (argc != 4) { fprintf(stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new(volname); if (!fs) { LOG_ERR("glfs_new failed"); return -1; } ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); if (ret < 0) { LOG_ERR("glfs_set_volfile_server failed"); goto err; } ret = glfs_set_logging(fs, logfile, 7); if (ret < 0) { LOG_ERR("glfs_set_logging failed"); goto err; } ret = glfs_init(fs); if (ret < 0) { LOG_ERR("glfs_init failed"); goto err; } glfs_fini(fs); fs = NULL; return 0; err: glfs_fini(fs); fs = NULL; return -1; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0; glfs_fd_t *fd = NULL; struct stat sb = {0, }; char readbuf[32]; char writebuf[32]; char *volname = "iops"; char *filename = "/filename2"; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } // ret = glfs_set_volfile (fs, "/tmp/filename.vol"); ret = glfs_set_volfile_server (fs, "socket", "localhost", 24007); // ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0); ret = glfs_set_logging (fs, "/dev/stderr", 7); ret = glfs_init (fs); fprintf (stderr, "glfs_init: returned %d\n", ret); ret = glfs_lstat (fs, filename, &sb); fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno)); fd = glfs_creat (fs, filename, O_RDWR, 0644); fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno)); sprintf (writebuf, "hi there\n"); ret = glfs_write (fd, writebuf, 32, 0); glfs_lseek (fd, 0, SEEK_SET); ret = glfs_read (fd, readbuf, 32, 0); printf ("read %d, %s", ret, readbuf); glfs_close (fd); return ret; }
int main(int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; char readbuf[32]; char *logname = NULL; char *hostname = NULL; char *volname = NULL; fprintf(stderr, "Starting libgfapi_fini\n"); if (argc < 4) { fprintf(stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logname = argv[3]; fs = glfs_new(volname); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); exit(1); } ret = glfs_set_volfile_server(fs, "tcp", hostname, 0); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging(fs, logname, 7); LOG_ERR("glfs_set_logging", ret); /* Do not call glfs_init. * glfs_fini() shouldn't hang in that case*/ ret = glfs_fini(fs); LOG_ERR("glfs_fini", ret); fprintf(stderr, "End of libgfapi_fini\n"); exit(0); }
glfs_t * setup_new_client(char *hostname, char *volname, char *log_file, int flag) { int ret = 0; glfs_t *fs = NULL; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "\nglfs_new: returned NULL (%s)\n", strerror (errno)); goto error; } ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); if (ret < 0) { fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret, strerror (errno)); goto error; } ret = glfs_set_logging (fs, log_file, 7); if (ret < 0) { fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret, strerror (errno)); goto error; } if (flag == NO_INIT) goto out; ret = glfs_init (fs); if (ret < 0) { fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n", ret, strerror (errno)); goto error; } out: return fs; error: return NULL; }
glfs_t * init_glfs (const char *hostname, const char *volname, const char *logfile) { int ret = -1; glfs_t *fs = NULL; fs = glfs_new (volname); if (!fs) { LOG_ERR ("glfs_new failed"); return NULL; } ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); if (ret < 0) { LOG_ERR ("glfs_set_volfile_server failed"); goto out; } ret = glfs_set_logging (fs, logfile, 7); if (ret < 0) { LOG_ERR ("glfs_set_logging failed"); goto out; } ret = glfs_init (fs); if (ret < 0) { LOG_ERR ("glfs_init failed"); goto out; } ret = 0; out: if (ret) { glfs_fini (fs); fs = NULL; } return fs; }
int main(int argc, char *argv[]) { int ret = -1; int flags = O_RDWR | O_SYNC; glfs_t *fs = NULL; glfs_fd_t *fd = NULL; char *volname = NULL; char *logfile = NULL; const char *filename = "file_tmp"; struct glfs_object *object = NULL; acl_t acl = NULL; struct stat sb; if (argc != 3) { fprintf(stderr, "Invalid argument\n"); return 1; } volname = argv[1]; logfile = argv[2]; fs = glfs_new(volname); if (!fs) VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out); ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); ret = glfs_set_logging(fs, logfile, 7); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); ret = glfs_init(fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); fd = glfs_creat(fs, filename, flags, 0044); if (fd == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out); } glfs_close(fd); object = glfs_h_lookupat(fs, NULL, filename, NULL, 0); if (object == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out); } ret = glfs_chown(fs, filename, 99, 99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out); ret = glfs_setfsuid(99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out); ret = glfs_setfsgid(99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out); acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS); if (acl == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); } ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); out: glfs_setfsuid(0); glfs_setfsgid(0); if (object) glfs_h_close(object); if (fs) glfs_fini(fs); return ret; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; char *filename = "/a1"; char *filename2 = "/a2"; struct stat sb = {0, }; struct callback_arg cbk; char *logfile = NULL; char *volname = NULL; int cnt = 1; struct callback_inode_arg *in_arg = NULL; struct glfs_object *root = NULL, *leaf = NULL; cbk.reason = 0; fprintf (stderr, "Starting libgfapi_fini\n"); if (argc != 3) { fprintf (stderr, "Invalid argument\n"); exit(1); } volname = argv[1]; logfile = argv[2]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); sleep (2); root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR ("glfs_h_lookupat root", ret); } leaf = glfs_h_lookupat (fs, root, filename, &sb, 0); if (!leaf) { ret = -1; LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); } leaf = glfs_h_creat (fs, root, filename, O_RDWR, 0644, &sb); if (!leaf) { ret = -1; LOG_ERR ("glfs_h_lookupat leaf", ret); } fprintf (stderr, "glfs_h_create leaf - %p\n", leaf); leaf = glfs_h_lookupat (fs, root, filename2, &sb, 0); if (!leaf) { ret = -1; LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); } ret = glfs_h_rename (fs, root, filename, root, filename2); LOG_ERR("glfs_rename", ret); while (cnt++ < 5) { ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); /* There should not be any upcalls sent */ if (cbk.reason != GFAPI_CBK_EVENT_NULL) { fprintf (stderr, "Error: Upcall received(%d)\n", cbk.reason); exit (1); } } ret = glfs_fini(fs); LOG_ERR("glfs_fini", ret); fprintf (stderr, "End of libgfapi_fini\n"); exit(0); }
int main(int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0, i, status = 0; glfs_fd_t *fd1 = NULL; glfs_fd_t *fd2 = NULL; glfs_fd_t *fd3 = NULL; char *filename = "file_tmp"; char *volname = NULL; char *logfile = NULL; char *hostname = NULL; if (argc != 4) { fprintf(stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new(volname); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); return -1; } ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging(fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init(fs); LOG_ERR("glfs_init", ret); fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644); if (fd1 <= 0) { ret = -1; LOG_ERR("glfs_creat", ret); } fprintf(stderr, "glfs-create fd1 - %d\n", fd1); fd2 = glfs_dup(fd1); fprintf(stderr, "glfs-dup fd2 - %d\n", fd2); fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC); if (fd2 <= 0) { ret = -1; LOG_ERR("glfs_open", ret); } fprintf(stderr, "glfs-open fd3 - %d\n", fd3); /* TEST 1: Conflicting ranges, same lk_owner * lock1 (0, 10, lownera) * lock2 (5, 10, lownera) * Expected: should not fail but get merged */ ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8); LOG_ERR("==== glfs_lock_test_1", ret); /* TEST 2: Conflicting ranges, different lk_owner * lock1 (0, 10, lownera) - already taken * lock2 (5, 10, lownerb) * Expected: should fail and not get merged */ ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8); LOG_ERR("==== glfs_lock_test_2", ret); /* TEST 3: Different ranges, same lk_owner * lock1 (0, 10, lownera) - already taken * lock2 (30, 10, lownera) * Expected: should not fail */ ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8); LOG_ERR("==== glfs_lock_test_3", ret); /* TEST 4: Conflicting ranges, different lk_owner * lock1 (0, 10, lownera) - already taken * lock2 (50, 10, lownerb) * Expected: should not fail */ ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8); LOG_ERR("==== glfs_lock_test_4", ret); /* TEST 5: Close fd1 & retry TEST2 * lock1 (not applicable) * lock2 (5, 10, lownerb) * Expected: should succeed now */ ret = glfs_close(fd1); LOG_ERR("glfs_close", ret); ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8); LOG_ERR("==== glfs_lock_test_5", ret); /* TEST 6: Check closing fd1 doesn't flush fd2 locks * retry TEST 4 but with fd2 and fd3. * lock1 (50, 10, lownerb) - already taken * lock2 (55, 10, lownerc) * Expected: should fail */ ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8); LOG_ERR("==== glfs_lock_test_6", ret); err: ret = glfs_close(fd2); LOG_ERR("glfs_close", ret); ret = glfs_close(fd3); LOG_ERR("glfs_close", ret); out: if (fs) { ret = glfs_fini(fs); fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); } if (ret) exit(1); exit(0); }
int main(int argc, char *argv[]) { int ret = 1; int opcode = -1; off_t offset = 0; size_t len = 0; glfs_t *fs = NULL; glfs_fd_t *fd = NULL; if (argc != 8) { fprintf(stderr, "Syntax: %s <host> <volname> <opcode> <offset> <len> " "<file-path> <log-file>\n", argv[0]); return 1; } fs = glfs_new(argv[2]); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); if (ret != 0) { fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); goto out; } ret = glfs_set_logging(fs, argv[7], 7); if (ret != 0) { fprintf(stderr, "glfs_set_logging: returned %d\n", ret); goto out; } ret = glfs_init(fs); if (ret != 0) { fprintf(stderr, "glfs_init: returned %d\n", ret); goto out; } opcode = atoi(argv[3]); opcode = get_fallocate_flag(opcode); if (opcode < 0) { fprintf(stderr, "get_fallocate_flag: invalid flag \n"); goto out; } offset = atoi(argv[4]); len = atoi(argv[5]); fd = glfs_open(fs, argv[6], O_RDWR); if (fd == NULL) { fprintf(stderr, "glfs_open: returned NULL\n"); goto out; } ret = glfs_fallocate(fd, opcode, offset, len); if (ret <= 0) { fprintf(stderr, "glfs_fallocate: returned %d\n", ret); goto out; } ret = 0; out: if (fd) glfs_close(fd); glfs_fini(fs); return ret; }
bool GlusterBackend::initialize(GlusterFSConnection _connectionInfo) { this->connectionInfo= _connectionInfo; //Create fs = glfs_new(connectionInfo.volumeName.c_str()); if(fs==nullptr){ LOG(ERROR)<<"Error in creating GlusterFS instance."; return false; } //Set volume server /** * * NOTE: This API is special, multiple calls to this function with different * volfile servers, port or transport-type would create a list of volfile * servers which would be polled during `volfile_fetch_attempts() * * @transport: String specifying the transport used to connect to the * management daemon. Specifying NULL will result in the usage * of the default (tcp) transport type. Permitted values * are those what you specify as transport-type in a volume * specification file (e.g "tcp", "rdma" etc.) * * 0 : Success. * -1 : Failure. @errno will be set with the type of failure. **/ bool allFailed = true; for(VolumeServer &volServer:_connectionInfo.volumeServers){ int ret = glfs_set_volfile_server ((glfs_t*)fs, volServer.transport.c_str(), volServer.serverIP.c_str(), volServer.port); //int ret = glfs_set_volfile_server ((glfs_t*)fs, volServer.transport.c_str(), volServer.serverIP.c_str(), 23432); //int ret = glfs_set_volfile_server ((glfs_t*)fs, volServer.transport.c_str(), volServer.serverIP.c_str(), ); if(ret !=0){ glfs_unset_volfile_server((glfs_t*)fs, volServer.transport.c_str(), volServer.serverIP.c_str(), volServer.port); LOG(ERROR)<<"Error in connecting to VolumeServer:"<<volServer.serverIP <<":"<<volServer.port<<"("<<volServer.transport<<")"<<" ErrorCode:"<<ret; } else allFailed = false; } if(allFailed){ LOG(ERROR)<<"Couldn't connect to any of Volume Servers. Gluster Initialization failed."; glfs_fini((glfs_t*)fs); return false; } //Set Logging info if(glfs_set_logging ((glfs_t*)fs, "/dev/stderr", 5)!=0) LOG(ERROR)<<"Failed to set logging for GlusterFS."; int ret = glfs_init((glfs_t*)fs); if(ret!=0){ LOG(ERROR)<<"Failed to initialize GlusterFS. ErrorCode:"<<ret; glfs_fini((glfs_t*)fs); return false; } LOG(INFO)<<"GlusterFS backend initialized for Volume:"<<this->connectionInfo.volumeName; /*vector<BackendItem> tmp; list(tmp);*/ return true; }
int main(int argc, char *argv[]) { int ret = -1; glfs_t *fs = NULL; char *volname = NULL; char *logfile = NULL; char *hostname = NULL; char *my_file = "file_"; char my_file_name[MAXPATHNAME]; uint32_t flags = O_RDWR | O_SYNC; struct glfs_fd *fd = NULL; int i = 0; int pct = 0; struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp; struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp; if (argc != 4) { fprintf(stderr, "Invalid argument\n"); return 1; } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new(volname); VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out); ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); ret = glfs_set_logging(fs, logfile, 7); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); ret = glfs_init(fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); for (i = 0; i < MAX_FILES_CREATE; i++) { sprintf(my_file_name, "%s%d", my_file, i); fd = glfs_creat(fs, my_file_name, flags, 0644); VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out); glfs_close(fd); } /* measure performance using old readdir call and new xreaddirplus call and * compare */ ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp); VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); ret = old_readdir(fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out); ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp); VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); assimilatetime(&otimestamp, ost_timestamp, oed_timestamp); printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", otimestamp.tv_sec, otimestamp.tv_nsec); ret = clock_gettime(CLOCK_REALTIME, &st_timestamp); VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); ret = new_xreaddirplus(fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out); ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp); VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); assimilatetime(×tamp, st_timestamp, ed_timestamp); printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", timestamp.tv_sec, timestamp.tv_nsec); pct = comparetime(otimestamp, timestamp); printf("There is improvement by %d%%\n", pct); ret = 0; out: if (fs) { ret = glfs_fini(fs); if (ret) fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); } return ret; }
int main(int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; char *filename = "/a1"; char *filename2 = "/a2"; struct stat sb = { 0, }; char *logfile = NULL; char *volname = NULL; char *hostname = NULL; int cnt = 1; int upcall_received = 0; struct glfs_upcall *cbk = NULL; struct glfs_object *root = NULL, *leaf = NULL; unsigned char globjhdl[GFAPI_HANDLE_LENGTH]; unsigned char globjhdl2[GFAPI_HANDLE_LENGTH]; fprintf(stderr, "Starting libgfapi_fini\n"); if (argc != 4) { fprintf(stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new(volname); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging(fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init(fs); LOG_ERR("glfs_init", ret); /* This does not block, but enables caching of events. Real * applications like NFS-Ganesha run this in a thread before activity * on the fs (through this instance) happens. */ ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR("glfs_h_poll_upcall", ret); fs2 = glfs_new(volname); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging(fs2, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init(fs2); LOG_ERR("glfs_init", ret); sleep(2); root = glfs_h_lookupat(fs, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR("glfs_h_lookupat root", ret); } leaf = glfs_h_lookupat(fs, root, filename, &sb, 0); if (!leaf) { ret = -1; LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret); } root = glfs_h_lookupat(fs2, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR("glfs_h_lookupat root", ret); } leaf = glfs_h_creat(fs2, root, filename, O_RDWR, 0644, &sb); if (!leaf) { ret = -1; LOG_ERR("glfs_h_lookupat leaf", ret); } fprintf(stderr, "glfs_h_create leaf - %p\n", leaf); while (cnt++ < 5 && !upcall_received) { enum glfs_upcall_reason reason = 0; struct glfs_upcall_inode *in_arg = NULL; ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR("glfs_h_poll_upcall", ret); if (ret) goto retry; reason = glfs_upcall_get_reason(cbk); fprintf(stderr, "Upcall received(%d)\n", reason); if (reason == GLFS_UPCALL_INODE_INVALIDATE) { struct glfs_object *object = NULL; in_arg = glfs_upcall_get_event(cbk); object = glfs_upcall_inode_get_object(in_arg); ret = glfs_h_extract_handle(root, globjhdl + GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); ret = glfs_h_extract_handle(object, globjhdl2 + GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); if (memcmp(globjhdl + GLAPI_UUID_LENGTH, globjhdl2 + GLAPI_UUID_LENGTH, 16)) { fprintf(stderr, "Error: gfid mismatch\n"); exit(1); } upcall_received = 1; } retry: if (!upcall_received) sleep(1); /* glfs_h_poll_upcall() does not block */ if (!ret) { glfs_free(cbk); cbk = NULL; } } if (!upcall_received) { fprintf(stderr, "Error: Upcall not received\n"); exit(1); } ret = glfs_fini(fs); LOG_ERR("glfs_fini", ret); fprintf(stderr, "End of libgfapi_fini\n"); exit(0); }
/* * Open a volume using gfapi. */ int gfapi_device::d_open(const char *pathname, int flags, int mode) { int status; POOL_MEM virtual_filename(PM_FNAME); /* * Parse the gluster URI. */ if (!m_gfapi_volume) { m_gfapi_volume = bstrdup(dev_name); if (!parse_gfapi_devicename(m_gfapi_volume, &m_transport, &m_servername, &m_volumename, &m_basedir, &m_serverport)) { Mmsg1(errmsg, _("Unable to parse device URI %s.\n"), dev_name); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } } /* * See if we need to setup a Gluster context. */ if (!m_glfs) { m_glfs = glfs_new(m_volumename); if (!m_glfs) { Mmsg1(errmsg, _("Unable to create new Gluster context for volumename %s.\n"), m_volumename); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } status = glfs_set_volfile_server(m_glfs, (m_transport) ? m_transport : "tcp", m_servername, m_serverport); if (status < 0) { Mmsg3(errmsg, _("Unable to initialize Gluster management server for transport %s, servername %s, serverport %d\n"), (m_transport) ? m_transport : "tcp", m_servername, m_serverport); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } status = glfs_init(m_glfs); if (status < 0) { Mmsg1(errmsg, _("Unable to initialize Gluster for volumename %s.\n"), m_volumename); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } } /* * See if we don't have a file open already. */ if (m_gfd) { glfs_close(m_gfd); m_gfd = NULL; } /* * See if we store in an explicit directory. */ if (m_basedir) { struct stat st; /* * Make sure the dir exists if one is defined. */ Mmsg(virtual_filename, "/%s", m_basedir); if (glfs_stat(m_glfs, virtual_filename.c_str(), &st) != 0) { switch (errno) { case ENOENT: if (!gfapi_makedir(m_glfs, virtual_filename.c_str())) { Mmsg1(errmsg, _("Specified glusterfs direcory %s cannot be created.\n"), virtual_filename.c_str()); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } break; default: goto bail_out; } } else { if (!S_ISDIR(st.st_mode)) { Mmsg1(errmsg, _("Specified glusterfs direcory %s is not a directory.\n"), virtual_filename.c_str()); Emsg0(M_FATAL, 0, errmsg); goto bail_out; } } Mmsg(virtual_filename, "/%s/%s", m_basedir, getVolCatName()); } else { Mmsg(virtual_filename, "%s", getVolCatName()); } /* * See if the O_CREAT flag is set as glfs_open doesn't support that flag and you have to call glfs_creat then. */ if (flags & O_CREAT) { m_gfd = glfs_creat(m_glfs, virtual_filename.c_str(), flags, mode); } else { m_gfd = glfs_open(m_glfs, virtual_filename.c_str(), flags); } if (!m_gfd) { goto bail_out; } return 0; bail_out: /* * Cleanup the Gluster context. */ if (m_glfs) { glfs_fini(m_glfs); m_glfs = NULL; } return -1; }
int main (int argc, char *argv[]) { int ret = 0; glfs_t *fs = NULL; struct glfs_object *root = NULL, *file_obj = NULL; struct stat sb = {0, }; char readbuf[32], writebuf[32]; char *filename = "file.txt"; char *logfile = NULL; char *volname = NULL; char *hostname = NULL; if (argc != 4) { fprintf (stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); ret = -1; } ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); if (root == NULL) { fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n", strerror (errno)); goto out; } file_obj = glfs_h_creat (fs, root, filename, O_CREAT, 0644, &sb); if (file_obj == NULL) { fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n", filename, root, strerror (errno)); goto out; } /* test read/write based on anonymous fd */ memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32); ret = glfs_h_anonymous_write (fs, file_obj, writebuf, 32, 0); if (ret < 0) LOG_ERR ("glfs_h_anonymous_write", ret); ret = glfs_h_anonymous_read (fs, file_obj, readbuf, 32, 0); if (ret < 0) LOG_ERR ("glfs_h_anonymous_read", ret); if (memcmp (readbuf, writebuf, 32)) { fprintf (stderr, "Failed to read what I wrote: %s %s\n", readbuf, writebuf); ret = -1; goto out; } ret = 0; out: if (file_obj) glfs_h_close (file_obj); if (fs) { ret = glfs_fini(fs); fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); } if (ret) exit(1); exit(0); }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0; int i = 0; glfs_fd_t *fd = NULL; glfs_fd_t *fd1 = NULL; char *topdir = "topdir", *filename = "file1"; char *buf = NULL; char *logfile = NULL; if (argc != 3) { fprintf (stderr, "Expect following args %s <Vol> <log file>\n" , argv[0]); return -1; } logfile = argv[2]; for (i = 0; i < TEST_CASE_LOOP; i++) { fs = glfs_new (argv[1]); if (!fs) { fprintf (stderr, "glfs_new: returned NULL (%s)\n", strerror (errno)); return -1; } ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); if (ret < 0) { fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret, strerror (errno)); return -1; } ret = glfs_set_logging (fs, logfile, 7); if (ret < 0) { fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret, strerror (errno)); return -1; } ret = glfs_init (fs); if (ret < 0) { fprintf (stderr, "glfs_init failed with ret: %d (%s)\n", ret, strerror (errno)); return -1; } ret = large_number_of_fops (fs); if (ret < 0) return -1; ret = large_read_write (fs); if (ret < 0) return -1; ret = volfile_change (argv[1]); if (ret < 0) return -1; ret = large_number_of_fops (fs); if (ret < 0) return -1; ret = large_read_write (fs); if (ret < 0) return -1; ret = glfs_fini (fs); if (ret < 0) { fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", ret, strerror (errno)); return -1; } } return 0; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; char *filename = "/a1"; char *filename2 = "/a2"; struct stat sb = {0, }; struct glfs_callback_arg cbk; char *logfile = NULL; char *volname = NULL; int cnt = 1; int upcall_received = 0; struct glfs_callback_inode_arg *in_arg = NULL; struct glfs_object *root = NULL, *leaf = NULL; unsigned char globjhdl[GFAPI_HANDLE_LENGTH]; unsigned char globjhdl2[GFAPI_HANDLE_LENGTH]; cbk.reason = 0; fprintf (stderr, "Starting libgfapi_fini\n"); if (argc != 3) { fprintf (stderr, "Invalid argument\n"); exit(1); } volname = argv[1]; logfile = argv[2]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); fs2 = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs2, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs2); LOG_ERR("glfs_init", ret); sleep (2); root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR ("glfs_h_lookupat root", ret); } leaf = glfs_h_lookupat (fs, root, filename, &sb, 0); if (!leaf) { ret = -1; LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); } root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR ("glfs_h_lookupat root", ret); } leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb); if (!leaf) { ret = -1; LOG_ERR ("glfs_h_lookupat leaf", ret); } fprintf (stderr, "glfs_h_create leaf - %p\n", leaf); while (cnt++ < 5) { ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); if (cbk.reason == GFAPI_INODE_INVALIDATE) { fprintf (stderr, "Upcall received(%d)\n", cbk.reason); in_arg = (struct glfs_callback_inode_arg *)(cbk.event_arg); ret = glfs_h_extract_handle (root, globjhdl+GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); ret = glfs_h_extract_handle (in_arg->object, globjhdl2+GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); if (memcmp (globjhdl+GLAPI_UUID_LENGTH, globjhdl2+GLAPI_UUID_LENGTH, 16)) { fprintf (stderr, "Error: gfid mismatch\n"); exit (1); } upcall_received = 1; } } if (!upcall_received) { fprintf (stderr, "Error: Upcall not received\n"); exit (1); } ret = glfs_fini(fs); LOG_ERR("glfs_fini", ret); fprintf (stderr, "End of libgfapi_fini\n"); exit(0); }
int main (int argc, char *argv[]) { int ret = -1; int flags = O_RDWR|O_SYNC; glfs_t *fs = NULL; glfs_fd_t *fd1 = NULL; char *volname = NULL; char *logfile = NULL; const char *filename = "file_tmp"; const char buff[WRITE_SIZE]; struct stat sb; if (argc != 3) { fprintf (stderr, "Invalid argument\n"); return 1; } volname = argv[1]; logfile = argv[2]; fs = glfs_new (volname); if (!fs) VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out); ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out); ret = glfs_set_logging (fs, logfile, 7); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out); ret = glfs_init (fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out); fd1 = glfs_creat(fs, filename, flags, 0644); if (fd1 == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out); } ret = glfs_write (fd1, buff, WRITE_SIZE, flags); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out); ret = glfs_truncate (fs, filename, TRUNC_SIZE); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out); ret = glfs_fstat (fd1, &sb); VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out); if (sb.st_size != TRUNC_SIZE) { fprintf (stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size, (intmax_t)2048); ret = -1; } out: if (fd1 != NULL) glfs_close(fd1); if (fs) { /* * If this fails (as it does on Special Snowflake NetBSD for no * good reason), it shouldn't affect the result of the test. */ (void) glfs_fini(fs); } return ret; }
int main (int argc, char **argv) { glfs_t *fs; int ret; int meta_fd = (-1); char *meta_buf = NULL; int data_fd = (-1); char *data_buf = NULL; fs = glfs_new ("whocares"); if (!fs) { fprintf (stderr, "glfs_new failed\n"); return EXIT_FAILURE; } if (getenv("RECON_DEBUG")) { ret = glfs_set_logging (fs, "/dev/stderr", 7); } else { ret = glfs_set_logging (fs, "/dev/null", 0); } if (ret != GFAPI_SUCCESS) { fprintf (stderr, "glfs_set_logging failed (%d)\n", errno); return EXIT_FAILURE; } ret = glfs_set_volfile (fs, argv[1]); if (ret != GFAPI_SUCCESS) { fprintf (stderr, "glfs_set_volfile failed (%d)\n", errno); return EXIT_FAILURE; } ret = glfs_init (fs); if (ret != GFAPI_SUCCESS) { fprintf (stderr, "glfs_init failed (%d)\n", errno); return EXIT_FAILURE; } meta_fd = open (argv[2], O_RDONLY); if (meta_fd < 0) { perror ("open"); return EXIT_FAILURE; } /* TBD: get proper length */ meta_buf = mmap (NULL, 1048576, PROT_READ, MAP_PRIVATE, meta_fd, 0); if (meta_buf == MAP_FAILED) { perror ("mmap"); return EXIT_FAILURE; } data_fd = open (argv[3], O_RDONLY); if (data_fd < 0) { perror ("open"); return EXIT_FAILURE; } /* TBD: get proper length */ data_buf = mmap (NULL, 1048576, PROT_READ, MAP_PRIVATE, data_fd, 0); if (data_buf == MAP_FAILED) { perror ("mmap"); return EXIT_FAILURE; } for (;;) { if (!recon_execute(fs,&meta_buf,&data_buf)) { break; } } return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; glfs_t *fs_tmp = NULL; glfs_t *fs_tmp2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; glfs_fd_t *fd2 = NULL; glfs_fd_t *fd_tmp = NULL; glfs_fd_t *fd_tmp2 = NULL; char readbuf[32]; char *filename = "file_tmp"; char *writebuf = NULL; char *vol_id = NULL; unsigned int cnt = 1; struct glfs_upcall *cbk = NULL; char *logfile = NULL; char *volname = NULL; char *hostname = NULL; if (argc != 4) { fprintf (stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return -1; } ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); /* This does not block, but enables caching of events. Real * applications like NFS-Ganesha run this in a thread before activity * on the fs (through this instance) happens. */ ret = glfs_h_poll_upcall(fs_tmp, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); fs2 = glfs_new (volname); if (!fs2) { fprintf (stderr, "glfs_new fs2: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server-fs2", ret); ret = glfs_set_logging (fs2, logfile, 7); LOG_ERR("glfs_set_logging-fs2", ret); ret = glfs_init (fs2); LOG_ERR("glfs_init-fs2", ret); fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); if (fd <= 0) { ret = -1; LOG_ERR ("glfs_creat", ret); } fprintf (stderr, "glfs-create fd - %d\n", fd); fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT); if (fd2 <= 0) { ret = -1; LOG_ERR ("glfs_open-fs2", ret); } fprintf (stderr, "glfs-open fd2 - %d\n", fd2); do { if (cnt%2) { fd_tmp = fd; fs_tmp = fs; fd_tmp2 = fd2; fs_tmp2 = fs2; } else { fd_tmp = fd2; fs_tmp = fs2; fd_tmp2 = fd; fs_tmp2 = fs; } /* WRITE on fd_tmp */ writebuf = malloc(10); if (writebuf) { memcpy (writebuf, "abcd", 4); ret = glfs_write (fd_tmp, writebuf, 4, 0); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_write", ret); } else { fprintf (stderr, "glfs_write suceeded\n"); } free(writebuf); } else { fprintf (stderr, "Could not allocate writebuf\n"); return -1; } /* READ on fd_tmp2 */ ret = glfs_lseek (fd_tmp2, 0, SEEK_SET); LOG_ERR ("glfs_lseek", ret); memset (readbuf, 0, sizeof(readbuf)); ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_pread", ret); } else { fprintf (stderr, "glfs_read: %s\n", readbuf); } /* Open() fops seem to be not performed on server side until * there are I/Os on that fd */ if (cnt > 2) { struct glfs_upcall_inode *in_arg = NULL; enum glfs_upcall_reason reason = 0; struct glfs_object *object = NULL; uint64_t flags = 0; uint64_t expire = 0; ret = glfs_h_poll_upcall(fs_tmp, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); reason = glfs_upcall_get_reason (cbk); /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */ if (reason == GLFS_UPCALL_INODE_INVALIDATE) { in_arg = glfs_upcall_get_event (cbk); object = glfs_upcall_inode_get_object (in_arg); flags = glfs_upcall_inode_get_flags (in_arg); expire = glfs_upcall_inode_get_expire (in_arg); fprintf (stderr, " upcall event type - %d," " object(%p), flags(%d), " " expire_time_attr(%d)\n" , reason, object, flags, expire); } else { fprintf (stderr, "Didnt receive upcall notify event"); ret = -1; goto err; } glfs_free (cbk); } sleep(5); } while (++cnt < 5); err: glfs_close(fd); LOG_ERR ("glfs_close", ret); glfs_close(fd2); LOG_ERR ("glfs_close-fd2", ret); out: if (fs) { ret = glfs_fini(fs); fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); } if (fs2) { ret = glfs_fini(fs2); fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret); } if (ret) exit(1); exit(0); }
static bool glfs_check_config(const char *cfgstring, char **reason) { char *path; char *servername = NULL; char *volname = NULL; char *pathname = NULL; glfs_t *fs = NULL; glfs_fd_t *gfd = NULL; struct stat st; int ret; bool result = true; path = strchr(cfgstring, '/'); if (!path) { if (asprintf(reason, "No path found") == -1) *reason = NULL; result = false; goto done; } path += 1; /* get past '/' */ if (parse_imagepath(path, &servername, &volname, &pathname) == -1) { if (asprintf(reason, "Invalid imagepath") == -1) *reason = NULL; result = false; goto done; } /* Actually attempt to open the volume to verify things are working */ /* TODO: consolidate this with v. similar tcmu_glfs_open code? */ fs = glfs_new(volname); if (!fs) { if (asprintf(reason, "glfs_new failed") == -1) *reason = NULL; result = false; goto done; } ret = glfs_set_volfile_server(fs, "tcp", servername, GLUSTER_PORT); if (ret) { if (asprintf(reason, "glfs_set_volfile_server failed: %m") == -1) *reason = NULL; result = false; goto done; } ret = glfs_init(fs); if (ret) { if (asprintf(reason, "glfs_init failed: %m") == -1) *reason = NULL; result = false; goto done; } gfd = glfs_open(fs, pathname, ALLOWED_BSOFLAGS); if (!gfd) { if (asprintf(reason, "glfs_open failed: %m") == -1) *reason = NULL; result = false; goto done; } ret = glfs_lstat(fs, pathname, &st); if (ret) { if (asprintf(reason, "glfs_lstat failed: %m") == -1) *reason = NULL; result = false; goto done; } done: if (gfd) glfs_close(gfd); if (fs) glfs_fini(fs); free(servername); free(volname); free(pathname); return result; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; int ret = 0; glfs_fd_t *fd = NULL; glfs_fd_t *fd2 = NULL; struct stat sb = {0, }; char readbuf[32]; char writebuf[32]; char *filename = "/filename2"; fs = glfs_new ("fsync"); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } // ret = glfs_set_volfile (fs, "/tmp/posix.vol"); ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); // ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0); ret = glfs_set_logging (fs, "/dev/stderr", 7); ret = glfs_init (fs); fprintf (stderr, "glfs_init: returned %d\n", ret); sleep (2); fs2 = glfs_new ("fsync"); if (!fs2) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } // ret = glfs_set_volfile (fs2, "/tmp/posix.vol"); ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007); ret = glfs_set_logging (fs2, "/dev/stderr", 7); ret = glfs_init (fs2); fprintf (stderr, "glfs_init: returned %d\n", ret); ret = glfs_lstat (fs, filename, &sb); fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno)); fd = glfs_creat (fs, filename, O_RDWR, 0644); fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno)); fd2 = glfs_open (fs2, filename, O_RDWR); fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno)); sprintf (writebuf, "hi there\n"); ret = glfs_write (fd, writebuf, 32, 0); glfs_lseek (fd2, 0, SEEK_SET); ret = glfs_read (fd2, readbuf, 32, 0); printf ("read %d, %s", ret, readbuf); glfs_close (fd); glfs_close (fd2); filename = "/filename3"; ret = glfs_mknod (fs, filename, S_IFIFO, 0); fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno)); ret = glfs_lstat (fs, filename, &sb); fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno)); ret = glfs_rename (fs, filename, "/filename4"); fprintf (stderr, "rename(%s): (%d) %s\n", filename, ret, strerror (errno)); ret = glfs_unlink (fs, "/filename4"); fprintf (stderr, "unlink(%s): (%d) %s\n", "/filename4", ret, strerror (errno)); filename = "/dirname2"; ret = glfs_mkdir (fs, filename, 0); fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno)); ret = glfs_lstat (fs, filename, &sb); fprintf (stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror (errno)); ret = glfs_rmdir (fs, filename); fprintf (stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror (errno)); test_dirops (fs); test_xattr (fs); test_chdir (fs); // done glfs_fini (fs); glfs_fini (fs2); return ret; }
static int tcmu_glfs_open(struct tcmu_device *dev) { struct glfs_state *gfsp; int ret = 0; char *config; struct stat st; int attribute; gfsp = calloc(1, sizeof(*gfsp)); if (!gfsp) return -ENOMEM; tcmu_set_dev_private(dev, gfsp); attribute = tcmu_get_attribute(dev, "hw_block_size"); if (attribute == -1) { errp("Could not get hw_block_size setting\n"); goto fail; } gfsp->block_size = attribute; config = strchr(tcmu_get_dev_cfgstring(dev), '/'); if (!config) { errp("no configuration found in cfgstring\n"); goto fail; } config += 1; /* get past '/' */ if (parse_imagepath(config, &gfsp->servername, &gfsp->volname, &gfsp->pathname) == -1) { errp("servername, volname, or pathname not set\n"); goto fail; } gfsp->fs = glfs_new(gfsp->volname); if (!gfsp->fs) { errp("glfs_new failed\n"); goto fail; } ret = glfs_set_volfile_server(gfsp->fs, "tcp", gfsp->servername, GLUSTER_PORT); if (ret) { errp("glfs_set_volfile_server failed: %m\n"); goto fail; } ret = glfs_init(gfsp->fs); if (ret) { errp("glfs_init failed: %m\n"); goto fail; } gfsp->gfd = glfs_open(gfsp->fs, gfsp->pathname, ALLOWED_BSOFLAGS); if (!gfsp->gfd) { errp("glfs_open failed: %m\n"); goto fail; } ret = glfs_lstat(gfsp->fs, gfsp->pathname, &st); if (ret) { errp("glfs_lstat failed: %m\n"); goto fail; } if (st.st_size != tcmu_get_device_size(dev)) { errp("device size and backing size disagree: " "device %lld backing %lld\n", tcmu_get_device_size(dev), (long long) st.st_size); goto fail; } return 0; fail: if (gfsp->gfd) glfs_close(gfsp->gfd); if (gfsp->fs) glfs_fini(gfsp->fs); free(gfsp->volname); free(gfsp->pathname); free(gfsp->servername); free(gfsp); return -EIO; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; glfs_t *fs_tmp = NULL; glfs_t *fs_tmp2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; glfs_fd_t *fd2 = NULL; glfs_fd_t *fd_tmp = NULL; glfs_fd_t *fd_tmp2 = NULL; char readbuf[32]; char *filename = "file_tmp"; char *writebuf = NULL; char *vol_id = NULL; unsigned int cnt = 1; struct callback_arg cbk; char *logfile = NULL; char *volname = NULL; cbk.object = NULL; if (argc != 3) { fprintf (stderr, "Invalid argument\n"); exit(1); } volname = argv[1]; logfile = argv[2]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return -1; } ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); fs2 = glfs_new (volname); if (!fs2) { fprintf (stderr, "glfs_new fs2: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server-fs2", ret); ret = glfs_set_logging (fs2, logfile, 7); LOG_ERR("glfs_set_logging-fs2", ret); ret = glfs_init (fs2); LOG_ERR("glfs_init-fs2", ret); fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); if (fd <= 0) { ret = -1; LOG_ERR ("glfs_creat", ret); } fprintf (stderr, "glfs-create fd - %d\n", fd); fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT); if (fd2 <= 0) { ret = -1; LOG_ERR ("glfs_open-fs2", ret); } fprintf (stderr, "glfs-open fd2 - %d\n", fd2); do { if (cnt%2) { fd_tmp = fd; fs_tmp = fs; fd_tmp2 = fd2; fs_tmp2 = fs2; } else { fd_tmp = fd2; fs_tmp = fs2; fd_tmp2 = fd; fs_tmp2 = fs; } /* WRITE on fd_tmp */ writebuf = malloc(10); if (writebuf) { memcpy (writebuf, "abcd", 4); ret = glfs_write (fd_tmp, writebuf, 4, 0); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_write", ret); } else { fprintf (stderr, "glfs_write suceeded\n"); } free(writebuf); } else { fprintf (stderr, "Could not allocate writebuf\n"); return -1; } /* READ on fd_tmp2 */ ret = glfs_lseek (fd_tmp2, 0, SEEK_SET); LOG_ERR ("glfs_lseek", ret); ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_pread", ret); } else { fprintf (stderr, "glfs_read: %s\n", readbuf); } /* Open() fops seem to be not performed on server side until * there are I/Os on that fd */ if (cnt > 2) { ret = glfs_h_poll_upcall(fs_tmp, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); if (cbk.object) { fprintf (stderr, " upcall event type - %d," " flags - %d, expire_time_attr - %d\n" , cbk.reason, cbk.flags, cbk.expire_time_attr); } else { fprintf (stderr, "Dint receive upcall notify event"); ret = -1; goto err; } } sleep(5); } while (++cnt < 5); err: glfs_close(fd); LOG_ERR ("glfs_close", ret); glfs_close(fd2); LOG_ERR ("glfs_close-fd2", ret); out: if (fs) { ret = glfs_fini(fs); fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); } if (fs2) { ret = glfs_fini(fs2); fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret); } if (ret) exit(1); exit(0); }
int main(int argc, char *argv[]) { glfs_t *fs = NULL; int ret = 0; glfs_fd_t *fd = NULL; char *filename = NULL; char *logfile = NULL; char *host = NULL; if (argc != 5) { return -1; } host = argv[2]; logfile = argv[3]; filename = argv[4]; /* setup signal handler for exiting */ signal(SIGTERM, stop_running); fs = glfs_new(argv[1]); if (!fs) { return -1; } ret = glfs_set_volfile_server(fs, "tcp", host, 24007); if (ret < 0) { return -1; } ret = glfs_set_logging(fs, logfile, 7); if (ret < 0) { return -1; } ret = glfs_init(fs); if (ret < 0) { return -1; } fd = glfs_creat(fs, filename, O_RDWR, 0644); if (!fd) { return -1; } /* sleep until SIGTERM has been received */ while (keep_running) { sleep(1); } ret = glfs_close(fd); if (ret < 0) { return -1; } ret = glfs_fini(fs); if (ret < 0) { return -1; } return 0; }