mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-09-24 08:25:45 +00:00
e57aaa6fcf
There are a number of places which generate cast alignment warnings, which are difficult or impossible to address. Use pragmas to disable the warnings in these few places conf/nwfilter_conf.c: In function 'virNWFilterRuleDetailsParse': conf/nwfilter_conf.c:1806:16: warning: cast increases required alignment of target type [-Wcast-align] item = (nwItemDesc *)((char *)nwf + att[idx].dataIdx); conf/nwfilter_conf.c: In function 'virNWFilterRuleDefDetailsFormat': conf/nwfilter_conf.c:3238:16: warning: cast increases required alignment of target type [-Wcast-align] item = (nwItemDesc *)((char *)def + att[i].dataIdx); storage/storage_backend_mpath.c: In function 'virStorageBackendCreateVols': storage/storage_backend_mpath.c:247:17: warning: cast increases required alignment of target type [-Wcast-align] names = (struct dm_names *)(((char *)names) + next); nwfilter/nwfilter_dhcpsnoop.c: In function 'virNWFilterSnoopDHCPDecode': nwfilter/nwfilter_dhcpsnoop.c:994:15: warning: cast increases required alignment of target type [-Wcast-align] pip = (struct iphdr *) pep->eh_data; nwfilter/nwfilter_dhcpsnoop.c:1004:11: warning: cast increases required alignment of target type [-Wcast-align] pup = (struct udphdr *) ((char *) pip + (pip->ihl << 2)); nwfilter/nwfilter_learnipaddr.c: In function 'procDHCPOpts': nwfilter/nwfilter_learnipaddr.c:327:33: warning: cast increases required alignment of target type [-Wcast-align] uint32_t *tmp = (uint32_t *)&dhcpopt->value; nwfilter/nwfilter_learnipaddr.c: In function 'learnIPAddressThread': nwfilter/nwfilter_learnipaddr.c:501:43: warning: cast increases required alignment of target type [-Wcast-align] struct iphdr *iphdr = (struct iphdr*)(packet + nwfilter/nwfilter_learnipaddr.c:538:43: warning: cast increases required alignment of target type [-Wcast-align] struct iphdr *iphdr = (struct iphdr*)(packet + nwfilter/nwfilter_learnipaddr.c:544:48: warning: cast increases required alignment of target type [-Wcast-align] struct udphdr *udphdr= (struct udphdr *) Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
338 lines
7.4 KiB
C
338 lines
7.4 KiB
C
/*
|
|
* storage_backend_mpath.c: storage backend for multipath handling
|
|
*
|
|
* Copyright (C) 2009-2011 Red Hat, Inc.
|
|
* Copyright (C) 2009-2008 Dave Allan
|
|
*
|
|
* 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/>.
|
|
*
|
|
* Author: Dave Allan <dallan@redhat.com>
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <libdevmapper.h>
|
|
|
|
#include "virerror.h"
|
|
#include "storage_conf.h"
|
|
#include "storage_backend.h"
|
|
#include "viralloc.h"
|
|
#include "virlog.h"
|
|
#include "virfile.h"
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_STORAGE
|
|
|
|
static int
|
|
virStorageBackendMpathUpdateVolTargetInfo(virStorageVolTargetPtr target,
|
|
unsigned long long *allocation,
|
|
unsigned long long *capacity)
|
|
{
|
|
int ret = -1;
|
|
int fdret, fd = -1;
|
|
|
|
if ((fdret = virStorageBackendVolOpen(target->path)) < 0)
|
|
goto out;
|
|
fd = fdret;
|
|
|
|
if (virStorageBackendUpdateVolTargetInfoFD(target,
|
|
fd,
|
|
allocation,
|
|
capacity) < 0)
|
|
goto out;
|
|
|
|
if (virStorageBackendDetectBlockVolFormatFD(target, fd) < 0)
|
|
goto out;
|
|
|
|
ret = 0;
|
|
out:
|
|
VIR_FORCE_CLOSE(fd);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int
|
|
virStorageBackendMpathNewVol(virStoragePoolObjPtr pool,
|
|
const int devnum,
|
|
const char *dev)
|
|
{
|
|
virStorageVolDefPtr vol;
|
|
int ret = -1;
|
|
|
|
if (VIR_ALLOC(vol) < 0) {
|
|
virReportOOMError();
|
|
goto cleanup;
|
|
}
|
|
|
|
vol->type = VIR_STORAGE_VOL_BLOCK;
|
|
|
|
if (virAsprintf(&(vol->name), "dm-%u", devnum) < 0) {
|
|
virReportOOMError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virAsprintf(&vol->target.path, "/dev/%s", dev) < 0) {
|
|
virReportOOMError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virStorageBackendMpathUpdateVolTargetInfo(&vol->target,
|
|
&vol->allocation,
|
|
&vol->capacity) < 0) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* XXX should use logical unit's UUID instead */
|
|
vol->key = strdup(vol->target.path);
|
|
if (vol->key == NULL) {
|
|
virReportOOMError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (VIR_REALLOC_N(pool->volumes.objs,
|
|
pool->volumes.count + 1) < 0) {
|
|
virReportOOMError();
|
|
goto cleanup;
|
|
}
|
|
pool->volumes.objs[pool->volumes.count++] = vol;
|
|
pool->def->capacity += vol->capacity;
|
|
pool->def->allocation += vol->allocation;
|
|
ret = 0;
|
|
|
|
cleanup:
|
|
|
|
if (ret != 0)
|
|
virStorageVolDefFree(vol);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int
|
|
virStorageBackendIsMultipath(const char *dev_name)
|
|
{
|
|
int ret = 0;
|
|
struct dm_task *dmt = NULL;
|
|
void *next = NULL;
|
|
uint64_t start, length;
|
|
char *target_type = NULL;
|
|
char *params = NULL;
|
|
|
|
dmt = dm_task_create(DM_DEVICE_TABLE);
|
|
if (dmt == NULL) {
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
if (dm_task_set_name(dmt, dev_name) == 0) {
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
dm_task_no_open_count(dmt);
|
|
|
|
if (!dm_task_run(dmt)) {
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
dm_get_next_target(dmt, next, &start, &length, &target_type, ¶ms);
|
|
|
|
if (target_type == NULL) {
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
if (STREQ(target_type, "multipath")) {
|
|
ret = 1;
|
|
}
|
|
|
|
out:
|
|
if (dmt != NULL) {
|
|
dm_task_destroy(dmt);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int
|
|
virStorageBackendGetMinorNumber(const char *dev_name, uint32_t *minor)
|
|
{
|
|
int ret = -1;
|
|
struct dm_task *dmt;
|
|
struct dm_info info;
|
|
|
|
if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
|
|
goto out;
|
|
}
|
|
|
|
if (!dm_task_set_name(dmt, dev_name)) {
|
|
goto out;
|
|
}
|
|
|
|
if (!dm_task_run(dmt)) {
|
|
goto out;
|
|
}
|
|
|
|
if (!dm_task_get_info(dmt, &info)) {
|
|
goto out;
|
|
}
|
|
|
|
*minor = info.minor;
|
|
ret = 0;
|
|
|
|
out:
|
|
if (dmt != NULL)
|
|
dm_task_destroy(dmt);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int
|
|
virStorageBackendCreateVols(virStoragePoolObjPtr pool,
|
|
struct dm_names *names)
|
|
{
|
|
int retval = -1, is_mpath = 0;
|
|
char *map_device = NULL;
|
|
uint32_t minor = -1;
|
|
uint32_t next;
|
|
|
|
do {
|
|
is_mpath = virStorageBackendIsMultipath(names->name);
|
|
|
|
if (is_mpath < 0) {
|
|
goto out;
|
|
}
|
|
|
|
if (is_mpath == 1) {
|
|
|
|
if (virAsprintf(&map_device, "mapper/%s", names->name) < 0) {
|
|
virReportOOMError();
|
|
goto out;
|
|
}
|
|
|
|
if (virStorageBackendGetMinorNumber(names->name, &minor) < 0) {
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
_("Failed to get %s minor number"),
|
|
names->name);
|
|
goto out;
|
|
}
|
|
|
|
if (virStorageBackendMpathNewVol(pool, minor, map_device) < 0) {
|
|
goto out;
|
|
}
|
|
|
|
VIR_FREE(map_device);
|
|
}
|
|
|
|
/* Given the way libdevmapper returns its data, I don't see
|
|
* any way to avoid this series of casts. */
|
|
VIR_WARNINGS_NO_CAST_ALIGN
|
|
next = names->next;
|
|
names = (struct dm_names *)(((char *)names) + next);
|
|
VIR_WARNINGS_RESET
|
|
|
|
} while (next);
|
|
|
|
retval = 0;
|
|
out:
|
|
return retval;
|
|
}
|
|
|
|
|
|
static int
|
|
virStorageBackendGetMaps(virStoragePoolObjPtr pool)
|
|
{
|
|
int retval = 0;
|
|
struct dm_task *dmt = NULL;
|
|
struct dm_names *names = NULL;
|
|
|
|
if (!(dmt = dm_task_create(DM_DEVICE_LIST))) {
|
|
retval = 1;
|
|
goto out;
|
|
}
|
|
|
|
dm_task_no_open_count(dmt);
|
|
|
|
if (!dm_task_run(dmt)) {
|
|
retval = 1;
|
|
goto out;
|
|
}
|
|
|
|
if (!(names = dm_task_get_names(dmt))) {
|
|
retval = 1;
|
|
goto out;
|
|
}
|
|
|
|
if (!names->dev) {
|
|
/* No devices found */
|
|
goto out;
|
|
}
|
|
|
|
virStorageBackendCreateVols(pool, names);
|
|
|
|
out:
|
|
if (dmt != NULL) {
|
|
dm_task_destroy(dmt);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
static int
|
|
virStorageBackendMpathCheckPool(virConnectPtr conn ATTRIBUTE_UNUSED,
|
|
virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
|
|
bool *isActive)
|
|
{
|
|
const char *path = "/dev/mpath";
|
|
|
|
*isActive = false;
|
|
|
|
if (access(path, F_OK) == 0)
|
|
*isActive = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
virStorageBackendMpathRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
|
|
virStoragePoolObjPtr pool)
|
|
{
|
|
int retval = 0;
|
|
|
|
VIR_DEBUG("conn=%p, pool=%p", conn, pool);
|
|
|
|
pool->def->allocation = pool->def->capacity = pool->def->available = 0;
|
|
|
|
virFileWaitForDevices();
|
|
|
|
virStorageBackendGetMaps(pool);
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
virStorageBackend virStorageBackendMpath = {
|
|
.type = VIR_STORAGE_POOL_MPATH,
|
|
|
|
.checkPool = virStorageBackendMpathCheckPool,
|
|
.refreshPool = virStorageBackendMpathRefreshPool,
|
|
};
|