2017-11-03 17:20:55 +03: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 "testutils.h"
2019-12-12 20:17:08 +03:00
# include "testutilsqemu.h"
# include "testutilsqemuschema.h"
# include "virstoragefile.h"
# include "virstring.h"
# include "virlog.h"
# include "qemu/qemu_block.h"
# include "qemu/qemu_qapi.h"
# include "qemu/qemu_monitor_json.h"
# include "qemu/qemu_backup.h"
2020-01-08 16:56:45 +03:00
# include "qemu/qemu_checkpoint.h"
2020-03-27 00:31:19 +03:00
# include "qemu/qemu_validate.h"
2018-03-23 11:06:40 +03:00
2019-12-12 20:17:08 +03:00
# include "qemu/qemu_command.h"
2017-11-03 17:20:55 +03:00
2019-12-12 20:17:08 +03:00
# define LIBVIRT_SNAPSHOT_CONF_PRIV_H_ALLOW
# include "conf/snapshot_conf_priv.h"
2018-09-04 14:00:14 +03:00
2019-12-12 20:17:08 +03:00
# define VIR_FROM_THIS VIR_FROM_NONE
2017-11-03 17:20:55 +03:00
VIR_LOG_INIT ( " tests.storagetest " ) ;
struct testBackingXMLjsonXMLdata {
int type ;
const char * xml ;
2020-03-09 17:39:04 +03:00
bool legacy ;
virHashTablePtr schema ;
virJSONValuePtr schemaroot ;
2017-11-03 17:20:55 +03:00
} ;
static int
testBackingXMLjsonXML ( const void * args )
{
const struct testBackingXMLjsonXMLdata * data = args ;
2019-10-15 15:47:50 +03:00
g_autoptr ( xmlDoc ) xml = NULL ;
g_autoptr ( xmlXPathContext ) ctxt = NULL ;
2019-10-15 15:47:50 +03:00
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virJSONValue ) backendprops = NULL ;
g_autoptr ( virJSONValue ) wrapper = NULL ;
2019-10-15 16:16:31 +03:00
g_autofree char * propsstr = NULL ;
g_autofree char * protocolwrapper = NULL ;
g_autofree char * actualxml = NULL ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virStorageSource ) xmlsrc = NULL ;
g_autoptr ( virStorageSource ) jsonsrc = NULL ;
2020-03-09 17:39:04 +03:00
g_auto ( virBuffer ) debug = VIR_BUFFER_INITIALIZER ;
2017-11-03 17:20:55 +03:00
2019-02-14 18:20:25 +03:00
if ( ! ( xmlsrc = virStorageSourceNew ( ) ) )
2017-11-03 17:20:55 +03:00
return - 1 ;
xmlsrc - > type = data - > type ;
if ( ! ( xml = virXMLParseStringCtxt ( data - > xml , " (test storage source XML) " , & ctxt ) ) )
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
2019-03-11 12:47:53 +03:00
if ( virDomainStorageSourceParse ( ctxt - > node , ctxt , xmlsrc , 0 , NULL ) < 0 ) {
2017-11-03 17:20:55 +03:00
fprintf ( stderr , " failed to parse disk source xml \n " ) ;
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
}
2020-03-09 17:39:04 +03:00
if ( ! ( backendprops = qemuBlockStorageSourceGetBackendProps ( xmlsrc ,
data - > legacy ,
false ,
2018-09-04 20:29:10 +03:00
false ) ) ) {
2017-11-03 17:20:55 +03:00
fprintf ( stderr , " failed to format disk source json \n " ) ;
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
}
2020-03-09 17:39:04 +03:00
if ( ! data - > legacy ) {
if ( testQEMUSchemaValidate ( backendprops , data - > schemaroot ,
2020-04-29 18:52:43 +03:00
data - > schema , false , & debug ) < 0 ) {
2020-03-09 17:39:04 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
g_autofree char * debugprops = virJSONValueToString ( backendprops , true ) ;
VIR_TEST_VERBOSE ( " json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
debugprops , NULLSTR ( debugmsg ) ) ;
return - 1 ;
}
}
2018-03-30 12:12:57 +03:00
if ( virJSONValueObjectCreate ( & wrapper , " a:file " , & backendprops , NULL ) < 0 )
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
if ( ! ( propsstr = virJSONValueToString ( wrapper , false ) ) )
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
2019-10-22 16:26:14 +03:00
protocolwrapper = g_strdup_printf ( " json:%s " , propsstr ) ;
2017-11-03 17:20:55 +03:00
2019-08-15 17:43:40 +03:00
if ( virStorageSourceNewFromBackingAbsolute ( protocolwrapper ,
& jsonsrc ) < 0 ) {
2017-11-03 17:20:55 +03:00
fprintf ( stderr , " failed to parse disk json \n " ) ;
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
}
2020-05-07 15:00:28 +03:00
if ( virDomainDiskSourceFormat ( & buf , jsonsrc , " source " , 0 , false , 0 ,
false , false , NULL ) < 0 | |
2017-11-03 17:20:55 +03:00
! ( actualxml = virBufferContentAndReset ( & buf ) ) ) {
fprintf ( stderr , " failed to format disk source xml \n " ) ;
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
}
if ( STRNEQ ( actualxml , data - > xml ) ) {
fprintf ( stderr , " \n expected storage source xml: \n '%s' \n "
" actual storage source xml: \n %s \n "
" intermediate json: \n %s \n " ,
data - > xml , actualxml , protocolwrapper ) ;
2019-03-08 18:11:20 +03:00
return - 1 ;
2017-11-03 17:20:55 +03:00
}
2019-03-08 18:11:20 +03:00
return 0 ;
2017-11-03 17:20:55 +03:00
}
2020-03-09 19:06:10 +03:00
static const char * testJSONtoJSONPath = abs_srcdir " /qemublocktestdata/jsontojson/ " ;
struct testJSONtoJSONData {
const char * name ;
virHashTablePtr schema ;
virJSONValuePtr schemaroot ;
} ;
static int
testJSONtoJSON ( const void * args )
{
const struct testJSONtoJSONData * data = args ;
g_auto ( virBuffer ) debug = VIR_BUFFER_INITIALIZER ;
g_autoptr ( virJSONValue ) jsonsrcout = NULL ;
g_autoptr ( virStorageSource ) src = NULL ;
g_autofree char * actual = NULL ;
g_autofree char * in = NULL ;
g_autofree char * infile = g_strdup_printf ( " %s%s-in.json " , testJSONtoJSONPath ,
data - > name ) ;
g_autofree char * outfile = g_strdup_printf ( " %s%s-out.json " , testJSONtoJSONPath ,
data - > name ) ;
if ( virTestLoadFile ( infile , & in ) < 0 )
return - 1 ;
if ( virStorageSourceNewFromBackingAbsolute ( in , & src ) < 0 ) {
fprintf ( stderr , " failed to parse disk json \n " ) ;
return - 1 ;
}
if ( ! ( jsonsrcout = qemuBlockStorageSourceGetBackendProps ( src , false , false , true ) ) ) {
fprintf ( stderr , " failed to format disk source json \n " ) ;
return - 1 ;
}
if ( ! ( actual = virJSONValueToString ( jsonsrcout , true ) ) )
return - 1 ;
if ( testQEMUSchemaValidate ( jsonsrcout , data - > schemaroot ,
2020-04-29 18:52:43 +03:00
data - > schema , false , & debug ) < 0 ) {
2020-03-09 19:06:10 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
VIR_TEST_VERBOSE ( " json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
actual , NULLSTR ( debugmsg ) ) ;
return - 1 ;
}
return virTestCompareToFile ( actual , outfile ) ;
}
2017-11-03 17:20:55 +03:00
2020-03-23 14:10:38 +03:00
struct testQemuDiskXMLToJSONImageData {
virJSONValuePtr formatprops ;
virJSONValuePtr storageprops ;
virJSONValuePtr storagepropssrc ;
2020-03-23 14:35:32 +03:00
char * backingstore ;
2020-03-23 14:10:38 +03:00
} ;
2018-03-23 11:06:40 +03:00
struct testQemuDiskXMLToJSONData {
virQEMUDriverPtr driver ;
virHashTablePtr schema ;
virJSONValuePtr schemaroot ;
const char * name ;
bool fail ;
2020-03-23 14:10:38 +03:00
struct testQemuDiskXMLToJSONImageData * images ;
size_t nimages ;
2018-12-17 18:29:05 +03:00
2018-03-23 11:06:40 +03:00
virQEMUCapsPtr qemuCaps ;
} ;
static void
testQemuDiskXMLToPropsClear ( struct testQemuDiskXMLToJSONData * data )
{
size_t i ;
2020-03-23 14:10:38 +03:00
for ( i = 0 ; i < data - > nimages ; i + + ) {
virJSONValueFree ( data - > images [ i ] . formatprops ) ;
virJSONValueFree ( data - > images [ i ] . storageprops ) ;
virJSONValueFree ( data - > images [ i ] . storagepropssrc ) ;
2020-03-23 14:35:32 +03:00
g_free ( data - > images [ i ] . backingstore ) ;
2020-03-23 14:10:38 +03:00
}
data - > nimages = 0 ;
VIR_FREE ( data - > images ) ;
2018-03-23 11:06:40 +03:00
}
2018-04-19 17:16:44 +03:00
static int
testQemuDiskXMLToJSONFakeSecrets ( virStorageSourcePtr src )
{
qemuDomainStorageSourcePrivatePtr srcpriv ;
if ( ! src - > privateData & &
! ( src - > privateData = qemuDomainStorageSourcePrivateNew ( ) ) )
return - 1 ;
srcpriv = QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE ( src ) ;
if ( src - > auth ) {
if ( VIR_ALLOC ( srcpriv - > secinfo ) < 0 )
return - 1 ;
srcpriv - > secinfo - > type = VIR_DOMAIN_SECRET_INFO_TYPE_AES ;
2019-10-20 14:49:46 +03:00
srcpriv - > secinfo - > s . aes . username = g_strdup ( src - > auth - > username ) ;
2018-04-19 17:16:44 +03:00
2019-10-22 16:26:14 +03:00
srcpriv - > secinfo - > s . aes . alias = g_strdup_printf ( " %s-secalias " ,
NULLSTR ( src - > nodestorage ) ) ;
2018-04-19 17:16:44 +03:00
}
if ( src - > encryption ) {
if ( VIR_ALLOC ( srcpriv - > encinfo ) < 0 )
return - 1 ;
srcpriv - > encinfo - > type = VIR_DOMAIN_SECRET_INFO_TYPE_AES ;
2019-10-22 16:26:14 +03:00
srcpriv - > encinfo - > s . aes . alias = g_strdup_printf ( " %s-encalias " ,
NULLSTR ( src - > nodeformat ) ) ;
2018-04-19 17:16:44 +03:00
}
return 0 ;
}
2018-03-23 11:06:40 +03:00
static const char * testQemuDiskXMLToJSONPath = abs_srcdir " /qemublocktestdata/xml2json/ " ;
static int
testQemuDiskXMLToProps ( const void * opaque )
{
struct testQemuDiskXMLToJSONData * data = ( void * ) opaque ;
2020-01-08 09:49:27 +03:00
g_autoptr ( virDomainDef ) vmdef = NULL ;
2018-03-23 11:06:40 +03:00
virDomainDiskDefPtr disk = NULL ;
virStorageSourcePtr n ;
2020-03-23 13:24:39 +03:00
g_autoptr ( virJSONValue ) formatProps = NULL ;
g_autoptr ( virJSONValue ) storageProps = NULL ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virJSONValue ) storageSrcOnlyProps = NULL ;
2020-03-23 13:24:39 +03:00
g_autofree char * xmlpath = NULL ;
g_autofree char * xmlstr = NULL ;
2018-03-23 11:06:40 +03:00
2019-10-22 16:26:14 +03:00
xmlpath = g_strdup_printf ( " %s%s.xml " , testQemuDiskXMLToJSONPath , data - > name ) ;
2018-03-23 11:06:40 +03:00
if ( virTestLoadFile ( xmlpath , & xmlstr ) < 0 )
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
/* qemu stores node names in the status XML portion */
2019-11-26 21:42:56 +03:00
if ( ! ( disk = virDomainDiskDefParse ( xmlstr , data - > driver - > xmlopt ,
2018-03-23 11:06:40 +03:00
VIR_DOMAIN_DEF_PARSE_STATUS ) ) )
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
2020-01-08 09:49:27 +03:00
if ( ! ( vmdef = virDomainDefNew ( ) ) | |
virDomainDiskInsert ( vmdef , disk ) < 0 )
2020-03-23 13:24:39 +03:00
return - 1 ;
2020-01-08 09:49:27 +03:00
2020-05-04 20:21:55 +03:00
if ( qemuValidateDomainDeviceDefDisk ( disk , vmdef , data - > qemuCaps ) < 0 ) {
2019-05-03 11:45:58 +03:00
VIR_TEST_VERBOSE ( " invalid configuration for disk " ) ;
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
}
for ( n = disk - > src ; virStorageSourceIsBacking ( n ) ; n = n - > backingStore ) {
2020-03-23 14:35:32 +03:00
g_autofree char * backingstore = NULL ;
2020-03-23 14:10:38 +03:00
2018-04-19 17:16:44 +03:00
if ( testQemuDiskXMLToJSONFakeSecrets ( n ) < 0 )
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-04-19 17:16:44 +03:00
2020-05-05 18:00:41 +03:00
if ( qemuDomainValidateStorageSource ( n , data - > qemuCaps , false ) < 0 )
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-05-29 18:28:11 +03:00
2019-10-08 16:14:22 +03:00
qemuDomainPrepareDiskSourceData ( disk , n ) ;
2018-05-29 18:05:05 +03:00
2019-09-03 14:27:52 +03:00
if ( ! ( formatProps = qemuBlockStorageSourceGetBlockdevProps ( n , n - > backingStore ) ) | |
2018-09-04 20:29:10 +03:00
! ( storageSrcOnlyProps = qemuBlockStorageSourceGetBackendProps ( n , false , true , true ) ) | |
2020-03-23 14:35:32 +03:00
! ( storageProps = qemuBlockStorageSourceGetBackendProps ( n , false , false , true ) ) | |
! ( backingstore = qemuBlockGetBackingStoreString ( n , true ) ) ) {
2018-03-23 11:06:40 +03:00
if ( ! data - > fail ) {
2019-05-03 11:45:58 +03:00
VIR_TEST_VERBOSE ( " failed to generate qemu blockdev props " ) ;
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
}
} else if ( data - > fail ) {
2019-05-03 11:45:58 +03:00
VIR_TEST_VERBOSE ( " qemu blockdev props should have failed " ) ;
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
}
2020-03-23 14:10:38 +03:00
if ( VIR_REALLOC_N ( data - > images , data - > nimages + 1 ) < 0 )
2020-03-23 13:24:39 +03:00
return - 1 ;
2020-03-23 14:10:38 +03:00
data - > images [ data - > nimages ] . formatprops = g_steal_pointer ( & formatProps ) ;
data - > images [ data - > nimages ] . storageprops = g_steal_pointer ( & storageProps ) ;
data - > images [ data - > nimages ] . storagepropssrc = g_steal_pointer ( & storageSrcOnlyProps ) ;
2020-03-23 14:35:32 +03:00
data - > images [ data - > nimages ] . backingstore = g_steal_pointer ( & backingstore ) ;
2020-03-23 14:10:38 +03:00
data - > nimages + + ;
2018-03-23 11:06:40 +03:00
}
2020-03-23 13:24:39 +03:00
return 0 ;
2018-03-23 11:06:40 +03:00
}
static int
testQemuDiskXMLToPropsValidateSchema ( const void * opaque )
{
struct testQemuDiskXMLToJSONData * data = ( void * ) opaque ;
int ret = 0 ;
size_t i ;
if ( data - > fail )
return EXIT_AM_SKIP ;
2020-03-23 14:10:38 +03:00
for ( i = 0 ; i < data - > nimages ; i + + ) {
2020-03-23 13:24:39 +03:00
g_auto ( virBuffer ) debug = VIR_BUFFER_INITIALIZER ;
2020-03-23 14:10:38 +03:00
if ( testQEMUSchemaValidate ( data - > images [ i ] . formatprops , data - > schemaroot ,
2020-04-29 18:52:43 +03:00
data - > schema , false , & debug ) < 0 ) {
2020-03-23 13:24:39 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
2020-03-23 14:10:38 +03:00
g_autofree char * propsstr = virJSONValueToString ( data - > images [ i ] . formatprops , true ) ;
2018-03-23 11:06:40 +03:00
VIR_TEST_VERBOSE ( " json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
propsstr , NULLSTR ( debugmsg ) ) ;
ret = - 1 ;
}
2018-12-17 18:29:05 +03:00
2020-03-23 14:10:38 +03:00
virBufferFreeAndReset ( & debug ) ;
2020-03-23 13:24:39 +03:00
2020-03-23 14:10:38 +03:00
if ( testQEMUSchemaValidate ( data - > images [ i ] . storageprops , data - > schemaroot ,
2020-04-29 18:52:43 +03:00
data - > schema , false , & debug ) < 0 ) {
2020-03-23 13:24:39 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
2020-03-23 14:10:38 +03:00
g_autofree char * propsstr = virJSONValueToString ( data - > images [ i ] . storageprops , true ) ;
VIR_TEST_VERBOSE ( " json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
propsstr , NULLSTR ( debugmsg ) ) ;
ret = - 1 ;
}
virBufferFreeAndReset ( & debug ) ;
if ( testQEMUSchemaValidate ( data - > images [ i ] . storagepropssrc , data - > schemaroot ,
2020-04-29 18:52:43 +03:00
data - > schema , false , & debug ) < 0 ) {
2020-03-23 14:10:38 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
g_autofree char * propsstr = virJSONValueToString ( data - > images [ i ] . storagepropssrc , true ) ;
2018-12-17 18:29:05 +03:00
VIR_TEST_VERBOSE ( " json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
propsstr , NULLSTR ( debugmsg ) ) ;
ret = - 1 ;
}
}
2018-03-23 11:06:40 +03:00
return ret ;
}
static int
testQemuDiskXMLToPropsValidateFile ( const void * opaque )
{
struct testQemuDiskXMLToJSONData * data = ( void * ) opaque ;
virBuffer buf = VIR_BUFFER_INITIALIZER ;
2020-03-23 13:24:39 +03:00
g_autofree char * jsonpath = NULL ;
g_autofree char * actual = NULL ;
2018-03-23 11:06:40 +03:00
size_t i ;
if ( data - > fail )
return EXIT_AM_SKIP ;
2019-10-22 16:26:14 +03:00
jsonpath = g_strdup_printf ( " %s%s.json " , testQemuDiskXMLToJSONPath , data - > name ) ;
2018-03-23 11:06:40 +03:00
2020-03-23 14:10:38 +03:00
for ( i = 0 ; i < data - > nimages ; i + + ) {
g_autofree char * formatprops = NULL ;
g_autofree char * storageprops = NULL ;
2018-03-23 11:06:40 +03:00
2020-03-23 14:10:38 +03:00
if ( ! ( formatprops = virJSONValueToString ( data - > images [ i ] . formatprops , true ) ) )
2020-03-23 13:24:39 +03:00
return - 1 ;
2018-03-23 11:06:40 +03:00
2020-03-23 14:10:38 +03:00
if ( ! ( storageprops = virJSONValueToString ( data - > images [ i ] . storageprops , true ) ) )
return - 1 ;
virBufferStrcat ( & buf , formatprops , storageprops , NULL ) ;
2018-03-23 11:06:40 +03:00
}
actual = virBufferContentAndReset ( & buf ) ;
2020-03-23 13:24:39 +03:00
return virTestCompareToFile ( actual , jsonpath ) ;
2018-03-23 11:06:40 +03:00
}
2020-03-23 13:50:57 +03:00
static int
testQemuDiskXMLToPropsValidateFileSrcOnly ( const void * opaque )
{
struct testQemuDiskXMLToJSONData * data = ( void * ) opaque ;
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
g_autofree char * jsonpath = NULL ;
g_autofree char * actual = NULL ;
size_t i ;
if ( data - > fail )
return EXIT_AM_SKIP ;
jsonpath = g_strdup_printf ( " %s%s-srconly.json " , testQemuDiskXMLToJSONPath ,
data - > name ) ;
2020-03-23 14:10:38 +03:00
for ( i = 0 ; i < data - > nimages ; i + + ) {
2020-03-23 13:50:57 +03:00
g_autofree char * jsonstr = NULL ;
2020-03-23 14:35:32 +03:00
virBufferAddLit ( & buf , " ( \n " ) ;
virBufferAdjustIndent ( & buf , 2 ) ;
virBufferAddLit ( & buf , " source only properties: \n " ) ;
2020-03-23 14:10:38 +03:00
if ( ! ( jsonstr = virJSONValueToString ( data - > images [ i ] . storagepropssrc , true ) ) )
2020-03-23 13:50:57 +03:00
return - 1 ;
2020-03-23 14:35:32 +03:00
virBufferAddStr ( & buf , jsonstr ) ;
virBufferAddLit ( & buf , " backing store string: \n " ) ;
virBufferAddStr ( & buf , data - > images [ i ] . backingstore ) ;
virBufferTrim ( & buf , " \n " ) ;
virBufferAdjustIndent ( & buf , - 2 ) ;
virBufferAddLit ( & buf , " \n ) \n " ) ;
2020-03-23 13:50:57 +03:00
}
actual = virBufferContentAndReset ( & buf ) ;
return virTestCompareToFile ( actual , jsonpath ) ;
}
2018-09-04 14:40:01 +03:00
struct testQemuImageCreateData {
const char * name ;
const char * backingname ;
virHashTablePtr schema ;
virJSONValuePtr schemaroot ;
virQEMUDriverPtr driver ;
virQEMUCapsPtr qemuCaps ;
} ;
static const char * testQemuImageCreatePath = abs_srcdir " /qemublocktestdata/imagecreate/ " ;
static virStorageSourcePtr
testQemuImageCreateLoadDiskXML ( const char * name ,
virDomainXMLOptionPtr xmlopt )
{
virDomainSnapshotDiskDefPtr diskdef = NULL ;
2019-10-15 15:47:50 +03:00
g_autoptr ( xmlDoc ) doc = NULL ;
g_autoptr ( xmlXPathContext ) ctxt = NULL ;
2018-09-04 14:40:01 +03:00
xmlNodePtr node ;
2019-10-15 16:16:31 +03:00
g_autofree char * xmlpath = NULL ;
2018-09-04 14:40:01 +03:00
virStorageSourcePtr ret = NULL ;
2019-10-22 16:26:14 +03:00
xmlpath = g_strdup_printf ( " %s%s.xml " , testQemuImageCreatePath , name ) ;
2018-09-04 14:40:01 +03:00
if ( ! ( doc = virXMLParseFileCtxt ( xmlpath , & ctxt ) ) )
return NULL ;
if ( ! ( node = virXPathNode ( " //disk " , ctxt ) ) ) {
VIR_TEST_VERBOSE ( " failed to find <source> element \n " ) ;
return NULL ;
}
if ( VIR_ALLOC ( diskdef ) < 0 )
return NULL ;
if ( virDomainSnapshotDiskDefParseXML ( node , ctxt , diskdef ,
VIR_DOMAIN_DEF_PARSE_STATUS ,
xmlopt ) = = 0 )
2019-10-16 14:45:15 +03:00
ret = g_steal_pointer ( & diskdef - > src ) ;
2018-09-04 14:40:01 +03:00
virDomainSnapshotDiskDefFree ( diskdef ) ;
return ret ;
}
static int
testQemuImageCreate ( const void * opaque )
{
struct testQemuImageCreateData * data = ( void * ) opaque ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virJSONValue ) protocolprops = NULL ;
g_autoptr ( virJSONValue ) formatprops = NULL ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virStorageSource ) src = NULL ;
2019-10-15 15:47:50 +03:00
g_auto ( virBuffer ) debug = VIR_BUFFER_INITIALIZER ;
g_auto ( virBuffer ) actualbuf = VIR_BUFFER_INITIALIZER ;
2019-10-15 16:16:31 +03:00
g_autofree char * jsonprotocol = NULL ;
g_autofree char * jsonformat = NULL ;
g_autofree char * actual = NULL ;
g_autofree char * jsonpath = NULL ;
2018-09-04 14:40:01 +03:00
if ( ! ( src = testQemuImageCreateLoadDiskXML ( data - > name , data - > driver - > xmlopt ) ) )
return - 1 ;
if ( data - > backingname & &
! ( src - > backingStore = testQemuImageCreateLoadDiskXML ( data - > backingname ,
data - > driver - > xmlopt ) ) )
return - 1 ;
if ( testQemuDiskXMLToJSONFakeSecrets ( src ) < 0 )
return - 1 ;
/* fake some sizes */
2019-08-30 17:36:15 +03:00
src - > capacity = UINT_MAX * 2ULL ;
src - > physical = UINT_MAX + 1ULL ;
2018-09-04 14:40:01 +03:00
2020-05-05 18:00:41 +03:00
if ( qemuDomainValidateStorageSource ( src , data - > qemuCaps , false ) < 0 )
2018-09-04 14:40:01 +03:00
return - 1 ;
if ( qemuBlockStorageSourceCreateGetStorageProps ( src , & protocolprops ) < 0 )
return - 1 ;
if ( qemuBlockStorageSourceCreateGetFormatProps ( src , src - > backingStore , & formatprops ) < 0 )
return - 1 ;
if ( formatprops ) {
if ( ! ( jsonformat = virJSONValueToString ( formatprops , true ) ) )
return - 1 ;
if ( testQEMUSchemaValidate ( formatprops , data - > schemaroot , data - > schema ,
2020-04-29 18:52:43 +03:00
false , & debug ) < 0 ) {
2019-10-15 16:16:31 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
2018-09-04 14:40:01 +03:00
VIR_TEST_VERBOSE ( " blockdev-create format json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
jsonformat , NULLSTR ( debugmsg ) ) ;
return - 1 ;
}
virBufferFreeAndReset ( & debug ) ;
}
if ( protocolprops ) {
if ( ! ( jsonprotocol = virJSONValueToString ( protocolprops , true ) ) )
return - 1 ;
if ( testQEMUSchemaValidate ( protocolprops , data - > schemaroot , data - > schema ,
2020-04-29 18:52:43 +03:00
false , & debug ) < 0 ) {
2019-10-15 16:16:31 +03:00
g_autofree char * debugmsg = virBufferContentAndReset ( & debug ) ;
2018-09-04 14:40:01 +03:00
VIR_TEST_VERBOSE ( " blockdev-create protocol json does not conform to QAPI schema " ) ;
VIR_TEST_DEBUG ( " json: \n %s \n does not match schema. Debug output: \n %s " ,
jsonprotocol , NULLSTR ( debugmsg ) ) ;
return - 1 ;
}
virBufferFreeAndReset ( & debug ) ;
}
virBufferStrcat ( & actualbuf , " protocol: \n " , NULLSTR ( jsonprotocol ) ,
" \n format: \n " , NULLSTR ( jsonformat ) , NULL ) ;
2020-02-02 22:26:38 +03:00
virBufferTrim ( & actualbuf , " \n " ) ;
2018-09-04 14:40:01 +03:00
virBufferAddLit ( & actualbuf , " \n " ) ;
2019-10-22 16:26:14 +03:00
jsonpath = g_strdup_printf ( " %s%s.json " , testQemuImageCreatePath , data - > name ) ;
2018-09-04 14:40:01 +03:00
if ( ! ( actual = virBufferContentAndReset ( & actualbuf ) ) )
return - 1 ;
return virTestCompareToFile ( actual , jsonpath ) ;
}
2019-12-12 15:37:01 +03:00
static const char * bitmapDetectPrefix = " qemublocktestdata/bitmap/ " ;
static void
testQemuDetectBitmapsWorker ( virHashTablePtr nodedata ,
const char * nodename ,
virBufferPtr buf )
{
qemuBlockNamedNodeDataPtr data ;
size_t i ;
if ( ! ( data = virHashLookup ( nodedata , nodename ) ) )
return ;
virBufferAsprintf ( buf , " %s: \n " , nodename ) ;
virBufferAdjustIndent ( buf , 1 ) ;
for ( i = 0 ; i < data - > nbitmaps ; i + + ) {
qemuBlockNamedNodeDataBitmapPtr bitmap = data - > bitmaps [ i ] ;
virBufferAsprintf ( buf , " %8s: record:%d busy:%d persist:%d inconsist:%d gran:%llu dirty:%llu \n " ,
bitmap - > name , bitmap - > recording , bitmap - > busy ,
bitmap - > persistent , bitmap - > inconsistent ,
bitmap - > granularity , bitmap - > dirtybytes ) ;
}
virBufferAdjustIndent ( buf , - 1 ) ;
}
static int
testQemuDetectBitmaps ( const void * opaque )
{
const char * name = opaque ;
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = NULL ;
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
size_t i ;
expectpath = g_strdup_printf ( " %s/%s%s.out " , abs_srcdir ,
bitmapDetectPrefix , name ) ;
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , name ,
" .json " , NULL ) ) )
return - 1 ;
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON " ) ;
return - 1 ;
}
/* we detect for the first 30 nodenames for simplicity */
for ( i = 0 ; i < 30 ; i + + ) {
g_autofree char * nodename = g_strdup_printf ( " libvirt-%zu-format " , i ) ;
testQemuDetectBitmapsWorker ( nodedata , nodename , & buf ) ;
}
actual = virBufferContentAndReset ( & buf ) ;
return virTestCompareToFile ( actual , expectpath ) ;
}
2019-12-12 18:01:22 +03:00
static virStorageSourcePtr
testQemuBackupIncrementalBitmapCalculateGetFakeImage ( size_t idx )
{
virStorageSourcePtr ret ;
if ( ! ( ret = virStorageSourceNew ( ) ) )
abort ( ) ;
2020-03-02 17:03:07 +03:00
ret - > id = idx ;
2019-12-12 18:01:22 +03:00
ret - > type = VIR_STORAGE_TYPE_FILE ;
ret - > format = VIR_STORAGE_FILE_QCOW2 ;
ret - > path = g_strdup_printf ( " /image%zu " , idx ) ;
ret - > nodestorage = g_strdup_printf ( " libvirt-%zu-storage " , idx ) ;
ret - > nodeformat = g_strdup_printf ( " libvirt-%zu-format " , idx ) ;
return ret ;
}
static virStorageSourcePtr
testQemuBackupIncrementalBitmapCalculateGetFakeChain ( void )
{
virStorageSourcePtr ret ;
virStorageSourcePtr n ;
size_t i ;
n = ret = testQemuBackupIncrementalBitmapCalculateGetFakeImage ( 1 ) ;
2020-03-02 17:03:07 +03:00
for ( i = 2 ; i < 6 ; i + + ) {
2019-12-12 18:01:22 +03:00
n - > backingStore = testQemuBackupIncrementalBitmapCalculateGetFakeImage ( i ) ;
n = n - > backingStore ;
}
return ret ;
}
2020-03-02 19:16:17 +03:00
static virStorageSourcePtr
testQemuBitmapGetFakeChainEntry ( virStorageSourcePtr src ,
size_t idx )
{
virStorageSourcePtr n ;
for ( n = src ; n ; n = n - > backingStore ) {
if ( n - > id = = idx )
return n ;
}
return NULL ;
}
2019-12-12 18:01:22 +03:00
typedef virDomainMomentDefPtr testMomentList ;
static void
testMomentListFree ( testMomentList * list )
{
testMomentList * tmp = list ;
if ( ! list )
return ;
while ( * tmp ) {
virObjectUnref ( * tmp ) ;
tmp + + ;
}
g_free ( list ) ;
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC ( testMomentList , testMomentListFree ) ;
static virDomainMomentDefPtr
testQemuBackupGetIncrementalMoment ( const char * name )
{
virDomainCheckpointDefPtr checkpoint = NULL ;
if ( ! ( checkpoint = virDomainCheckpointDefNew ( ) ) )
abort ( ) ;
2020-05-21 14:23:40 +03:00
checkpoint - > disks = g_new0 ( virDomainCheckpointDiskDef , 1 ) ;
checkpoint - > ndisks = 1 ;
checkpoint - > disks [ 0 ] . name = g_strdup ( " testdisk " ) ;
checkpoint - > disks [ 0 ] . type = VIR_DOMAIN_CHECKPOINT_TYPE_BITMAP ;
2019-12-12 18:01:22 +03:00
checkpoint - > parent . name = g_strdup ( name ) ;
return ( virDomainMomentDefPtr ) checkpoint ;
}
static virDomainMomentDefPtr *
testQemuBackupGetIncremental ( const char * incFrom )
{
const char * checkpoints [ ] = { " current " , " d " , " c " , " b " , " a " } ;
virDomainMomentDefPtr * incr ;
size_t i ;
incr = g_new0 ( virDomainMomentDefPtr , G_N_ELEMENTS ( checkpoints ) + 1 ) ;
for ( i = 0 ; i < G_N_ELEMENTS ( checkpoints ) ; i + + ) {
incr [ i ] = testQemuBackupGetIncrementalMoment ( checkpoints [ i ] ) ;
if ( STREQ ( incFrom , checkpoints [ i ] ) )
break ;
}
return incr ;
}
static const char * backupDataPrefix = " qemublocktestdata/backupmerge/ " ;
struct testQemuBackupIncrementalBitmapCalculateData {
const char * name ;
virStorageSourcePtr chain ;
const char * incremental ;
const char * nodedatafile ;
} ;
static int
testQemuBackupIncrementalBitmapCalculate ( const void * opaque )
{
const struct testQemuBackupIncrementalBitmapCalculateData * data = opaque ;
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
g_autoptr ( virJSONValue ) mergebitmaps = NULL ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = NULL ;
g_autoptr ( testMomentList ) incremental = NULL ;
expectpath = g_strdup_printf ( " %s/%s%s-out.json " , abs_srcdir ,
backupDataPrefix , data - > name ) ;
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , data - > nodedatafile ,
" .json " , NULL ) ) )
return - 1 ;
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON \n " ) ;
return - 1 ;
}
incremental = testQemuBackupGetIncremental ( data - > incremental ) ;
if ( ! ( mergebitmaps = qemuBackupDiskPrepareOneBitmapsChain ( incremental ,
data - > chain ,
nodedata ,
" testdisk " ) ) ) {
VIR_TEST_VERBOSE ( " failed to calculate merged bitmaps " ) ;
return - 1 ;
}
if ( ! ( actual = virJSONValueToString ( mergebitmaps , true ) ) )
return - 1 ;
return virTestCompareToFile ( actual , expectpath ) ;
}
2020-01-08 16:56:45 +03:00
static const char * checkpointDeletePrefix = " qemublocktestdata/checkpointdelete/ " ;
struct testQemuCheckpointDeleteMergeData {
const char * name ;
virStorageSourcePtr chain ;
const char * deletebitmap ;
const char * parentbitmap ;
2020-01-09 16:19:07 +03:00
const char * nodedatafile ;
2020-01-08 16:56:45 +03:00
} ;
static int
testQemuCheckpointDeleteMerge ( const void * opaque )
{
const struct testQemuCheckpointDeleteMergeData * data = opaque ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = NULL ;
g_autoptr ( virJSONValue ) actions = NULL ;
2020-01-09 16:19:07 +03:00
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
2020-01-09 19:34:29 +03:00
g_autoptr ( GSList ) reopenimages = NULL ;
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
GSList * tmp ;
2020-01-08 16:56:45 +03:00
expectpath = g_strdup_printf ( " %s/%s%s-out.json " , abs_srcdir ,
checkpointDeletePrefix , data - > name ) ;
2020-01-09 16:19:07 +03:00
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , data - > nodedatafile ,
" .json " , NULL ) ) )
2020-01-08 16:56:45 +03:00
return - 1 ;
2020-01-09 16:19:07 +03:00
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON \n " ) ;
return - 1 ;
}
2020-01-31 10:18:36 +03:00
actions = virJSONValueNewArray ( ) ;
2020-01-08 16:56:45 +03:00
if ( qemuCheckpointDiscardDiskBitmaps ( data - > chain ,
2020-01-09 16:19:07 +03:00
nodedata ,
2020-01-08 16:56:45 +03:00
data - > deletebitmap ,
data - > parentbitmap ,
2020-01-09 16:19:07 +03:00
actions ,
2020-01-09 19:34:29 +03:00
" testdisk " ,
& reopenimages ) < 0 ) {
2020-01-08 16:56:45 +03:00
VIR_TEST_VERBOSE ( " failed to generate checkpoint delete transaction \n " ) ;
return - 1 ;
}
2020-01-09 19:34:29 +03:00
if ( virJSONValueToBuffer ( actions , & buf , true ) < 0 )
2020-01-08 16:56:45 +03:00
return - 1 ;
2020-01-09 19:34:29 +03:00
if ( reopenimages ) {
virBufferAddLit ( & buf , " reopen nodes: \n " ) ;
for ( tmp = reopenimages ; tmp ; tmp = tmp - > next ) {
virStorageSourcePtr src = tmp - > data ;
virBufferAsprintf ( & buf , " %s \n " , src - > nodeformat ) ;
}
}
actual = virBufferContentAndReset ( & buf ) ;
2020-01-08 16:56:45 +03:00
return virTestCompareToFile ( actual , expectpath ) ;
}
2020-01-29 14:08:50 +03:00
struct testQemuBlockBitmapValidateData {
const char * name ;
const char * bitmapname ;
virStorageSourcePtr chain ;
bool expect ;
} ;
static int
testQemuBlockBitmapValidate ( const void * opaque )
{
const struct testQemuBlockBitmapValidateData * data = opaque ;
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
bool actual ;
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , data - > name ,
" .json " , NULL ) ) )
return - 1 ;
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON \n " ) ;
return - 1 ;
}
actual = qemuBlockBitmapChainIsValid ( data - > chain , data - > bitmapname , nodedata ) ;
if ( actual ! = data - > expect ) {
VIR_TEST_VERBOSE ( " expected rv:'%d' actual rv:'%d' \n " , data - > expect , actual ) ;
return - 1 ;
}
return 0 ;
}
2020-01-29 19:12:47 +03:00
static const char * blockcopyPrefix = " qemublocktestdata/bitmapblockcopy/ " ;
struct testQemuBlockBitmapBlockcopyData {
const char * name ;
bool shallow ;
virStorageSourcePtr chain ;
const char * nodedatafile ;
} ;
static int
testQemuBlockBitmapBlockcopy ( const void * opaque )
{
const struct testQemuBlockBitmapBlockcopyData * data = opaque ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = NULL ;
g_autoptr ( virJSONValue ) actions = NULL ;
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
g_autoptr ( virStorageSource ) fakemirror = virStorageSourceNew ( ) ;
if ( ! fakemirror )
return - 1 ;
fakemirror - > nodeformat = g_strdup ( " mirror-format-node " ) ;
expectpath = g_strdup_printf ( " %s/%s%s-out.json " , abs_srcdir ,
blockcopyPrefix , data - > name ) ;
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , data - > nodedatafile ,
" .json " , NULL ) ) )
return - 1 ;
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON \n " ) ;
return - 1 ;
}
if ( qemuBlockBitmapsHandleBlockcopy ( data - > chain , fakemirror , nodedata ,
data - > shallow , & actions ) < 0 )
return - 1 ;
if ( actions & &
! ( actual = virJSONValueToString ( actions , true ) ) )
return - 1 ;
return virTestCompareToFile ( actual , expectpath ) ;
}
2020-03-02 19:16:17 +03:00
static const char * blockcommitPrefix = " qemublocktestdata/bitmapblockcommit/ " ;
struct testQemuBlockBitmapBlockcommitData {
const char * name ;
virStorageSourcePtr top ;
virStorageSourcePtr base ;
virStorageSourcePtr chain ;
const char * nodedatafile ;
} ;
static int
testQemuBlockBitmapBlockcommit ( const void * opaque )
{
const struct testQemuBlockBitmapBlockcommitData * data = opaque ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = NULL ;
g_autoptr ( virJSONValue ) actionsDisable = NULL ;
g_autoptr ( virJSONValue ) actionsMerge = NULL ;
g_autoptr ( virJSONValue ) nodedatajson = NULL ;
g_autoptr ( virHashTable ) nodedata = NULL ;
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
VIR_AUTOSTRINGLIST bitmapsDisable = NULL ;
expectpath = g_strdup_printf ( " %s/%s%s " , abs_srcdir ,
blockcommitPrefix , data - > name ) ;
if ( ! ( nodedatajson = virTestLoadFileJSON ( bitmapDetectPrefix , data - > nodedatafile ,
" .json " , NULL ) ) )
return - 1 ;
if ( ! ( nodedata = qemuMonitorJSONBlockGetNamedNodeDataJSON ( nodedatajson ) ) ) {
VIR_TEST_VERBOSE ( " failed to load nodedata JSON \n " ) ;
return - 1 ;
}
if ( qemuBlockBitmapsHandleCommitStart ( data - > top , data - > base , nodedata ,
& actionsDisable , & bitmapsDisable ) < 0 )
return - 1 ;
virBufferAddLit ( & buf , " pre job bitmap disable: \n " ) ;
if ( actionsDisable & &
virJSONValueToBuffer ( actionsDisable , & buf , true ) < 0 )
return - 1 ;
virBufferAddLit ( & buf , " merge bitmpas: \n " ) ;
if ( qemuBlockBitmapsHandleCommitFinish ( data - > top , data - > base , nodedata ,
& actionsMerge , bitmapsDisable ) < 0 )
return - 1 ;
if ( actionsMerge & &
virJSONValueToBuffer ( actionsMerge , & buf , true ) < 0 )
return - 1 ;
actual = virBufferContentAndReset ( & buf ) ;
return virTestCompareToFile ( actual , expectpath ) ;
}
2020-01-29 19:12:47 +03:00
2017-11-03 17:20:55 +03:00
static int
mymain ( void )
{
int ret = 0 ;
2018-03-23 11:06:40 +03:00
virQEMUDriver driver ;
2018-03-16 19:11:29 +03:00
struct testBackingXMLjsonXMLdata xmljsonxmldata ;
2018-03-23 11:06:40 +03:00
struct testQemuDiskXMLToJSONData diskxmljsondata ;
2020-03-09 19:06:10 +03:00
struct testJSONtoJSONData jsontojsondata ;
2018-09-04 14:40:01 +03:00
struct testQemuImageCreateData imagecreatedata ;
2019-12-12 18:01:22 +03:00
struct testQemuBackupIncrementalBitmapCalculateData backupbitmapcalcdata ;
2020-01-08 16:56:45 +03:00
struct testQemuCheckpointDeleteMergeData checkpointdeletedata ;
2020-01-29 14:08:50 +03:00
struct testQemuBlockBitmapValidateData blockbitmapvalidatedata ;
2020-01-29 19:12:47 +03:00
struct testQemuBlockBitmapBlockcopyData blockbitmapblockcopydata ;
2020-03-02 19:16:17 +03:00
struct testQemuBlockBitmapBlockcommitData blockbitmapblockcommitdata ;
2018-03-23 11:06:40 +03:00
char * capslatest_x86_64 = NULL ;
virQEMUCapsPtr caps_x86_64 = NULL ;
2020-03-09 17:24:56 +03:00
g_autoptr ( virHashTable ) qmp_schema_x86_64 = NULL ;
2020-03-09 17:33:58 +03:00
virJSONValuePtr qmp_schemaroot_x86_64_blockdev_add = NULL ;
2019-12-12 18:01:22 +03:00
g_autoptr ( virStorageSource ) bitmapSourceChain = NULL ;
2018-03-23 11:06:40 +03:00
if ( qemuTestDriverInit ( & driver ) < 0 )
return EXIT_FAILURE ;
2019-12-12 18:01:22 +03:00
bitmapSourceChain = testQemuBackupIncrementalBitmapCalculateGetFakeChain ( ) ;
2018-03-23 11:06:40 +03:00
diskxmljsondata . driver = & driver ;
2018-09-04 14:40:01 +03:00
imagecreatedata . driver = & driver ;
2018-03-23 11:06:40 +03:00
2019-04-16 13:26:22 +03:00
if ( ! ( capslatest_x86_64 = testQemuGetLatestCapsForArch ( " x86_64 " , " xml " ) ) )
2018-03-23 11:06:40 +03:00
return EXIT_FAILURE ;
2019-05-03 11:45:58 +03:00
VIR_TEST_VERBOSE ( " \n latest caps x86_64: %s " , capslatest_x86_64 ) ;
2018-03-23 11:06:40 +03:00
if ( ! ( caps_x86_64 = qemuTestParseCapabilitiesArch ( virArchFromString ( " x86_64 " ) ,
capslatest_x86_64 ) ) )
return EXIT_FAILURE ;
diskxmljsondata . qemuCaps = caps_x86_64 ;
2018-09-04 14:40:01 +03:00
imagecreatedata . qemuCaps = caps_x86_64 ;
2017-11-03 17:20:55 +03:00
2020-05-15 17:21:25 +03:00
if ( ! ( qmp_schema_x86_64 = testQEMUSchemaLoadLatest ( " x86_64 " ) ) ) {
2020-03-09 17:24:56 +03:00
ret = - 1 ;
goto cleanup ;
}
2020-03-09 17:33:58 +03:00
if ( virQEMUQAPISchemaPathGet ( " blockdev-add/arg-type " ,
qmp_schema_x86_64 ,
& qmp_schemaroot_x86_64_blockdev_add ) < 0 | |
! qmp_schemaroot_x86_64_blockdev_add ) {
VIR_TEST_VERBOSE ( " failed to find schema entry for blockdev-add " ) ;
ret = - 1 ;
goto cleanup ;
}
2017-11-03 17:20:55 +03:00
virTestCounterReset ( " qemu storage source xml->json->xml " ) ;
2019-12-12 20:17:08 +03:00
# define TEST_JSON_FORMAT(tpe, xmlstr) \
2017-11-03 17:20:55 +03:00
do { \
2018-03-16 19:11:29 +03:00
xmljsonxmldata . type = tpe ; \
xmljsonxmldata . xml = xmlstr ; \
2020-03-09 17:39:04 +03:00
xmljsonxmldata . legacy = true ; \
if ( virTestRun ( virTestCounterNext ( ) , testBackingXMLjsonXML , \
& xmljsonxmldata ) < 0 ) \
xmljsonxmldata . legacy = false ; \
2018-03-16 19:11:29 +03:00
if ( virTestRun ( virTestCounterNext ( ) , testBackingXMLjsonXML , \
& xmljsonxmldata ) < 0 ) \
2017-11-03 17:20:55 +03:00
ret = - 1 ; \
} while ( 0 )
2019-12-12 20:17:08 +03:00
# define TEST_JSON_FORMAT_NET(xmlstr) \
2017-11-03 17:20:55 +03:00
TEST_JSON_FORMAT ( VIR_STORAGE_TYPE_NETWORK , xmlstr )
2020-03-09 17:39:04 +03:00
xmljsonxmldata . schema = qmp_schema_x86_64 ;
xmljsonxmldata . schemaroot = qmp_schemaroot_x86_64_blockdev_add ;
2017-11-03 17:20:55 +03:00
TEST_JSON_FORMAT ( VIR_STORAGE_TYPE_FILE , " <source file='/path/to/file'/> \n " ) ;
/* type VIR_STORAGE_TYPE_BLOCK is not tested since it parses back to 'file' */
/* type VIR_STORAGE_TYPE_DIR it is a 'format' driver in qemu */
2020-03-23 20:06:56 +03:00
TEST_JSON_FORMAT ( VIR_STORAGE_TYPE_NVME ,
" <source type='pci' namespace='1'> \n "
" <address domain='0x0000' bus='0x01' slot='0x00' function='0x0'/> \n "
" </source> \n " ) ;
2018-10-11 13:22:21 +03:00
TEST_JSON_FORMAT_NET ( " <source protocol='http' name=''> \n "
" <host name='example.com' port='80'/> \n "
" </source> \n " ) ;
2017-11-03 17:20:55 +03:00
TEST_JSON_FORMAT_NET ( " <source protocol='http' name='file'> \n "
" <host name='example.com' port='80'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='https' name='file'> \n "
" <host name='example.com' port='432'/> \n "
" </source> \n " ) ;
2020-03-06 10:13:06 +03:00
TEST_JSON_FORMAT_NET ( " <source protocol='https' name='file'> \n "
" <host name='example.com' port='432'/> \n "
" <ssl verify='no'/> \n "
" <readahead size='1024'/> \n "
" <timeout seconds='1337'/> \n "
" </source> \n " ) ;
2017-11-03 17:20:55 +03:00
TEST_JSON_FORMAT_NET ( " <source protocol='gluster' name='vol/file'> \n "
" <host name='example.com' port='24007'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='gluster' name='testvol/img.qcow2'> \n "
" <host name='example.com' port='1234'/> \n "
" <host transport='unix' socket='/path/socket'/> \n "
" <host name='example.com' port='24007'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='nbd'> \n "
" <host transport='unix' socket='/path/to/socket'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='nbd' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='nbd'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='ssh' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='rbd' name='libvirt/test'> \n "
" <host name='example.com' port='1234'/> \n "
" <host name='example2.com'/> \n "
" <snapshot name='snapshotname'/> \n "
" <config file='/path/to/conf'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/0'> \n "
" <host name='test.org' port='3260'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/6'> \n "
" <host name='test.org' port='1234'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='sheepdog' name='test'> \n "
" <host name='example.com' port='321'/> \n "
" </source> \n " ) ;
TEST_JSON_FORMAT_NET ( " <source protocol='vxhs' name='c6718f6b-0401-441d-a8c3-1f0064d75ee0'> \n "
" <host name='example.com' port='9999'/> \n "
" </source> \n " ) ;
2019-12-12 20:17:08 +03:00
# define TEST_DISK_TO_JSON_FULL(nme, fl) \
2018-03-23 11:06:40 +03:00
do { \
diskxmljsondata . name = nme ; \
2020-03-23 14:10:38 +03:00
diskxmljsondata . images = NULL ; \
diskxmljsondata . nimages = 0 ; \
2018-03-23 11:06:40 +03:00
diskxmljsondata . fail = fl ; \
if ( virTestRun ( " disk xml to props " nme , testQemuDiskXMLToProps , \
& diskxmljsondata ) < 0 ) \
ret = - 1 ; \
if ( virTestRun ( " disk xml to props validate schema " nme , \
testQemuDiskXMLToPropsValidateSchema , & diskxmljsondata ) < 0 ) \
ret = - 1 ; \
if ( virTestRun ( " disk xml to props validate file " nme , \
testQemuDiskXMLToPropsValidateFile , & diskxmljsondata ) < 0 ) \
ret = - 1 ; \
2018-12-17 18:29:05 +03:00
if ( virTestRun ( " disk xml to props source only validate file " nme , \
testQemuDiskXMLToPropsValidateFileSrcOnly , & diskxmljsondata ) < 0 ) \
ret = - 1 ; \
2018-03-23 11:06:40 +03:00
testQemuDiskXMLToPropsClear ( & diskxmljsondata ) ; \
} while ( 0 )
2019-12-12 20:17:08 +03:00
# define TEST_DISK_TO_JSON(nme) TEST_DISK_TO_JSON_FULL(nme, false)
2018-03-23 11:06:40 +03:00
2020-03-09 17:24:56 +03:00
diskxmljsondata . schema = qmp_schema_x86_64 ;
2020-03-09 17:33:58 +03:00
diskxmljsondata . schemaroot = qmp_schemaroot_x86_64_blockdev_add ;
2018-03-23 11:06:40 +03:00
TEST_DISK_TO_JSON_FULL ( " nodename-long-format " , true ) ;
TEST_DISK_TO_JSON_FULL ( " nodename-long-protocol " , true ) ;
2018-03-28 10:40:03 +03:00
TEST_DISK_TO_JSON ( " file-raw-noopts " ) ;
tests: qemublock: Add tests for all other format without special options
Similarly to the 'raw' case add tests for bochs, cloop, dmg, ploop, vdi
vhd, and vpc. Covering all supported non-backing formats.
Note that the JSON name for 'ploop' maps to 'parallels' and 'vhd' maps
to 'vhdx'.
Files added here would result in the followint configs:
file-bochs-noopts.xml:
-drive file=/path/to/i.img,format=bochs,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-cloop-noopts.xml:
-drive file=/path/to/i.img,format=cloop,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-dmg-noopts.xml:
-drive file=/path/to/i.img,format=dmg,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-ploop-noopts.xml:
-drive file=/path/to/i.img,format=ploop,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-vdi-noopts.xml:
-drive file=/path/to/i.img,format=vdi,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-vhd-noopts.xml:
-drive file=/path/to/i.img,format=vhd,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-vpc-noopts.xml:
-drive file=/path/to/i.img,format=vpc,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-03-28 11:11:38 +03:00
TEST_DISK_TO_JSON ( " file-bochs-noopts " ) ;
TEST_DISK_TO_JSON ( " file-cloop-noopts " ) ;
TEST_DISK_TO_JSON ( " file-dmg-noopts " ) ;
TEST_DISK_TO_JSON ( " file-ploop-noopts " ) ;
TEST_DISK_TO_JSON ( " file-vdi-noopts " ) ;
TEST_DISK_TO_JSON ( " file-vhd-noopts " ) ;
TEST_DISK_TO_JSON ( " file-vpc-noopts " ) ;
2018-03-28 10:40:03 +03:00
2018-03-28 11:27:14 +03:00
TEST_DISK_TO_JSON ( " file-backing_basic-noopts " ) ;
2018-03-19 10:00:19 +03:00
TEST_DISK_TO_JSON ( " dir-fat-readonly " ) ;
TEST_DISK_TO_JSON ( " dir-fat-floppy " ) ;
tests: qemublock: Add test cases for 'aio' options of 'file' storage
Test that the 'aio' option is applied correctly for the 'file' protocol
backend and across the backing chain.
The top level disk image would generate the following '-drive' cmdline:
file-backing_basic-aio_threads:
-drive file=/var/lib/libvirt/images/a,format=qcow,if=none,id=drive-dummy,aio=threads
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-raw-aio_native:
-drive file=/path/to/i.img,format=raw,if=none,id=drive-dummy,cache=none,aio=native
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-03-19 10:59:19 +03:00
TEST_DISK_TO_JSON ( " file-raw-aio_native " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-aio_threads " ) ;
2020-04-21 15:19:37 +03:00
TEST_DISK_TO_JSON ( " file-backing_basic-aio_io_uring " ) ;
2018-04-19 17:16:44 +03:00
TEST_DISK_TO_JSON ( " file-raw-luks " ) ;
tests: qemublock: basic qcow2 tests
Add tests for backing chain handling, including a very long chain which
is fully specified in the XML and an unterminated chain.
The top level disk image would generate the following '-drive':
file-qcow2-backing-chain-encryption.xml:
-drive file=/var/lib/libvirt/images/a,encrypt.format=luks,
encrypt.key-secret=node-b-f-encalias,format=qcow2,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-qcow2-backing-chain-noopts.xml:
-drive file=/var/lib/libvirt/images/rhel7.3.1507297895,format=qcow2,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-qcow2-backing-chain-unterminated.xml:
-drive file=/var/lib/libvirt/images/rhel7.3.1507297895,format=qcow2,if=none,id=drive-dummy
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-03-16 19:56:16 +03:00
TEST_DISK_TO_JSON ( " file-qcow2-backing-chain-noopts " ) ;
TEST_DISK_TO_JSON ( " file-qcow2-backing-chain-unterminated " ) ;
TEST_DISK_TO_JSON ( " file-qcow2-backing-chain-encryption " ) ;
2018-03-19 14:51:20 +03:00
TEST_DISK_TO_JSON ( " network-qcow2-backing-chain-encryption_auth " ) ;
2018-03-28 11:27:14 +03:00
tests: qemublock: Test handling of 'unmap' and 'detect-zeroes' options
The test cases would correspond to the following -drive command lines:
file-backing_basic-detect.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow,if=none,id=drive-dummy,detect-zeroes=on
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-backing_basic-unmap-detect.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow,if=none,id=drive-dummy,discard=unmap,detect-zeroes=unmap
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-backing_basic-unmap-ignore.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow,if=none,id=drive-dummy,discard=ignore,detect-zeroes=on
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
file-backing_basic-unmap.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow,if=none,id=drive-dummy,discard=unmap
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-04-06 15:07:44 +03:00
TEST_DISK_TO_JSON ( " file-backing_basic-unmap " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-unmap-detect " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-unmap-ignore " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-detect " ) ;
tests: qemublock: Test handling of all cache modes
The test cases would correspond to the following -drive command lines:
dir-fat-cache.xml:
-drive file=fat:/var/somefiles,if=none,id=drive-dummy,readonly=on,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
file-backing_basic-cache-directsync.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
file-backing_basic-cache-none.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=none
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-unsafe.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=unsafe
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-writeback.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=writeback
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-writethrough.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=writethrough
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
network-qcow2-backing-chain-cache-unsafe.xml:
-drive file=rbd:rbdpool/rbdimg:id=testuser-rbd:auth_supported=cephx\;none:
mon_host=host1.example.com\;host2.example.com,
file.password-secret=node-a-s-secalias,format=qcow2,
if=none,id=drive-dummy,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-04-06 15:24:51 +03:00
TEST_DISK_TO_JSON ( " file-backing_basic-cache-none " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-cache-writethrough " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-cache-writeback " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-cache-directsync " ) ;
TEST_DISK_TO_JSON ( " file-backing_basic-cache-unsafe " ) ;
TEST_DISK_TO_JSON ( " network-qcow2-backing-chain-cache-unsafe " ) ;
TEST_DISK_TO_JSON ( " dir-fat-cache " ) ;
2018-05-30 16:28:24 +03:00
TEST_DISK_TO_JSON ( " network-nbd-tls " ) ;
2020-03-23 18:36:22 +03:00
TEST_DISK_TO_JSON ( " network-http-noopts " ) ;
TEST_DISK_TO_JSON ( " network-http-curlopts " ) ;
tests: qemublock: Test handling of all cache modes
The test cases would correspond to the following -drive command lines:
dir-fat-cache.xml:
-drive file=fat:/var/somefiles,if=none,id=drive-dummy,readonly=on,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
file-backing_basic-cache-directsync.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
file-backing_basic-cache-none.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=none
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-unsafe.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=unsafe
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-writeback.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=writeback
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=on
file-backing_basic-cache-writethrough.xml:
-drive file=/var/lib/libvirt/images/a,format=qcow2,if=none,id=drive-dummy,cache=writethrough
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
network-qcow2-backing-chain-cache-unsafe.xml:
-drive file=rbd:rbdpool/rbdimg:id=testuser-rbd:auth_supported=cephx\;none:
mon_host=host1.example.com\;host2.example.com,
file.password-secret=node-a-s-secalias,format=qcow2,
if=none,id=drive-dummy,cache=directsync
-device virtio-blk-pci,scsi=off,drive=drive-dummy,id=dummy,write-cache=off
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-04-06 15:24:51 +03:00
2018-04-25 16:53:18 +03:00
TEST_DISK_TO_JSON ( " block-raw-noopts " ) ;
2018-05-30 16:47:13 +03:00
TEST_DISK_TO_JSON ( " block-raw-reservations " ) ;
2018-04-25 16:53:18 +03:00
2020-03-18 20:49:10 +03:00
TEST_DISK_TO_JSON ( " nvme-raw-noopts " ) ;
2020-03-09 19:06:10 +03:00
# define TEST_JSON_TO_JSON(nme) \
do { \
jsontojsondata . name = nme ; \
if ( virTestRun ( " JSON to JSON " nme , testJSONtoJSON , \
& jsontojsondata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
jsontojsondata . schema = qmp_schema_x86_64 ;
jsontojsondata . schemaroot = qmp_schemaroot_x86_64_blockdev_add ;
TEST_JSON_TO_JSON ( " curl-libguestfs " ) ;
2020-03-09 17:05:58 +03:00
TEST_JSON_TO_JSON ( " ssh-passthrough-libguestfs " ) ;
2020-03-09 19:06:10 +03:00
2019-12-12 20:17:08 +03:00
# define TEST_IMAGE_CREATE(testname, testbacking) \
2018-09-04 14:40:01 +03:00
do { \
imagecreatedata . name = testname ; \
imagecreatedata . backingname = testbacking ; \
if ( virTestRun ( " image create xml to props " testname , testQemuImageCreate , \
& imagecreatedata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
2020-03-09 17:24:56 +03:00
imagecreatedata . schema = qmp_schema_x86_64 ;
2018-09-04 14:40:01 +03:00
if ( virQEMUQAPISchemaPathGet ( " blockdev-create/arg-type/options " ,
imagecreatedata . schema ,
& imagecreatedata . schemaroot ) < 0 | |
! imagecreatedata . schemaroot ) {
VIR_TEST_VERBOSE ( " failed to find schema entry for blockdev-create \n " ) ;
ret = - 1 ;
goto cleanup ;
}
TEST_IMAGE_CREATE ( " raw " , NULL ) ;
TEST_IMAGE_CREATE ( " raw-nbd " , NULL ) ;
TEST_IMAGE_CREATE ( " luks-noopts " , NULL ) ;
TEST_IMAGE_CREATE ( " luks-encopts " , NULL ) ;
TEST_IMAGE_CREATE ( " qcow2 " , NULL ) ;
TEST_IMAGE_CREATE ( " qcow2-luks-noopts " , NULL ) ;
TEST_IMAGE_CREATE ( " qcow2-luks-encopts " , NULL ) ;
TEST_IMAGE_CREATE ( " qcow2-backing-raw " , " raw " ) ;
TEST_IMAGE_CREATE ( " qcow2-backing-raw-nbd " , " raw-nbd " ) ;
TEST_IMAGE_CREATE ( " qcow2-backing-luks " , " luks-noopts " ) ;
TEST_IMAGE_CREATE ( " qcow2-luks-encopts-backing " , " qcow2 " ) ;
2020-02-12 19:26:18 +03:00
TEST_IMAGE_CREATE ( " qcow2-backing-raw-slice " , " raw-slice " ) ;
TEST_IMAGE_CREATE ( " qcow2-backing-qcow2-slice " , " qcow2-slice " ) ;
2018-09-04 14:40:01 +03:00
TEST_IMAGE_CREATE ( " network-gluster-qcow2 " , NULL ) ;
TEST_IMAGE_CREATE ( " network-rbd-qcow2 " , NULL ) ;
TEST_IMAGE_CREATE ( " network-ssh-qcow2 " , NULL ) ;
TEST_IMAGE_CREATE ( " network-sheepdog-qcow2 " , NULL ) ;
2019-12-12 20:17:08 +03:00
# define TEST_BITMAP_DETECT(testname) \
2019-12-12 15:37:01 +03:00
do { \
if ( virTestRun ( " bitmap detect " testname , \
testQemuDetectBitmaps , testname ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
2020-05-28 17:19:07 +03:00
TEST_BITMAP_DETECT ( " empty " ) ;
2019-12-12 15:37:01 +03:00
TEST_BITMAP_DETECT ( " basic " ) ;
2019-12-12 15:47:40 +03:00
TEST_BITMAP_DETECT ( " synthetic " ) ;
2019-12-12 15:50:55 +03:00
TEST_BITMAP_DETECT ( " snapshots " ) ;
2020-01-09 17:32:49 +03:00
TEST_BITMAP_DETECT ( " snapshots-synthetic-checkpoint " ) ;
2020-01-29 17:48:36 +03:00
TEST_BITMAP_DETECT ( " snapshots-synthetic-broken " ) ;
2019-12-12 15:37:01 +03:00
2019-12-12 20:17:08 +03:00
# define TEST_BACKUP_BITMAP_CALCULATE(testname, source, incrbackup, named) \
2019-12-12 18:01:22 +03:00
do { \
backupbitmapcalcdata . name = testname ; \
backupbitmapcalcdata . chain = source ; \
backupbitmapcalcdata . incremental = incrbackup ; \
backupbitmapcalcdata . nodedatafile = named ; \
if ( virTestRun ( " incremental backup bitmap " testname , \
testQemuBackupIncrementalBitmapCalculate , \
& backupbitmapcalcdata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
TEST_BACKUP_BITMAP_CALCULATE ( " basic-flat " , bitmapSourceChain , " current " , " basic " ) ;
TEST_BACKUP_BITMAP_CALCULATE ( " basic-intermediate " , bitmapSourceChain , " d " , " basic " ) ;
TEST_BACKUP_BITMAP_CALCULATE ( " basic-deep " , bitmapSourceChain , " a " , " basic " ) ;
2019-12-12 18:03:22 +03:00
TEST_BACKUP_BITMAP_CALCULATE ( " snapshot-flat " , bitmapSourceChain , " current " , " snapshots " ) ;
TEST_BACKUP_BITMAP_CALCULATE ( " snapshot-intermediate " , bitmapSourceChain , " d " , " snapshots " ) ;
TEST_BACKUP_BITMAP_CALCULATE ( " snapshot-deep " , bitmapSourceChain , " a " , " snapshots " ) ;
2020-01-09 16:19:07 +03:00
# define TEST_CHECKPOINT_DELETE_MERGE(testname, delbmp, parbmp, named) \
2020-01-08 16:56:45 +03:00
do { \
checkpointdeletedata . name = testname ; \
checkpointdeletedata . chain = bitmapSourceChain ; \
checkpointdeletedata . deletebitmap = delbmp ; \
checkpointdeletedata . parentbitmap = parbmp ; \
2020-01-09 16:19:07 +03:00
checkpointdeletedata . nodedatafile = named ; \
2020-01-08 16:56:45 +03:00
if ( virTestRun ( " checkpoint delete " testname , \
testQemuCheckpointDeleteMerge , & checkpointdeletedata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
2020-01-09 16:19:07 +03:00
TEST_CHECKPOINT_DELETE_MERGE ( " basic-noparent " , " a " , NULL , " basic " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " basic-intermediate1 " , " b " , " a " , " basic " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " basic-intermediate2 " , " c " , " b " , " basic " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " basic-intermediate3 " , " d " , " c " , " basic " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " basic-current " , " current " , " d " , " basic " ) ;
2020-01-08 16:56:45 +03:00
2020-01-09 17:10:43 +03:00
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-noparent " , " a " , NULL , " snapshots " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-intermediate1 " , " b " , " a " , " snapshots " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-intermediate2 " , " c " , " b " , " snapshots " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-intermediate3 " , " d " , " c " , " snapshots " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-current " , " current " , " d " , " snapshots " ) ;
2020-01-09 18:37:43 +03:00
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-synthetic-checkpoint-noparent " , " a " , NULL , " snapshots-synthetic-checkpoint " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-synthetic-checkpoint-intermediate1 " , " b " , " a " , " snapshots-synthetic-checkpoint " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-synthetic-checkpoint-intermediate2 " , " c " , " b " , " snapshots-synthetic-checkpoint " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-synthetic-checkpoint-intermediate3 " , " d " , " c " , " snapshots-synthetic-checkpoint " ) ;
TEST_CHECKPOINT_DELETE_MERGE ( " snapshots-synthetic-checkpoint-current " , " current " , " d " , " snapshots-synthetic-checkpoint " ) ;
2020-01-29 14:08:50 +03:00
# define TEST_BITMAP_VALIDATE(testname, bitmap, rc) \
do { \
blockbitmapvalidatedata . name = testname ; \
blockbitmapvalidatedata . chain = bitmapSourceChain ; \
blockbitmapvalidatedata . bitmapname = bitmap ; \
blockbitmapvalidatedata . expect = rc ; \
if ( virTestRun ( " bitmap validate " testname " " bitmap , \
testQemuBlockBitmapValidate , \
& blockbitmapvalidatedata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
2020-01-09 18:37:43 +03:00
2020-05-28 17:19:07 +03:00
TEST_BITMAP_VALIDATE ( " empty " , " a " , false ) ;
2020-01-29 14:08:50 +03:00
TEST_BITMAP_VALIDATE ( " basic " , " a " , true ) ;
TEST_BITMAP_VALIDATE ( " basic " , " b " , true ) ;
TEST_BITMAP_VALIDATE ( " basic " , " c " , true ) ;
TEST_BITMAP_VALIDATE ( " basic " , " d " , true ) ;
TEST_BITMAP_VALIDATE ( " basic " , " current " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots " , " a " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots " , " b " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots " , " c " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots " , " d " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots " , " current " , true ) ;
TEST_BITMAP_VALIDATE ( " synthetic " , " a " , false ) ;
TEST_BITMAP_VALIDATE ( " synthetic " , " b " , true ) ;
TEST_BITMAP_VALIDATE ( " synthetic " , " c " , true ) ;
TEST_BITMAP_VALIDATE ( " synthetic " , " d " , true ) ;
TEST_BITMAP_VALIDATE ( " synthetic " , " current " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-checkpoint " , " a " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-checkpoint " , " b " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-checkpoint " , " c " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-checkpoint " , " d " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-checkpoint " , " current " , true ) ;
2020-01-29 17:48:36 +03:00
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-broken " , " a " , false ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-broken " , " b " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-broken " , " c " , true ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-broken " , " d " , false ) ;
TEST_BITMAP_VALIDATE ( " snapshots-synthetic-broken " , " current " , true ) ;
2020-01-29 19:12:47 +03:00
# define TEST_BITMAP_BLOCKCOPY(testname, shllw, ndf) \
do { \
blockbitmapblockcopydata . name = testname ; \
blockbitmapblockcopydata . shallow = shllw ; \
blockbitmapblockcopydata . nodedatafile = ndf ; \
blockbitmapblockcopydata . chain = bitmapSourceChain ; \
if ( virTestRun ( " bitmap block copy " testname , \
testQemuBlockBitmapBlockcopy , \
& blockbitmapblockcopydata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
TEST_BITMAP_BLOCKCOPY ( " basic-shallow " , true , " basic " ) ;
TEST_BITMAP_BLOCKCOPY ( " basic-deep " , false , " basic " ) ;
TEST_BITMAP_BLOCKCOPY ( " snapshots-shallow " , true , " snapshots " ) ;
TEST_BITMAP_BLOCKCOPY ( " snapshots-deep " , false , " snapshots " ) ;
2020-03-02 19:16:17 +03:00
# define TEST_BITMAP_BLOCKCOMMIT(testname, topimg, baseimg, ndf) \
do { \
blockbitmapblockcommitdata . name = testname ; \
blockbitmapblockcommitdata . top = testQemuBitmapGetFakeChainEntry ( bitmapSourceChain , topimg ) ; \
blockbitmapblockcommitdata . base = testQemuBitmapGetFakeChainEntry ( bitmapSourceChain , baseimg ) ; \
blockbitmapblockcommitdata . nodedatafile = ndf ; \
if ( virTestRun ( " bitmap block commit " testname , \
testQemuBlockBitmapBlockcommit , \
& blockbitmapblockcommitdata ) < 0 ) \
ret = - 1 ; \
} while ( 0 )
TEST_BITMAP_BLOCKCOMMIT ( " basic-1-2 " , 1 , 2 , " basic " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " basic-1-3 " , 1 , 3 , " basic " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " basic-2-3 " , 2 , 3 , " basic " ) ;
2020-03-02 19:26:05 +03:00
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-1-2 " , 1 , 2 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-1-3 " , 1 , 3 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-1-4 " , 1 , 4 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-1-5 " , 1 , 5 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-2-3 " , 2 , 3 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-2-4 " , 2 , 4 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-2-5 " , 2 , 5 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-3-4 " , 3 , 4 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-3-5 " , 3 , 5 , " snapshots " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-4-5 " , 4 , 5 , " snapshots " ) ;
2020-03-04 19:25:03 +03:00
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-1-2 " , 1 , 2 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-1-3 " , 1 , 3 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-1-4 " , 1 , 4 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-1-5 " , 1 , 5 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-2-3 " , 2 , 3 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-2-4 " , 2 , 4 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-2-5 " , 2 , 5 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-3-4 " , 3 , 4 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-3-5 " , 3 , 5 , " snapshots-synthetic-broken " ) ;
TEST_BITMAP_BLOCKCOMMIT ( " snapshots-synthetic-broken-4-5 " , 4 , 5 , " snapshots-synthetic-broken " ) ;
2020-03-02 19:26:05 +03:00
2018-03-23 11:06:40 +03:00
cleanup :
qemuTestDriverFree ( & driver ) ;
VIR_FREE ( capslatest_x86_64 ) ;
virObjectUnref ( caps_x86_64 ) ;
2017-11-03 17:20:55 +03:00
return ret = = 0 ? EXIT_SUCCESS : EXIT_FAILURE ;
}
2020-01-29 19:12:47 +03:00
VIR_TEST_MAIN_PRELOAD ( mymain , VIR_TEST_MOCK ( " virdeterministichash " ) )