From fc0de008b808886ff8800527298d100adfcc14f4 Mon Sep 17 00:00:00 2001 Message-Id: From: Eric Blake Date: Wed, 26 Feb 2014 14:54:23 +0100 Subject: [PATCH] storage: implement rudimentary glusterfs pool refresh https://bugzilla.redhat.com/show_bug.cgi?id=1032370 Actually put gfapi to use, by allowing the creation of a gluster pool. Right now, all volumes are treated as raw and directories are skipped; further patches will allow peering into files to allow for qcow2 files and backing chains, and reporting proper volume allocation. This implementation was tested against Fedora 19's glusterfs 3.4.1; it might be made simpler by requiring a higher minimum, and/or require more hacks to work with a lower minimum. * src/storage/storage_backend_gluster.c (virStorageBackendGlusterRefreshPool): Initial implementation. (virStorageBackendGlusterOpen, virStorageBackendGlusterClose) (virStorageBackendGlusterRefreshVol): New helper functions. Signed-off-by: Eric Blake (cherry picked from commit efee1af54ad58e7147442714b2baa560814f94be) Signed-off-by: Jiri Denemark --- src/storage/storage_backend_gluster.c | 249 +++++++++++++++++++++++++++++++++- 1 file changed, 244 insertions(+), 5 deletions(-) diff --git a/src/storage/storage_backend_gluster.c b/src/storage/storage_backend_gluster.c index 2863c73..d57427e 100644 --- a/src/storage/storage_backend_gluster.c +++ b/src/storage/storage_backend_gluster.c @@ -23,20 +23,259 @@ #include -#include "virerror.h" #include "storage_backend_gluster.h" #include "storage_conf.h" +#include "viralloc.h" +#include "virerror.h" +#include "virlog.h" +#include "virstoragefile.h" +#include "virstring.h" +#include "viruri.h" #define VIR_FROM_THIS VIR_FROM_STORAGE +struct _virStorageBackendGlusterState { + glfs_t *vol; + + /* Accept the same URIs as qemu's block/gluster.c: + * gluster[+transport]://[server[:port]]/vol/[dir/]image[?socket=...] */ + virURI *uri; + + char *volname; /* vol from URI, no '/' */ + char *dir; /* dir from URI, or "/"; always starts and ends in '/' */ +}; + +typedef struct _virStorageBackendGlusterState virStorageBackendGlusterState; +typedef virStorageBackendGlusterState *virStorageBackendGlusterStatePtr; + +static void +virStorageBackendGlusterClose(virStorageBackendGlusterStatePtr state) +{ + if (!state) + return; + + /* Yuck - glusterfs-api-3.4.1 appears to always return -1 for + * glfs_fini, with errno containing random data, so there's no way + * to tell if it succeeded. 3.4.2 is supposed to fix this.*/ + if (state->vol && glfs_fini(state->vol) < 0) + VIR_DEBUG("shutdown of gluster volume %s failed with errno %d", + state->volname, errno); + + virURIFree(state->uri); + VIR_FREE(state->volname); + VIR_FREE(state->dir); + VIR_FREE(state); +} + +static virStorageBackendGlusterStatePtr +virStorageBackendGlusterOpen(virStoragePoolObjPtr pool) +{ + virStorageBackendGlusterStatePtr ret = NULL; + const char *name = pool->def->source.name; + const char *dir = pool->def->source.dir; + bool trailing_slash = true; + + /* Volume name must not contain '/'; optional path allows use of a + * subdirectory within the volume name. */ + if (strchr(name, '/')) { + virReportError(VIR_ERR_XML_ERROR, + _("gluster pool name '%s' must not contain /"), + name); + return NULL; + } + if (dir) { + if (*dir != '/') { + virReportError(VIR_ERR_XML_ERROR, + _("gluster pool path '%s' must start with /"), + dir); + return NULL; + } + if (strchr(dir, '\0')[-1] != '/') + trailing_slash = false; + } + + if (VIR_ALLOC(ret) < 0) + return NULL; + + if (VIR_STRDUP(ret->volname, name) < 0) + goto error; + if (virAsprintf(&ret->dir, "%s%s", dir ? dir : "/", + trailing_slash ? "" : "/") < 0) + goto error; + + /* FIXME: Currently hard-coded to tcp transport; XML needs to be + * extended to allow alternate transport */ + if (VIR_ALLOC(ret->uri) < 0) + goto error; + if (VIR_STRDUP(ret->uri->scheme, "gluster") < 0) + goto error; + if (VIR_STRDUP(ret->uri->server, pool->def->source.hosts[0].name) < 0) + goto error; + if (virAsprintf(&ret->uri->path, "/%s%s", ret->volname, ret->dir) < 0) + goto error; + ret->uri->port = pool->def->source.hosts[0].port; + + /* Actually connect to glfs */ + if (!(ret->vol = glfs_new(ret->volname))) { + virReportOOMError(); + goto error; + } + + if (glfs_set_volfile_server(ret->vol, "tcp", + ret->uri->server, ret->uri->port) < 0 || + glfs_init(ret->vol) < 0) { + char *uri = virURIFormat(ret->uri); + + virReportSystemError(errno, _("failed to connect to %s"), + NULLSTR(uri)); + VIR_FREE(uri); + goto error; + } + + if (glfs_chdir(ret->vol, ret->dir) < 0) { + virReportSystemError(errno, + _("failed to change to directory '%s' in '%s'"), + ret->dir, ret->volname); + goto error; + } + + return ret; + +error: + virStorageBackendGlusterClose(ret); + return NULL; +} + + +/* Populate *volptr for the given name and stat information, or leave + * it NULL if the entry should be skipped (such as "."). Return 0 on + * success, -1 on failure. */ +static int +virStorageBackendGlusterRefreshVol(virStorageBackendGlusterStatePtr state, + const char *name, + struct stat *st, + virStorageVolDefPtr *volptr) +{ + char *tmp; + int ret = -1; + virStorageVolDefPtr vol = NULL; + + *volptr = NULL; + + /* Silently skip '.' and '..'. */ + if (STREQ(name, ".") || STREQ(name, "..")) + return 0; + /* FIXME: support directories. For now, silently skip them. */ + if (S_ISDIR(st->st_mode)) + return 0; + + if (VIR_ALLOC(vol) < 0) + goto cleanup; + if (VIR_STRDUP(vol->name, name) < 0) + goto cleanup; + if (virAsprintf(&vol->key, "%s%s%s", state->volname, state->dir, + vol->name) < 0) + goto cleanup; + + vol->type = VIR_STORAGE_VOL_NETWORK; + tmp = state->uri->path; + state->uri->path = vol->key; + if (!(vol->target.path = virURIFormat(state->uri))) { + state->uri->path = tmp; + goto cleanup; + } + state->uri->path = tmp; + + /* FIXME - must open files to determine if they are non-raw */ + vol->target.format = VIR_STORAGE_FILE_RAW; + vol->capacity = vol->allocation = st->st_size; + + *volptr = vol; + vol = NULL; + ret = 0; +cleanup: + virStorageVolDefFree(vol); + return ret; +} static int virStorageBackendGlusterRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED, - virStoragePoolObjPtr pool ATTRIBUTE_UNUSED) + virStoragePoolObjPtr pool) { - virReportError(VIR_ERR_NO_SUPPORT, "%s", - _("gluster pool type not fully supported yet")); - return -1; + int ret = -1; + virStorageBackendGlusterStatePtr state = NULL; + struct { + struct dirent ent; + /* See comment below about readdir_r needing padding */ + char padding[MAX(1, 256 - (int) (sizeof(struct dirent) + - offsetof(struct dirent, d_name)))]; + } de; + struct dirent *ent; + glfs_fd_t *dir = NULL; + struct stat st; + struct statvfs sb; + + if (!(state = virStorageBackendGlusterOpen(pool))) + goto cleanup; + + /* Why oh why did glfs 3.4 decide to expose only readdir_r rather + * than readdir? POSIX admits that readdir_r is inherently a + * flawed design, because systems are not required to define + * NAME_MAX: http://austingroupbugs.net/view.php?id=696 + * http://womble.decadent.org.uk/readdir_r-advisory.html + * + * Fortunately, gluster appears to limit its underlying bricks to + * only use file systems such as XFS that have a NAME_MAX of 255; + * so we are currently guaranteed that if we provide 256 bytes of + * tail padding, then we should have enough space to avoid buffer + * overflow no matter whether the OS used d_name[], d_name[1], or + * d_name[256] in its 'struct dirent'. + * http://lists.gnu.org/archive/html/gluster-devel/2013-10/msg00083.html + */ + + if (!(dir = glfs_opendir(state->vol, state->dir))) { + virReportSystemError(errno, _("cannot open path '%s' in '%s'"), + state->dir, state->volname); + goto cleanup; + } + while (!(errno = glfs_readdirplus_r(dir, &st, &de.ent, &ent)) && ent) { + virStorageVolDefPtr vol; + int okay = virStorageBackendGlusterRefreshVol(state, + ent->d_name, &st, + &vol); + + if (okay < 0) + goto cleanup; + if (vol && VIR_APPEND_ELEMENT(pool->volumes.objs, pool->volumes.count, + vol) < 0) + goto cleanup; + } + if (errno) { + virReportSystemError(errno, _("failed to read directory '%s' in '%s'"), + state->dir, state->volname); + goto cleanup; + } + + if (glfs_statvfs(state->vol, state->dir, &sb) < 0) { + virReportSystemError(errno, _("cannot statvfs path '%s' in '%s'"), + state->dir, state->volname); + goto cleanup; + } + + pool->def->capacity = ((unsigned long long)sb.f_frsize * + (unsigned long long)sb.f_blocks); + pool->def->available = ((unsigned long long)sb.f_bfree * + (unsigned long long)sb.f_frsize); + pool->def->allocation = pool->def->capacity - pool->def->available; + + ret = 0; +cleanup: + if (dir) + glfs_closedir(dir); + virStorageBackendGlusterClose(state); + if (ret < 0) + virStoragePoolObjClearVols(pool); + return ret; } virStorageBackend virStorageBackendGluster = { -- 1.9.0