openkylin
/
libvirt
mirror of https://gitee.com/openkylin/libvirt.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
libvirt/tests/virfilewrapper.c

190 lines
4.2 KiB
C
Raw Normal View History

tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
/*
* virfilewrapper.c: Wrapper for universal file access
*
* 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>
tests: stub out virfilewrapper.c on Win32 The Win32 platform can not do link time overrides in the same way that we can on POSIX / ELF based platforms, so we cannot build the virfilewrapper.c code reliably. Just stub it out on Win32 so it is a no-op. Tests that use this file are already written to skip on Win32. Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2017-05-11 18:42:14 +08:00
#ifndef WIN32
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
tests: stub out virfilewrapper.c on Win32 The Win32 platform can not do link time overrides in the same way that we can on POSIX / ELF based platforms, so we cannot build the virfilewrapper.c code reliably. Just stub it out on Win32 so it is a no-op. Tests that use this file are already written to skip on Win32. Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2017-05-11 18:42:14 +08:00
# include <fcntl.h>
# include "viralloc.h"
# include "virfile.h"
# include "virfilewrapper.h"
# include "virmock.h"
# include "virstring.h"
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
/* Mapping for prefix overrides */
static size_t noverrides;
static const char **overrides;
/* nprefixes == noverrides, but two variables make it easier to use
* VIR_*_ELEMENT macros */
static size_t nprefixes;
static const char **prefixes;
/* TODO: callbacks */
static int (*real_open)(const char *path, int flags, ...);
static FILE *(*real_fopen)(const char *path, const char *mode);
static int (*real_access)(const char *path, int mode);
static int (*real_mkdir)(const char *path, mode_t mode);
static DIR *(*real_opendir)(const char *path);
static void init_syms(void)
{
if (real_fopen)
return;
VIR_MOCK_REAL_INIT(fopen);
VIR_MOCK_REAL_INIT(access);
VIR_MOCK_REAL_INIT(mkdir);
VIR_MOCK_REAL_INIT(open);
VIR_MOCK_REAL_INIT(opendir);
}
tests: Turn virFileWrapperAddPrefix to void In theory, it's nice to have virFileWrapperAddPrefix() return a value that indicates if the function succeeded or not. But in practice, nobody checks for that and in fact blindly believes that the function succeeded. Therefore, make the function return nothing and just abort() if it would fail. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Martin Kletzander <mkletzan@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:45:25 +08:00
void
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
virFileWrapperAddPrefix(const char *prefix,
tests: Fix indentation in virfilewrapper.c Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-07-25 17:43:33 +08:00
const char *override)
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
{
/* Both parameters are mandatory */
tests: Turn virFileWrapperAddPrefix to void In theory, it's nice to have virFileWrapperAddPrefix() return a value that indicates if the function succeeded or not. But in practice, nobody checks for that and in fact blindly believes that the function succeeded. Therefore, make the function return nothing and just abort() if it would fail. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Martin Kletzander <mkletzan@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:45:25 +08:00
if (!prefix || !override) {
fprintf(stderr, "Attempt to add invalid path override\n");
abort();
}
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
init_syms();
if (VIR_APPEND_ELEMENT_QUIET(prefixes, nprefixes, prefix) < 0 ||
VIR_APPEND_ELEMENT_QUIET(overrides, noverrides, override) < 0) {
VIR_FREE(prefixes);
VIR_FREE(overrides);
tests: Turn virFileWrapperAddPrefix to void In theory, it's nice to have virFileWrapperAddPrefix() return a value that indicates if the function succeeded or not. But in practice, nobody checks for that and in fact blindly believes that the function succeeded. Therefore, make the function return nothing and just abort() if it would fail. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Martin Kletzander <mkletzan@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:45:25 +08:00
fprintf(stderr, "Unable to add path override for '%s'\n", prefix);
abort();
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
}
void
virFileWrapperRemovePrefix(const char *prefix)
{
size_t i = 0;
for (i = 0; i < noverrides; i++) {
if (STREQ(prefixes[i], prefix))
break;
}
if (i == noverrides)
return;
VIR_DELETE_ELEMENT(overrides, i, noverrides);
VIR_DELETE_ELEMENT(prefixes, i, nprefixes);
}
void
virFileWrapperClearPrefixes(void)
{
nprefixes = 0;
noverrides = 0;
VIR_FREE(prefixes);
VIR_FREE(overrides);
}
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
# include "virmockstathelpers.c"
int
virMockStatRedirect(const char *path, char **newpath)
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
{
size_t i = 0;
for (i = 0; i < noverrides; i++) {
const char *tmp = STRSKIP(path, prefixes[i]);
if (!tmp)
continue;
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
if (virAsprintfQuiet(newpath, "%s%s", overrides[i], tmp) < 0)
return -1;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
break;
}
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
return 0;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
Remove backslash alignment attempts Right-aligning backslashes when defining macros or using complex commands in Makefiles looks cute, but as soon as any changes is required to the code you end up with either distractingly broken alignment or unnecessarily big diffs where most of the changes are just pushing all backslashes a few characters to one side. Generated using $ git grep -El '[[:blank:]][[:blank:]]\\$' | \ grep -E '*\.([chx]|am|mk)$$' | \ while read f; do \ sed -Ei 's/[[:blank:]]*[[:blank:]]\\$/ \\/g' "$f"; \ done Signed-off-by: Andrea Bolognani <abologna@redhat.com>
2017-11-03 20:09:47 +08:00
# define PATH_OVERRIDE(newpath, path) \
do { \
init_syms(); \
\
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
if (virMockStatRedirect(path, &newpath) < 0) \
Remove backslash alignment attempts Right-aligning backslashes when defining macros or using complex commands in Makefiles looks cute, but as soon as any changes is required to the code you end up with either distractingly broken alignment or unnecessarily big diffs where most of the changes are just pushing all backslashes a few characters to one side. Generated using $ git grep -El '[[:blank:]][[:blank:]]\\$' | \ grep -E '*\.([chx]|am|mk)$$' | \ while read f; do \ sed -Ei 's/[[:blank:]]*[[:blank:]]\\$/ \\/g' "$f"; \ done Signed-off-by: Andrea Bolognani <abologna@redhat.com>
2017-11-03 20:09:47 +08:00
abort(); \
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
} while (0)
FILE *fopen(const char *path, const char *mode)
{
virFileWrapper: Use VIR_AUTOFREE() This enables us to simplify the code a bit. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:54:45 +08:00
VIR_AUTOFREE(char *) newpath = NULL;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
PATH_OVERRIDE(newpath, path);
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
return real_fopen(newpath ? newpath : path, mode);
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
int access(const char *path, int mode)
{
virFileWrapper: Use VIR_AUTOFREE() This enables us to simplify the code a bit. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:54:45 +08:00
VIR_AUTOFREE(char *) newpath = NULL;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
PATH_OVERRIDE(newpath, path);
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
return real_access(newpath ? newpath : path, mode);
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
int open(const char *path, int flags, ...)
{
virFileWrapper: Use VIR_AUTOFREE() This enables us to simplify the code a bit. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:54:45 +08:00
VIR_AUTOFREE(char *) newpath = NULL;
tests: Do not ignore mode parameter in mocked open() This is normally not an issue since the tests which use mocked open() do not create files. But once coverage build is enabled, gcov_open will use O_CREATE and real_open will read random data rather than the actual mode argument. Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
2017-09-26 02:27:07 +08:00
va_list ap;
mode_t mode = 0;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
PATH_OVERRIDE(newpath, path);
tests: Do not ignore mode parameter in mocked open() This is normally not an issue since the tests which use mocked open() do not create files. But once coverage build is enabled, gcov_open will use O_CREATE and real_open will read random data rather than the actual mode argument. Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
2017-09-26 02:27:07 +08:00
/* The mode argument is mandatory when O_CREAT is set in flags,
* otherwise the argument is ignored.
*/
if (flags & O_CREAT) {
va_start(ap, flags);
tests: Fix build with clang clang doesn't like mode_t type as an argument to va_arg(): error: second argument to 'va_arg' is of promotable type 'mode_t' (aka 'unsigned short'); this va_arg has undefined behavior because arguments will be promoted to 'int' mode = va_arg(ap, mode_t); ^~~~~~ Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
2017-10-05 15:06:03 +08:00
mode = (mode_t) va_arg(ap, int);
tests: Do not ignore mode parameter in mocked open() This is normally not an issue since the tests which use mocked open() do not create files. But once coverage build is enabled, gcov_open will use O_CREATE and real_open will read random data rather than the actual mode argument. Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
2017-09-26 02:27:07 +08:00
va_end(ap);
}
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
return real_open(newpath ? newpath : path, flags, mode);
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
DIR *opendir(const char *path)
{
virFileWrapper: Use VIR_AUTOFREE() This enables us to simplify the code a bit. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com>
2019-03-13 16:54:45 +08:00
VIR_AUTOFREE(char *) newpath = NULL;
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
PATH_OVERRIDE(newpath, path);
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
return real_opendir(newpath ? newpath : path);
tests: Add virfilewrapper -- the new super "mock" This mock (which is actually not mock at all, see later) can redirect all accesses to a path into another path. There is no need to create mocks for particular directories, you just create a directory with all the data a redirect the test there. In the future, this should also be able to register callbacks for calls/paths, e.g. when the test is going to write into anything under "/sys/devices", call function fce(); Then in the open() call we would add information about the fd into some structure and in write() we would call fce() with parameters like @path to write to, @data to be written and pointer to optional return value, so that fce() itself could stop the call from happening or change its behaviour. But that's an idea for a latter day. This is not a mock because it will not be preloaded, but compiled in the test itself. See future patches for usage. Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
2017-04-03 20:29:45 +08:00
}
tests: fix mocking of stat() / lstat() functions Quite a few of the tests have a need to mock the stat() / lstat() functions and they are taking somewhat different & inconsistent approaches none of which are actually fully correct. This is shown by fact that 'make check' fails on 32-bit hosts. Investigation revealed that the code was calling into the native C library impl, not getting intercepted by our mocks. The POSIX stat() function might resolve to any number of different symbols in the C library. The may be an additional stat64() function exposed by the headers too. On 64-bit hosts the stat & stat64 functions are identical, always refering to the 64-bit ABI. On 32-bit hosts they refer to the 32-bit & 64-bit ABIs respectively. Libvirt uses _FILE_OFFSET_BITS=64 on 32-bit hosts, which causes the C library to transparently rewrite stat() calls to be stat64() calls. Libvirt will never see the 32-bit ABI from the traditional stat() call. We cannot assume this rewriting is done using a macro. It might be, but on GLibC it is done with a magic __asm__ statement to apply the rewrite at link time instead of at preprocessing. In GLibC there may be two additional functions exposed by the headers, __xstat() and __xstat64(). When these exist, stat() and stat64() are transparently rewritten to call __xstat() and __xstat64() respectively. The former symbols will not actally exist in the library at all, only the header. The leading "__" indicates the symbols are a private impl detail of the C library that applications should not care about. Unfortunately, because we are trying to mock replace the C library, we need to know about this internal impl detail. With all this in mind the list of functions we have to mock will depend on several factors - If _FILE_OFFSET_BITS is set, then we are on a 32-bit host, and we only need to mock stat64 and __xstat64. The other stat / __xstat functions exist, but we'll never call them so they can be ignored for mocking. - If _FILE_OFFSET_BITS is not set, then we are on a 64-bit host and we should mock stat, stat64, __xstat & __xstat64. Either may be called by app code. - If __xstat & __xstat64 exist, then stat & stat64 will not exist as symbols in the library, so the latter should not be mocked. The same all applies to lstat() These rules are complex enough that we don't want to duplicate them across every mock file, so this centralizes all the logic in a helper file virmockstathelper.c that should be #included when needed. The code merely need to provide a filename rewriting callback called virMockStatRedirect(). Optionally VIR_MOCK_STAT_HOOK can be defined as a macro if further processing is needed inline. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2019-04-02 00:47:25 +08:00
tests: stub out virfilewrapper.c on Win32 The Win32 platform can not do link time overrides in the same way that we can on POSIX / ELF based platforms, so we cannot build the virfilewrapper.c code reliably. Just stub it out on Win32 so it is a no-op. Tests that use this file are already written to skip on Win32. Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2017-05-11 18:42:14 +08:00
#endif