bool gfapi_device::d_truncate(DCR *dcr)
{
struct stat st;
if (m_gfd) {
if (glfs_ftruncate(m_gfd, 0) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
print_name(), be.bstrerror());
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/*
* Check for a successful glfs_truncate() and issue work-around when truncation doesn't work.
*
* 1. close file
* 2. delete file
* 3. open new file with same mode
* 4. change ownership to original
*/
if (glfs_fstat(m_gfd, &st) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"), print_name(), be.bstrerror());
return false;
}
if (st.st_size != 0) { /* glfs_truncate() didn't work */
glfs_close(m_gfd);
glfs_unlink(m_glfs, getVolCatName());
set_mode(CREATE_READ_WRITE);
/*
* Recreate the file -- of course, empty
*/
m_gfd = glfs_creat(m_glfs, getVolCatName(), oflags, st.st_mode);
if (!m_gfd) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), getVolCatName(), be.bstrerror());
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/*
* Reset proper owner
*/
glfs_chown(m_glfs, getVolCatName(), st.st_uid, st.st_gid);
}
}
return true;
}
static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs)
{
BDRVGlusterState *s = bs->opaque;
struct stat st;
int ret;
ret = glfs_fstat(s->fd, &st);
if (ret < 0) {
return -errno;
} else {
return st.st_blocks * 512;
}
}
int xglfs_fgetattr(const char* _path, struct stat* _statbuf, struct fuse_file_info* _info)
{
int ret = 0;
if (!strcmp(_path, "/"))
ret = xglfs_getattr(_path, _statbuf);
else
{
ret = glfs_fstat(FH_TO_FD(_info->fh), _statbuf);
if (unlikely(ret < 0))
ret = -errno;
}
return ret;
}
static fsal_status_t getattrs(struct fsal_obj_handle *obj_hdl,
const struct req_op_context *opctx)
{
int rc = 0;
fsal_status_t status = { ERR_FSAL_NO_ERROR, 0 };
struct stat sb;
struct glusterfs_export *glfs_export =
container_of(obj_hdl->export, struct glusterfs_export, export);
struct glusterfs_handle *objhandle =
container_of(obj_hdl, struct glusterfs_handle, handle);
#ifdef GLTIMING
struct timespec s_time, e_time;
now(&s_time);
#endif
/* FIXME: Should we hold the fd so that any async op does
* not close it */
if (objhandle->openflags != FSAL_O_CLOSED) {
rc = glfs_fstat(objhandle->glfd, &sb);
} else {
rc = glfs_h_stat(glfs_export->gl_fs, objhandle->glhandle, &sb);
}
if (rc != 0) {
if (errno == ENOENT)
status = gluster2fsal_error(ESTALE);
else
status = gluster2fsal_error(errno);
goto out;
}
stat2fsal_attributes(&sb, &objhandle->handle.attributes);
out:
#ifdef GLTIMING
now(&e_time);
latency_update(&s_time, &e_time, lat_getattrs);
#endif
return status;
}
static int uwsgi_glusterfs_request(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX+1];
/* Standard GlusterFS request */
if (!wsgi_req->uh->pktsize) {
uwsgi_log( "Empty GlusterFS request. skip.\n");
return -1;
}
if (uwsgi_parse_vars(wsgi_req)) {
return -1;
}
// blocks empty paths
if (wsgi_req->path_info_len == 0 || wsgi_req->path_info_len > PATH_MAX) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
wsgi_req->app_id = uwsgi_get_app_id(wsgi_req, wsgi_req->appid, wsgi_req->appid_len, glusterfs_plugin.modifier1);
if (wsgi_req->app_id == -1 && !uwsgi.no_default_app && uwsgi.default_app > -1) {
if (uwsgi_apps[uwsgi.default_app].modifier1 == glusterfs_plugin.modifier1) {
wsgi_req->app_id = uwsgi.default_app;
}
}
if (wsgi_req->app_id == -1) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct uwsgi_app *ua = &uwsgi_apps[wsgi_req->app_id];
memcpy(filename, wsgi_req->path_info, wsgi_req->path_info_len);
filename[wsgi_req->path_info_len] = 0;
glfs_fd_t *fd = glfs_open((glfs_t *) ua->interpreter, filename, O_RDONLY);
if (!fd) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct stat st;
if (glfs_fstat(fd, &st)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(wsgi_req->path_info, wsgi_req->path_info_len, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end;
}
if (uwsgi_response_add_last_modified(wsgi_req, (uint64_t) st.st_mtime)) goto end;
if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end;
// skip body on HEAD
if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4)) {
size_t remains = st.st_size;
while(remains > 0) {
char buf[8192];
ssize_t rlen = glfs_read (fd, buf, UMIN(remains, 8192), 0);
if (rlen <= 0) goto end;
if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) goto end;
remains -= rlen;
}
}
end:
glfs_close(fd);
return UWSGI_OK;
}
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;
}
