2013-11-19 23:26:05 +00:00
|
|
|
/*
|
|
|
|
* storage_backend_gluster.c: storage backend for Gluster handling
|
|
|
|
*
|
2018-04-25 09:17:13 +00:00
|
|
|
* Copyright (C) 2013-2018 Red Hat, Inc.
|
2013-11-19 23:26:05 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library. If not, see
|
|
|
|
* <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
#include <glusterfs/api/glfs.h>
|
|
|
|
|
|
|
|
#include "storage_backend_gluster.h"
|
|
|
|
#include "storage_conf.h"
|
2013-10-30 03:28:16 +00:00
|
|
|
#include "viralloc.h"
|
|
|
|
#include "virerror.h"
|
|
|
|
#include "virlog.h"
|
|
|
|
#include "virstring.h"
|
|
|
|
#include "viruri.h"
|
2017-01-11 17:04:15 +00:00
|
|
|
#include "storage_util.h"
|
2013-11-19 23:26:05 +00:00
|
|
|
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_STORAGE
|
|
|
|
|
2014-02-28 12:16:17 +00:00
|
|
|
VIR_LOG_INIT("storage.storage_backend_gluster");
|
|
|
|
|
2013-10-30 03:28:16 +00:00
|
|
|
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;
|
2017-07-26 18:23:46 +00:00
|
|
|
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
|
|
|
|
const char *name = def->source.name;
|
|
|
|
const char *dir = def->source.dir;
|
2013-10-30 03:28:16 +00:00
|
|
|
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;
|
|
|
|
|
2019-10-20 11:49:46 +00:00
|
|
|
ret->volname = g_strdup(name);
|
2019-10-22 13:26:14 +00:00
|
|
|
ret->dir = g_strdup_printf("%s%s", dir ? dir : "/", trailing_slash ? "" : "/");
|
2013-10-30 03:28:16 +00:00
|
|
|
|
|
|
|
/* FIXME: Currently hard-coded to tcp transport; XML needs to be
|
|
|
|
* extended to allow alternate transport */
|
|
|
|
if (VIR_ALLOC(ret->uri) < 0)
|
|
|
|
goto error;
|
2019-10-20 11:49:46 +00:00
|
|
|
ret->uri->scheme = g_strdup("gluster");
|
|
|
|
ret->uri->server = g_strdup(def->source.hosts[0].name);
|
2019-10-22 13:26:14 +00:00
|
|
|
ret->uri->path = g_strdup_printf("/%s%s", ret->volname, ret->dir);
|
2017-07-26 18:23:46 +00:00
|
|
|
ret->uri->port = def->source.hosts[0].port;
|
2013-10-30 03:28:16 +00:00
|
|
|
|
|
|
|
/* 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) {
|
2019-10-15 13:16:31 +00:00
|
|
|
g_autofree char *uri = NULL;
|
2019-01-31 17:09:38 +00:00
|
|
|
uri = virURIFormat(ret->uri);
|
|
|
|
virReportSystemError(errno, _("failed to connect to %s"), NULLSTR(uri));
|
2013-10-30 03:28:16 +00:00
|
|
|
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;
|
|
|
|
|
2014-03-25 06:52:40 +00:00
|
|
|
error:
|
2013-10-30 03:28:16 +00:00
|
|
|
virStorageBackendGlusterClose(ret);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-12 04:08:27 +00:00
|
|
|
static ssize_t
|
2017-05-12 11:57:25 +00:00
|
|
|
virStorageBackendGlusterRead(glfs_fd_t *fd,
|
|
|
|
const char *name,
|
|
|
|
size_t len,
|
|
|
|
char **buf)
|
2013-11-12 04:08:27 +00:00
|
|
|
{
|
|
|
|
char *s;
|
|
|
|
size_t nread = 0;
|
|
|
|
|
2017-05-12 11:57:25 +00:00
|
|
|
if (VIR_ALLOC_N(*buf, len) < 0)
|
2013-11-12 04:08:27 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
s = *buf;
|
2017-05-12 11:57:25 +00:00
|
|
|
while (len) {
|
|
|
|
ssize_t r = glfs_read(fd, s, len, 0);
|
2013-11-12 04:08:27 +00:00
|
|
|
if (r < 0 && errno == EINTR)
|
|
|
|
continue;
|
|
|
|
if (r < 0) {
|
|
|
|
VIR_FREE(*buf);
|
|
|
|
virReportSystemError(errno, _("unable to read '%s'"), name);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
if (r == 0)
|
|
|
|
return nread;
|
2014-07-01 14:54:11 +00:00
|
|
|
s += r;
|
2017-05-12 11:57:25 +00:00
|
|
|
len -= r;
|
2013-11-12 04:08:27 +00:00
|
|
|
nread += r;
|
|
|
|
}
|
|
|
|
return nread;
|
|
|
|
}
|
|
|
|
|
2014-01-29 12:17:12 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
virStorageBackendGlusterSetMetadata(virStorageBackendGlusterStatePtr state,
|
|
|
|
virStorageVolDefPtr vol,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
char *tmp;
|
2019-10-15 13:16:31 +00:00
|
|
|
g_autofree char *path = NULL;
|
2014-01-29 12:17:12 +00:00
|
|
|
|
|
|
|
VIR_FREE(vol->key);
|
|
|
|
VIR_FREE(vol->target.path);
|
|
|
|
|
|
|
|
vol->type = VIR_STORAGE_VOL_NETWORK;
|
|
|
|
vol->target.format = VIR_STORAGE_FILE_RAW;
|
|
|
|
|
|
|
|
if (name) {
|
|
|
|
VIR_FREE(vol->name);
|
2019-10-20 11:49:46 +00:00
|
|
|
vol->name = g_strdup(name);
|
2014-01-29 12:17:12 +00:00
|
|
|
}
|
|
|
|
|
2019-10-22 13:26:14 +00:00
|
|
|
path = g_strdup_printf("%s%s%s", state->volname, state->dir, vol->name);
|
2014-01-29 12:17:12 +00:00
|
|
|
|
|
|
|
tmp = state->uri->path;
|
2019-10-22 13:26:14 +00:00
|
|
|
state->uri->path = g_strdup_printf("/%s", path);
|
2014-01-29 12:17:12 +00:00
|
|
|
if (!(vol->target.path = virURIFormat(state->uri))) {
|
|
|
|
VIR_FREE(state->uri->path);
|
|
|
|
state->uri->path = tmp;
|
2019-01-31 17:09:38 +00:00
|
|
|
return -1;
|
2014-01-29 12:17:12 +00:00
|
|
|
}
|
|
|
|
VIR_FREE(state->uri->path);
|
|
|
|
state->uri->path = tmp;
|
|
|
|
|
2014-02-24 15:12:34 +00:00
|
|
|
/* the path is unique enough to serve as a volume key */
|
2019-10-20 11:49:46 +00:00
|
|
|
vol->key = g_strdup(vol->target.path);
|
2014-01-29 12:17:12 +00:00
|
|
|
|
2019-01-31 17:09:38 +00:00
|
|
|
return 0;
|
2014-01-29 12:17:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-30 03:28:16 +00:00
|
|
|
/* 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)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
2013-11-12 04:08:27 +00:00
|
|
|
glfs_fd_t *fd = NULL;
|
2017-05-12 11:57:25 +00:00
|
|
|
ssize_t len;
|
2019-10-15 12:47:50 +00:00
|
|
|
g_autoptr(virStorageVolDef) vol = NULL;
|
2019-10-15 12:47:50 +00:00
|
|
|
g_autoptr(virStorageSource) meta = NULL;
|
2019-10-15 13:16:31 +00:00
|
|
|
g_autofree char *header = NULL;
|
2013-10-30 03:28:16 +00:00
|
|
|
|
|
|
|
*volptr = NULL;
|
|
|
|
|
|
|
|
/* Silently skip '.' and '..'. */
|
|
|
|
if (STREQ(name, ".") || STREQ(name, ".."))
|
|
|
|
return 0;
|
|
|
|
|
2013-11-18 22:24:05 +00:00
|
|
|
/* Follow symlinks; silently skip broken links and loops. */
|
|
|
|
if (S_ISLNK(st->st_mode) && glfs_stat(state->vol, name, st) < 0) {
|
|
|
|
if (errno == ENOENT || errno == ELOOP) {
|
|
|
|
VIR_WARN("ignoring dangling symlink '%s'", name);
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
virReportSystemError(errno, _("cannot stat '%s'"), name);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-10-30 03:28:16 +00:00
|
|
|
if (VIR_ALLOC(vol) < 0)
|
|
|
|
goto cleanup;
|
2013-11-18 19:45:31 +00:00
|
|
|
|
2015-02-19 12:43:03 +00:00
|
|
|
if (virStorageBackendUpdateVolTargetInfoFD(&vol->target, -1, st) < 0)
|
2013-11-18 19:45:31 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2014-01-29 12:17:12 +00:00
|
|
|
if (virStorageBackendGlusterSetMetadata(state, vol, name) < 0)
|
2013-12-10 12:45:26 +00:00
|
|
|
goto cleanup;
|
2013-10-30 03:28:16 +00:00
|
|
|
|
2013-11-20 20:17:55 +00:00
|
|
|
if (S_ISDIR(st->st_mode)) {
|
|
|
|
vol->type = VIR_STORAGE_VOL_NETDIR;
|
|
|
|
vol->target.format = VIR_STORAGE_FILE_DIR;
|
2019-10-16 11:45:15 +00:00
|
|
|
*volptr = g_steal_pointer(&vol);
|
2013-11-20 20:17:55 +00:00
|
|
|
ret = 0;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2013-11-12 04:08:27 +00:00
|
|
|
/* No need to worry about O_NONBLOCK - gluster doesn't allow creation
|
|
|
|
* of fifos, so there's nothing it would protect us from. */
|
|
|
|
if (!(fd = glfs_open(state->vol, name, O_RDONLY | O_NOCTTY))) {
|
|
|
|
/* A dangling symlink now implies a TOCTTOU race; report it. */
|
|
|
|
virReportSystemError(errno, _("cannot open volume '%s'"), name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2017-05-12 11:57:25 +00:00
|
|
|
if ((len = virStorageBackendGlusterRead(fd, name, VIR_STORAGE_MAX_HEADER,
|
|
|
|
&header)) < 0)
|
2013-11-12 04:08:27 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (!(meta = virStorageFileGetMetadataFromBuf(name, header, len,
|
2020-02-21 11:41:11 +00:00
|
|
|
VIR_STORAGE_FILE_AUTO)))
|
2013-11-12 04:08:27 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2014-07-14 13:19:49 +00:00
|
|
|
if (meta->backingStoreRaw) {
|
2019-02-14 15:20:25 +00:00
|
|
|
if (!(vol->target.backingStore = virStorageSourceNew()))
|
2014-07-14 13:19:49 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2017-10-12 18:31:33 +00:00
|
|
|
vol->target.backingStore->type = VIR_STORAGE_TYPE_NETWORK;
|
|
|
|
|
2020-02-21 11:28:14 +00:00
|
|
|
vol->target.backingStore->path = g_steal_pointer(&meta->backingStoreRaw);
|
|
|
|
vol->target.backingStore->format = meta->backingStoreRawFormat;
|
2014-07-14 13:19:49 +00:00
|
|
|
|
2020-02-21 11:28:14 +00:00
|
|
|
if (vol->target.backingStore->format < 0)
|
2014-07-14 13:19:49 +00:00
|
|
|
vol->target.backingStore->format = VIR_STORAGE_FILE_RAW;
|
|
|
|
}
|
2014-07-07 09:38:28 +00:00
|
|
|
|
2014-06-05 16:47:21 +00:00
|
|
|
vol->target.format = meta->format;
|
2013-11-12 04:08:27 +00:00
|
|
|
if (meta->capacity)
|
conf: track sizes directly in source struct
One of the features of qcow2 is that a wrapper file can have
more capacity than its backing file from the guest's perspective;
what's more, sparse files make tracking allocation of both
the active and backing file worthwhile. As such, it makes
more sense to show allocation numbers for each file in a chain,
and not just the top-level file. This sets up the fields for
the tracking, although it does not modify XML to display any
new information.
* src/util/virstoragefile.h (_virStorageSource): Add fields.
* src/conf/storage_conf.h (_virStorageVolDef): Drop redundant
fields.
* src/storage/storage_backend.c (virStorageBackendCreateBlockFrom)
(createRawFile, virStorageBackendCreateQemuImgCmd)
(virStorageBackendCreateQcowCreate): Update clients.
* src/storage/storage_driver.c (storageVolDelete)
(storageVolCreateXML, storageVolCreateXMLFrom, storageVolResize)
(storageVolWipeInternal, storageVolGetInfo): Likewise.
* src/storage/storage_backend_fs.c (virStorageBackendProbeTarget)
(virStorageBackendFileSystemRefresh)
(virStorageBackendFileSystemVolResize)
(virStorageBackendFileSystemVolRefresh): Likewise.
* src/storage/storage_backend_logical.c
(virStorageBackendLogicalMakeVol)
(virStorageBackendLogicalCreateVol): Likewise.
* src/storage/storage_backend_scsi.c
(virStorageBackendSCSINewLun): Likewise.
* src/storage/storage_backend_mpath.c
(virStorageBackendMpathNewVol): Likewise.
* src/storage/storage_backend_rbd.c
(volStorageBackendRBDRefreshVolInfo)
(virStorageBackendRBDCreateImage): Likewise.
* src/storage/storage_backend_disk.c
(virStorageBackendDiskMakeDataVol)
(virStorageBackendDiskCreateVol): Likewise.
* src/storage/storage_backend_sheepdog.c
(virStorageBackendSheepdogBuildVol)
(virStorageBackendSheepdogParseVdiList): Likewise.
* src/storage/storage_backend_gluster.c
(virStorageBackendGlusterRefreshVol): Likewise.
* src/conf/storage_conf.c (virStorageVolDefFormat)
(virStorageVolDefParseXML): Likewise.
* src/test/test_driver.c (testOpenVolumesForPool)
(testStorageVolCreateXML, testStorageVolCreateXMLFrom)
(testStorageVolDelete, testStorageVolGetInfo): Likewise.
* src/esx/esx_storage_backend_iscsi.c (esxStorageVolGetXMLDesc):
Likewise.
* src/esx/esx_storage_backend_vmfs.c (esxStorageVolGetXMLDesc)
(esxStorageVolCreateXML): Likewise.
* src/parallels/parallels_driver.c (parallelsAddHddByVolume):
Likewise.
* src/parallels/parallels_storage.c (parallelsDiskDescParseNode)
(parallelsStorageVolDefineXML, parallelsStorageVolCreateXMLFrom)
(parallelsStorageVolDefRemove, parallelsStorageVolGetInfo):
Likewise.
* src/vbox/vbox_tmpl.c (vboxStorageVolCreateXML)
(vboxStorageVolGetXMLDesc): Likewise.
* tests/storagebackendsheepdogtest.c (test_vdi_list_parser):
Likewise.
* src/phyp/phyp_driver.c (phypStorageVolCreateXML): Likewise.
2014-04-01 23:43:36 +00:00
|
|
|
vol->target.capacity = meta->capacity;
|
2014-04-02 01:13:51 +00:00
|
|
|
if (meta->encryption) {
|
|
|
|
vol->target.encryption = meta->encryption;
|
|
|
|
meta->encryption = NULL;
|
2013-11-12 04:08:27 +00:00
|
|
|
}
|
|
|
|
vol->target.features = meta->features;
|
|
|
|
meta->features = NULL;
|
|
|
|
vol->target.compat = meta->compat;
|
|
|
|
meta->compat = NULL;
|
2013-10-30 03:28:16 +00:00
|
|
|
|
2019-10-16 11:45:15 +00:00
|
|
|
*volptr = g_steal_pointer(&vol);
|
2013-10-30 03:28:16 +00:00
|
|
|
ret = 0;
|
2014-03-25 06:52:40 +00:00
|
|
|
cleanup:
|
2013-11-12 04:08:27 +00:00
|
|
|
if (fd)
|
|
|
|
glfs_close(fd);
|
2013-10-30 03:28:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2013-11-19 23:26:05 +00:00
|
|
|
|
|
|
|
static int
|
2018-01-26 13:31:58 +00:00
|
|
|
virStorageBackendGlusterRefreshPool(virStoragePoolObjPtr pool)
|
2013-11-19 23:26:05 +00:00
|
|
|
{
|
2013-10-30 03:28:16 +00:00
|
|
|
int ret = -1;
|
2017-07-26 18:23:46 +00:00
|
|
|
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
|
2013-10-30 03:28:16 +00:00
|
|
|
virStorageBackendGlusterStatePtr state = NULL;
|
|
|
|
struct {
|
|
|
|
struct dirent ent;
|
|
|
|
/* See comment below about readdir_r needing padding */
|
2018-04-25 12:42:34 +00:00
|
|
|
char padding[MAX(1, 256 - (int)(sizeof(struct dirent)
|
2013-10-30 03:28:16 +00:00
|
|
|
- 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
|
2020-08-25 22:44:00 +00:00
|
|
|
* NAME_MAX: https://austingroupbugs.net/view.php?id=696
|
|
|
|
* https://womble.decadent.org.uk/readdir_r-advisory.html
|
2013-10-30 03:28:16 +00:00
|
|
|
*
|
|
|
|
* 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'.
|
2020-08-25 22:44:00 +00:00
|
|
|
* https://lists.gnu.org/archive/html/gluster-devel/2013-10/msg00083.html
|
2013-10-30 03:28:16 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
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;
|
2017-05-09 12:05:16 +00:00
|
|
|
if (vol && virStoragePoolObjAddVol(pool, vol) < 0)
|
2013-10-30 03:28:16 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-07-26 18:23:46 +00:00
|
|
|
def->capacity = ((unsigned long long)sb.f_frsize *
|
|
|
|
(unsigned long long)sb.f_blocks);
|
|
|
|
def->available = ((unsigned long long)sb.f_bfree *
|
|
|
|
(unsigned long long)sb.f_frsize);
|
|
|
|
def->allocation = def->capacity - def->available;
|
2013-10-30 03:28:16 +00:00
|
|
|
|
|
|
|
ret = 0;
|
2014-03-25 06:52:40 +00:00
|
|
|
cleanup:
|
2013-10-30 03:28:16 +00:00
|
|
|
if (dir)
|
|
|
|
glfs_closedir(dir);
|
|
|
|
virStorageBackendGlusterClose(state);
|
|
|
|
return ret;
|
2013-11-19 23:26:05 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 10:38:28 +00:00
|
|
|
|
|
|
|
static int
|
2018-01-26 13:31:58 +00:00
|
|
|
virStorageBackendGlusterVolDelete(virStoragePoolObjPtr pool,
|
2013-12-11 10:38:28 +00:00
|
|
|
virStorageVolDefPtr vol,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
virStorageBackendGlusterStatePtr state = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
virCheckFlags(0, -1);
|
|
|
|
|
2018-04-25 12:42:34 +00:00
|
|
|
switch ((virStorageVolType)vol->type) {
|
2013-12-11 10:38:28 +00:00
|
|
|
case VIR_STORAGE_VOL_FILE:
|
|
|
|
case VIR_STORAGE_VOL_DIR:
|
|
|
|
case VIR_STORAGE_VOL_BLOCK:
|
2016-04-15 16:05:37 +00:00
|
|
|
case VIR_STORAGE_VOL_PLOOP:
|
2013-12-11 10:38:28 +00:00
|
|
|
case VIR_STORAGE_VOL_LAST:
|
|
|
|
virReportError(VIR_ERR_NO_SUPPORT,
|
|
|
|
_("removing of '%s' volumes is not supported "
|
|
|
|
"by the gluster backend: %s"),
|
|
|
|
virStorageVolTypeToString(vol->type),
|
|
|
|
vol->target.path);
|
|
|
|
goto cleanup;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_STORAGE_VOL_NETWORK:
|
|
|
|
if (!(state = virStorageBackendGlusterOpen(pool)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (glfs_unlink(state->vol, vol->name) < 0) {
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("cannot remove gluster volume file '%s'"),
|
|
|
|
vol->target.path);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_STORAGE_VOL_NETDIR:
|
|
|
|
if (!(state = virStorageBackendGlusterOpen(pool)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (glfs_rmdir(state->vol, vol->target.path) < 0) {
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("cannot remove gluster volume dir '%s'"),
|
|
|
|
vol->target.path);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2014-03-25 06:52:40 +00:00
|
|
|
cleanup:
|
2013-12-11 10:38:28 +00:00
|
|
|
virStorageBackendGlusterClose(state);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-03-27 12:39:51 +00:00
|
|
|
static char *
|
2018-01-26 13:31:58 +00:00
|
|
|
virStorageBackendGlusterFindPoolSources(const char *srcSpec,
|
2014-03-27 12:39:51 +00:00
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
virStoragePoolSourceList list = { .type = VIR_STORAGE_POOL_GLUSTER,
|
|
|
|
.nsources = 0,
|
|
|
|
.sources = NULL
|
|
|
|
};
|
|
|
|
char *ret = NULL;
|
2017-01-10 17:35:03 +00:00
|
|
|
int rc;
|
2014-03-27 12:39:51 +00:00
|
|
|
size_t i;
|
2019-10-15 12:47:50 +00:00
|
|
|
g_autoptr(virStoragePoolSource) source = NULL;
|
2014-03-27 12:39:51 +00:00
|
|
|
|
|
|
|
virCheckFlags(0, NULL);
|
|
|
|
|
|
|
|
if (!srcSpec) {
|
|
|
|
virReportError(VIR_ERR_INVALID_ARG, "%s",
|
|
|
|
_("hostname must be specified for gluster sources"));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(source = virStoragePoolDefParseSourceString(srcSpec,
|
|
|
|
VIR_STORAGE_POOL_GLUSTER)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (source->nhost != 1) {
|
|
|
|
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
|
|
|
|
_("Expected exactly 1 host for the storage pool"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2017-01-10 17:35:03 +00:00
|
|
|
if ((rc = virStorageBackendFindGlusterPoolSources(source->hosts[0].name,
|
2017-03-30 13:08:06 +00:00
|
|
|
VIR_STORAGE_POOL_GLUSTER,
|
2017-01-09 14:56:12 +00:00
|
|
|
&list, true)) < 0)
|
2014-03-27 12:39:51 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2017-01-10 17:35:03 +00:00
|
|
|
if (rc == 0) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("no storage pools were found on host '%s'"),
|
|
|
|
source->hosts[0].name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2014-03-27 12:39:51 +00:00
|
|
|
if (!(ret = virStoragePoolSourceListFormat(&list)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
for (i = 0; i < list.nsources; i++)
|
|
|
|
virStoragePoolSourceClear(&list.sources[i]);
|
|
|
|
VIR_FREE(list.sources);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-03-30 11:18:43 +00:00
|
|
|
static int
|
|
|
|
virStorageBackendGlusterCheckPool(virStoragePoolObjPtr pool,
|
|
|
|
bool *active)
|
|
|
|
{
|
|
|
|
/* Return previous state remembered by the status XML. If the pool is not
|
|
|
|
* available we will fail to refresh it and end up in the same situation.
|
|
|
|
* This will save one attempt to open the connection to the remote server */
|
2017-07-26 16:15:42 +00:00
|
|
|
*active = virStoragePoolObjIsActive(pool);
|
2017-03-30 11:18:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-19 23:26:05 +00:00
|
|
|
virStorageBackend virStorageBackendGluster = {
|
|
|
|
.type = VIR_STORAGE_POOL_GLUSTER,
|
|
|
|
|
2017-03-30 11:18:43 +00:00
|
|
|
.checkPool = virStorageBackendGlusterCheckPool,
|
2013-11-19 23:26:05 +00:00
|
|
|
.refreshPool = virStorageBackendGlusterRefreshPool,
|
2014-03-27 12:39:51 +00:00
|
|
|
.findPoolSources = virStorageBackendGlusterFindPoolSources,
|
2013-12-11 10:38:28 +00:00
|
|
|
|
|
|
|
.deleteVol = virStorageBackendGlusterVolDelete,
|
2013-11-19 23:26:05 +00:00
|
|
|
};
|
2014-02-03 16:18:24 +00:00
|
|
|
|
|
|
|
|
2017-01-13 15:50:11 +00:00
|
|
|
int
|
|
|
|
virStorageBackendGlusterRegister(void)
|
|
|
|
{
|
|
|
|
if (virStorageBackendRegister(&virStorageBackendGluster) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|