int write_something (glfs_t *fs) { glfs_fd_t *fd = NULL; char *buf = NULL; int ret = 0; int j = 0; fd = glfs_creat (fs, "filename", O_RDWR, 0644); if (!fd) { fprintf (stderr, "%s: (%p) %s\n", "filename", fd, strerror (errno)); return -1; } buf = (char *) malloc (WRITE_SIZE); memset (buf, '-', WRITE_SIZE); for (j = 0; j < 4; j++) { ret = glfs_write (fd, buf, WRITE_SIZE, 0); if (ret < 0) { fprintf (stderr, "Write(%s): %d (%s)\n", "filename", ret, strerror (errno)); return ret; } glfs_lseek (fd, 0, SEEK_SET); } return 0; }
/* * Write data to a volume using gfapi. */ ssize_t gfapi_device::d_write(int fd, const void *buffer, size_t count) { if (m_gfd) { return glfs_write(m_gfd, buffer, count, 0); } else { errno = EBADF; 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 glfs_test_function (const char *hostname, const char *volname, const char *logfile) { int ret = -1; int flags = O_CREAT | O_RDWR; glfs_t *fs = NULL; glfs_fd_t *glfd = NULL; const char *buff = "This is from my prog\n"; const char *filename = "glfs_test.txt"; fs = init_glfs (hostname, volname, logfile); if (fs == NULL) { LOG_ERR ("init_glfs failed"); return -1; } glfd = glfs_creat (fs, filename, flags, 0644); if (glfd == NULL) { LOG_ERR ("glfs_creat failed"); goto out; } ret = glfs_write (glfd, buff, strlen (buff), flags); if (ret < 0) { LOG_ERR ("glfs_write failed"); goto out; } ret = glfs_close (glfd); if (ret < 0) { LOG_ERR ("glfs_write failed"); goto out; } out: ret = glfs_fini (fs); if (ret) { LOG_ERR ("glfs_fini failed"); } return ret; }
static int fio_gf_queue(struct thread_data *td, struct io_u *io_u) { struct gf_data *g = td->io_ops_data; int ret = 0; dprint(FD_FILE, "fio queue len %lu\n", io_u->xfer_buflen); fio_ro_check(td, io_u); if (io_u->ddir == DDIR_READ) ret = glfs_read(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0); else if (io_u->ddir == DDIR_WRITE) ret = glfs_write(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0); else if (io_u->ddir == DDIR_SYNC) ret = glfs_fsync(g->fd); else if (io_u->ddir == DDIR_DATASYNC) ret = glfs_fdatasync(g->fd); else { log_err("unsupported operation.\n"); return -EINVAL; } dprint(FD_FILE, "fio len %lu ret %d\n", io_u->xfer_buflen, ret); if (io_u->file && ret >= 0 && ddir_rw(io_u->ddir)) LAST_POS(io_u->file) = io_u->offset + ret; if (ret != (int)io_u->xfer_buflen) { if (ret >= 0) { io_u->resid = io_u->xfer_buflen - ret; io_u->error = 0; return FIO_Q_COMPLETED; } else io_u->error = errno; } if (io_u->error) { log_err("IO failed.\n"); td_verror(td, io_u->error, "xfer"); } return FIO_Q_COMPLETED; }
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; }
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); }
long glfs_java_write (glfs_fd_t *glfd, b_array *io_data, size_t size) { return glfs_write (glfd, io_data, size, 0); }
static int large_read_write (glfs_t *fs) { int ret = 0; int j = 0; glfs_fd_t *fd = NULL; glfs_fd_t *fd1 = NULL; char *filename = NULL; char *buf = NULL; ret = asprintf (&filename, "filerw%d", extension); if (ret < 0) { fprintf (stderr, "cannot construct filename (%s)", strerror (errno)); return ret; } extension++; fd = glfs_creat (fs, filename, O_RDWR, 0644); if (!fd) { fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno)); return -1; } buf = (char *) malloc (WRITE_SIZE); memset (buf, '-', WRITE_SIZE); for (j = 0; j < READ_WRITE_LOOP; j++) { ret = glfs_write (fd, buf, WRITE_SIZE, 0); if (ret < 0) { fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret, strerror (errno)); return ret; } } fd1 = glfs_open (fs, filename, O_RDWR); if (fd1 < 0) { fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret, strerror (errno)); return -1; } glfs_lseek (fd1, 0, SEEK_SET); for (j = 0; j < READ_WRITE_LOOP; j++) { ret = glfs_read (fd1, buf, WRITE_SIZE, 0); if (ret < 0) { fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret, strerror (errno)); return ret; } } for (j = 0; j < READ_WRITE_LOOP; j++) { ret = glfs_write (fd1, buf, WRITE_SIZE, 0); if (ret < 0) { fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret, strerror (errno)); return ret; } } glfs_close (fd); glfs_close (fd1); ret = glfs_unlink (fs, filename); if (ret < 0) { fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n", ret, strerror (errno)); return -1; } free (buf); free (filename); }
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; }
bool GlusterBackend::put(const SyncEvent* _putEvent) { if(_putEvent == nullptr || _putEvent->fullPathBuffer.empty()) return false; FileNode* node = FileSystem::getInstance().findAndOpenNode(_putEvent->fullPathBuffer); if(node == nullptr){ LOG(ERROR)<<_putEvent->fullPathBuffer<<" Does not exist! So can't upload it."; return false; } uint64_t inodeNum = FileSystem::getInstance().assignINodeNum((intptr_t)node); //Double check if not already uploaded if(node->flushed()){ node->close(inodeNum); return true; } //CheckEvent validity if(!UploadQueue::getInstance().checkEventValidity(*_putEvent)) { //release file delete lock, so they can delete it node->close(inodeNum); return true;//going to be deletes so anyway say it's synced! } if(node->mustBeDeleted()){ node->close(inodeNum); return true; } //Create necessary directories //Traverse FileSystem Hierarchies Poco::StringTokenizer tokenizer(_putEvent->fullPathBuffer, FileSystem::delimiter,Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY); //Nested directories if(tokenizer.count()>=2){ for(unsigned int i=0;i<tokenizer.count()-1;i++){ string path = FileSystem::delimiter; for(unsigned int j=0;j<=i;j++){ path += tokenizer[j]; path += FileSystem::delimiter; } if(!createDirectory(path.c_str())){ LOG(ERROR)<<"Failed to create parent directory("<<tokenizer[i]<<") for:"<<_putEvent->fullPathBuffer; node->close(inodeNum); return false; } } } //Create the file! (overwrite or create) glfs_fd_t *fd = glfs_creat((glfs_t*)fs, _putEvent->fullPathBuffer.c_str(), O_RDWR, 0644); //glfs_fd_t *fd = glfs_open(,O_RDWR| O_CREAT | O_TRUNC); if(!fd){ LOG(ERROR)<<"Error in creating file:"<<_putEvent->fullPathBuffer<<" in GlusterFS. errno:"<<errno; return false; } //Ready to write (write each time a blocksize) uint64_t buffSize = 1024ll*1024ll*10ll; char *buff = new char[buffSize];//10MB buffer size_t offset = 0; long read = 0; //FileNode *node = _putEvent->node; do { //CheckEvent validity if(!UploadQueue::getInstance().checkEventValidity(*_putEvent)){ glfs_close(fd); delete []buff; buff = nullptr; node->close(inodeNum); return true; } if(node->mustBeDeleted()){//Check Delete glfs_close(fd); delete []buff; buff = nullptr; node->close(inodeNum); return true; } //get lock delete so file won't be deleted read = node->read(buff,offset,buffSize); offset += read; int64_t written = glfs_write(fd,buff,read,0); if(written!=read){ LOG(ERROR)<<"Error while writing to:"<<_putEvent->fullPathBuffer<< ". Asked to write:"<<read<<" but wrote:"<<written; glfs_close(fd); return false; } } while(read > 0); delete []buff; buff = nullptr; if(node->mustBeDeleted()){//Check Delete glfs_close(fd); node->close(inodeNum); return true; } //Now sync if(glfs_close(fd)!=0){ LOG(ERROR)<<"Error in closing:"<<_putEvent->fullPathBuffer<<" errorNo:"<<errno; node->close(inodeNum); return false; } node->close(inodeNum); return true; }
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); }