ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* Fixes for compiling QEMU on Alpine Linux 

* Add Alpine Linux to the gitlab-CI
 * Some small fixes for qtests
 * Updates to the MAINTAINERS file
 -----BEGIN PGP SIGNATURE-----
 
 iQJFBAABCAAvFiEEJ7iIR+7gJQEY8+q5LtnXdP5wLbUFAmAIKG4RHHRodXRoQHJl
 ZGhhdC5jb20ACgkQLtnXdP5wLbWTsg//Vz+8g+fLIkZJcfOdH1Fup/tjTLLGiDo2
 SjMrWmjoRqygI+Ho0fr+mrl9t2Fq5dYOuKRJuXY9NfWFHK4STa97PJkhEwMeXayf
 QGIYRs8TB7u83y+JcaW/I8EBMxEpQrBmnuiQo/cHhQ3HIg3CGqGPU/v135AUhLNl
 IP3OMCmwQzgr8a0kad6FT24xOF6xDQ0NkLF7x+naq+mc+DHajZmrV+MP/tTpzH26
 u065dGORE3zvmGNm8BVm6rPuZINUc8fjQiTZMHvNkjLACXtIMmYQpV7B2G7WISns
 BBQ4qg6aC67bTK4Q4zZzO9q8HDqb1AlzywSloWEG6w0fuKEN+XcWxHvjz6EDxQpZ
 +N2pEAkobqfS2GzSdqR8grMQ2T1bRhswXDCloNg8ehfqD96CbL4+4g8eieUtu9JU
 2G4UOs91yAljP4LsUEa4LROboGXvLBavzi/WJaDEWPrrFBOhXFiGKWVrQ2ubN/FJ
 JwId1oEPqbPZLg+PhXYrhoOT285vwVfjurnSoY02iUhQO/rNOEaQHGOvZRbZH2VE
 1x+bTxQNPe4cNFOo1vVJ+cgVel38wwU8JHX2jrcwHB6DC1LMRjf+I+v//jmxBp7j
 x4iS0+b7BuNFzmpA54MNjmmyDIZl1M6EaGd6dyksu625ND2jHi8ycm+Y4oDa8kYY
 0MR0zrLTeCw=
 =vjqN
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2021-01-20' into staging

* Fixes for compiling QEMU on Alpine Linux
* Add Alpine Linux to the gitlab-CI
* Some small fixes for qtests
* Updates to the MAINTAINERS file

# gpg: Signature made Wed 20 Jan 2021 12:56:14 GMT
# gpg:                using RSA key 27B88847EEE0250118F3EAB92ED9D774FE702DB5
# gpg:                issuer "thuth@redhat.com"
# gpg: Good signature from "Thomas Huth <th.huth@gmx.de>" [full]
# gpg:                 aka "Thomas Huth <thuth@redhat.com>" [full]
# gpg:                 aka "Thomas Huth <huth@tuxfamily.org>" [full]
# gpg:                 aka "Thomas Huth <th.huth@posteo.de>" [unknown]
# Primary key fingerprint: 27B8 8847 EEE0 2501 18F3  EAB9 2ED9 D774 FE70 2DB5

* remotes/huth-gitlab/tags/pull-request-2021-01-20:
  MAINTAINERS: Make status spellings consistent
  MAINTAINERS: Remove Ben Warren
  tests: Fix memory leak in tpm-util.c
  qtest/npcm7xx_pwm-test: Fix memleak in pwm_qom_get
  gitlab-ci: Add alpine to pipeline
  tests/check-block.sh: Refuse to run the iotests with BusyBox' sed
  tests/docker: Add dockerfile for Alpine Linux
  accel/kvm: avoid using predefined PAGE_SIZE
  tests: Rename PAGE_SIZE definitions
  elf2dmp: Rename PAGE_SIZE to ELF2DMP_PAGE_SIZE
  hw/block/nand: Rename PAGE_SIZE to NAND_PAGE_SIZE
  libvhost-user: Include poll.h instead of sys/poll.h
  configure: Add sys/timex.h to probe clock_adjtime
  osdep.h: Remove <sys/signal.h> include

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2021-01-20 17:44:31 +00:00
parent 48202c7124 4251dfb082
commit 954b83f132
22 changed files with 224 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitlab-ci.d/containers.yml
View File

@ -28,6 +28,11 @@
- if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH' - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
- if: '$CI_COMMIT_REF_NAME == "testing/next"' - if: '$CI_COMMIT_REF_NAME == "testing/next"'
amd64-alpine-container:
<<: *container_job_definition
variables:
NAME: alpine
amd64-centos7-container: amd64-centos7-container:
<<: *container_job_definition <<: *container_job_definition
variables: variables:

33
.gitlab-ci.yml
View File

@ -72,6 +72,39 @@ include:
- cd build - cd build
- du -chs ${CI_PROJECT_DIR}/avocado-cache - du -chs ${CI_PROJECT_DIR}/avocado-cache
build-system-alpine:
<<: *native_build_job_definition
variables:
IMAGE: alpine
TARGETS: aarch64-softmmu alpha-softmmu cris-softmmu hppa-softmmu
moxie-softmmu microblazeel-softmmu mips64el-softmmu
MAKE_CHECK_ARGS: check-build
CONFIGURE_ARGS: --enable-docs
artifacts:
expire_in: 2 days
paths:
- .git-submodule-status
- build
check-system-alpine:
<<: *native_test_job_definition
needs:
- job: build-system-alpine
artifacts: true
variables:
IMAGE: alpine
MAKE_CHECK_ARGS: check
acceptance-system-alpine:
<<: *native_test_job_definition
needs:
- job: build-system-alpine
artifacts: true
variables:
IMAGE: alpine
MAKE_CHECK_ARGS: check-acceptance
<<: *acceptance_definition
build-system-ubuntu: build-system-ubuntu:
<<: *native_build_job_definition <<: *native_build_job_definition
variables: variables:

13
MAINTAINERS
View File

@ -1142,7 +1142,7 @@ F: tests/acceptance/machine_mips_malta.py
Mipssim Mipssim
R: Aleksandar Rikalo <aleksandar.rikalo@syrmia.com> R: Aleksandar Rikalo <aleksandar.rikalo@syrmia.com>
S: Orphaned S: Orphan
F: hw/mips/mipssim.c F: hw/mips/mipssim.c
F: hw/net/mipsnet.c F: hw/net/mipsnet.c
@ -1999,8 +1999,7 @@ F: include/hw/nvram/chrp_nvram.h
F: tests/qtest/prom-env-test.c F: tests/qtest/prom-env-test.c
VM Generation ID VM Generation ID
M: Ben Warren <ben@skyportsystems.com> S: Orphan
S: Maintained
F: hw/acpi/vmgenid.c F: hw/acpi/vmgenid.c
F: include/hw/acpi/vmgenid.h F: include/hw/acpi/vmgenid.h
F: docs/specs/vmgenid.txt F: docs/specs/vmgenid.txt
@ -2444,7 +2443,7 @@ T: git https://gitlab.com/jsnow/qemu.git python
Python scripts Python scripts
M: Eduardo Habkost <ehabkost@redhat.com> M: Eduardo Habkost <ehabkost@redhat.com>
M: Cleber Rosa <crosa@redhat.com> M: Cleber Rosa <crosa@redhat.com>
S: Odd fixes S: Odd Fixes
F: scripts/*.py F: scripts/*.py
F: tests/*.py F: tests/*.py
@ -2681,7 +2680,7 @@ F: tests/test-coroutine.c
Buffers Buffers
M: Daniel P. Berrange <berrange@redhat.com> M: Daniel P. Berrange <berrange@redhat.com>
S: Odd fixes S: Odd Fixes
F: util/buffer.c F: util/buffer.c
F: include/qemu/buffer.h F: include/qemu/buffer.h
@ -2710,7 +2709,7 @@ F: qapi/sockets.json
File monitor File monitor
M: Daniel P. Berrange <berrange@redhat.com> M: Daniel P. Berrange <berrange@redhat.com>
S: Odd fixes S: Odd Fixes
F: util/filemonitor*.c F: util/filemonitor*.c
F: include/qemu/filemonitor.h F: include/qemu/filemonitor.h
F: tests/test-util-filemonitor.c F: tests/test-util-filemonitor.c
@ -3264,7 +3263,7 @@ S: Odd Fixes
F: scripts/git-submodule.sh F: scripts/git-submodule.sh
UI translations UI translations
S: Orphaned S: Orphan
F: po/*.po F: po/*.po
Sphinx documentation configuration and build machinery Sphinx documentation configuration and build machinery

3
accel/kvm/kvm-all.c
View File

@ -58,6 +58,9 @@
/* KVM uses PAGE_SIZE in its definition of KVM_COALESCED_MMIO_MAX. We /* KVM uses PAGE_SIZE in its definition of KVM_COALESCED_MMIO_MAX. We
* need to use the real host PAGE_SIZE, as that's what KVM will use. * need to use the real host PAGE_SIZE, as that's what KVM will use.
*/ */
#ifdef PAGE_SIZE
#undef PAGE_SIZE
#endif
#define PAGE_SIZE qemu_real_host_page_size #define PAGE_SIZE qemu_real_host_page_size
//#define DEBUG_KVM //#define DEBUG_KVM

1
configure vendored
View File

@ -4039,6 +4039,7 @@ fi
clock_adjtime=no clock_adjtime=no
cat > $TMPC <<EOF cat > $TMPC <<EOF
#include <time.h> #include <time.h>
#include <sys/timex.h>
int main(void) int main(void)
{ {

4
contrib/elf2dmp/addrspace.c
View File

@ -207,8 +207,8 @@ int va_space_rw(struct va_space *vs, uint64_t addr,
void *buf, size_t size, int is_write) void *buf, size_t size, int is_write)
{ {
while (size) { while (size) {
uint64_t page = addr & PFN_MASK; uint64_t page = addr & ELF2DMP_PFN_MASK;
size_t s = (page + PAGE_SIZE) - addr; size_t s = (page + ELF2DMP_PAGE_SIZE) - addr;
void *ptr; void *ptr;
s = (s > size) ? size : s; s = (s > size) ? size : s;

6
contrib/elf2dmp/addrspace.h
View File

@ -10,9 +10,9 @@
#include "qemu_elf.h" #include "qemu_elf.h"
#define PAGE_BITS 12 #define ELF2DMP_PAGE_BITS 12
#define PAGE_SIZE (1ULL << PAGE_BITS) #define ELF2DMP_PAGE_SIZE (1ULL << ELF2DMP_PAGE_BITS)
#define PFN_MASK (~(PAGE_SIZE - 1)) #define ELF2DMP_PFN_MASK (~(ELF2DMP_PAGE_SIZE - 1))
#define INVALID_PA UINT64_MAX #define INVALID_PA UINT64_MAX

18
contrib/elf2dmp/main.c
View File

@ -244,8 +244,8 @@ static int fill_header(WinDumpHeader64 *hdr, struct pa_space *ps,
WinDumpHeader64 h; WinDumpHeader64 h;
size_t i; size_t i;
QEMU_BUILD_BUG_ON(KUSD_OFFSET_SUITE_MASK >= PAGE_SIZE); QEMU_BUILD_BUG_ON(KUSD_OFFSET_SUITE_MASK >= ELF2DMP_PAGE_SIZE);
QEMU_BUILD_BUG_ON(KUSD_OFFSET_PRODUCT_TYPE >= PAGE_SIZE); QEMU_BUILD_BUG_ON(KUSD_OFFSET_PRODUCT_TYPE >= ELF2DMP_PAGE_SIZE);
if (!suite_mask || !product_type) { if (!suite_mask || !product_type) {
return 1; return 1;
@ -281,14 +281,14 @@ static int fill_header(WinDumpHeader64 *hdr, struct pa_space *ps,
}; };
for (i = 0; i < ps->block_nr; i++) { for (i = 0; i < ps->block_nr; i++) {
h.PhysicalMemoryBlock.NumberOfPages += ps->block[i].size / PAGE_SIZE; h.PhysicalMemoryBlock.NumberOfPages += ps->block[i].size / ELF2DMP_PAGE_SIZE;
h.PhysicalMemoryBlock.Run[i] = (WinDumpPhyMemRun64) { h.PhysicalMemoryBlock.Run[i] = (WinDumpPhyMemRun64) {
.BasePage = ps->block[i].paddr / PAGE_SIZE, .BasePage = ps->block[i].paddr / ELF2DMP_PAGE_SIZE,
.PageCount = ps->block[i].size / PAGE_SIZE, .PageCount = ps->block[i].size / ELF2DMP_PAGE_SIZE,
}; };
} }
h.RequiredDumpSpace += h.PhysicalMemoryBlock.NumberOfPages << PAGE_BITS; h.RequiredDumpSpace += h.PhysicalMemoryBlock.NumberOfPages << ELF2DMP_PAGE_BITS;
*hdr = h; *hdr = h;
@ -379,7 +379,7 @@ static int pe_get_pdb_symstore_hash(uint64_t base, void *start_addr,
size_t pdb_name_sz; size_t pdb_name_sz;
size_t i; size_t i;
QEMU_BUILD_BUG_ON(sizeof(*dos_hdr) >= PAGE_SIZE); QEMU_BUILD_BUG_ON(sizeof(*dos_hdr) >= ELF2DMP_PAGE_SIZE);
if (memcmp(&dos_hdr->e_magic, e_magic, sizeof(e_magic))) { if (memcmp(&dos_hdr->e_magic, e_magic, sizeof(e_magic))) {
return 1; return 1;
@ -509,10 +509,10 @@ int main(int argc, char *argv[])
} }
printf("CPU #0 IDT[0] -> 0x%016"PRIx64"\n", idt_desc_addr(first_idt_desc)); printf("CPU #0 IDT[0] -> 0x%016"PRIx64"\n", idt_desc_addr(first_idt_desc));
KernBase = idt_desc_addr(first_idt_desc) & ~(PAGE_SIZE - 1); KernBase = idt_desc_addr(first_idt_desc) & ~(ELF2DMP_PAGE_SIZE - 1);
printf("Searching kernel downwards from 0x%016"PRIx64"...\n", KernBase); printf("Searching kernel downwards from 0x%016"PRIx64"...\n", KernBase);
for (; KernBase >= 0xfffff78000000000; KernBase -= PAGE_SIZE) { for (; KernBase >= 0xfffff78000000000; KernBase -= ELF2DMP_PAGE_SIZE) {
nt_start_addr = va_space_resolve(&vs, KernBase); nt_start_addr = va_space_resolve(&vs, KernBase);
if (!nt_start_addr) { if (!nt_start_addr) {
continue; continue;

40
hw/block/nand.c
View File

@ -115,24 +115,24 @@ static void mem_and(uint8_t *dest, const uint8_t *src, size_t n)
# define NAND_IO # define NAND_IO
# define PAGE(addr) ((addr) >> ADDR_SHIFT) # define PAGE(addr) ((addr) >> ADDR_SHIFT)
# define PAGE_START(page) (PAGE(page) * (PAGE_SIZE + OOB_SIZE)) # define PAGE_START(page) (PAGE(page) * (NAND_PAGE_SIZE + OOB_SIZE))
# define PAGE_MASK ((1 << ADDR_SHIFT) - 1) # define PAGE_MASK ((1 << ADDR_SHIFT) - 1)
# define OOB_SHIFT (PAGE_SHIFT - 5) # define OOB_SHIFT (PAGE_SHIFT - 5)
# define OOB_SIZE (1 << OOB_SHIFT) # define OOB_SIZE (1 << OOB_SHIFT)
# define SECTOR(addr) ((addr) >> (9 + ADDR_SHIFT - PAGE_SHIFT)) # define SECTOR(addr) ((addr) >> (9 + ADDR_SHIFT - PAGE_SHIFT))
# define SECTOR_OFFSET(addr) ((addr) & ((511 >> PAGE_SHIFT) << 8)) # define SECTOR_OFFSET(addr) ((addr) & ((511 >> PAGE_SHIFT) << 8))
# define PAGE_SIZE 256 # define NAND_PAGE_SIZE 256
# define PAGE_SHIFT 8 # define PAGE_SHIFT 8
# define PAGE_SECTORS 1 # define PAGE_SECTORS 1
# define ADDR_SHIFT 8 # define ADDR_SHIFT 8
# include "nand.c" # include "nand.c"
# define PAGE_SIZE 512 # define NAND_PAGE_SIZE 512
# define PAGE_SHIFT 9 # define PAGE_SHIFT 9
# define PAGE_SECTORS 1 # define PAGE_SECTORS 1
# define ADDR_SHIFT 8 # define ADDR_SHIFT 8
# include "nand.c" # include "nand.c"
# define PAGE_SIZE 2048 # define NAND_PAGE_SIZE 2048
# define PAGE_SHIFT 11 # define PAGE_SHIFT 11
# define PAGE_SECTORS 4 # define PAGE_SECTORS 4
# define ADDR_SHIFT 16 # define ADDR_SHIFT 16
@ -652,7 +652,7 @@ type_init(nand_register_types)
#else #else
/* Program a single page */ /* Program a single page */
static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s) static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
{ {
uint64_t off, page, sector, soff; uint64_t off, page, sector, soff;
uint8_t iobuf[(PAGE_SECTORS + 2) * 0x200]; uint8_t iobuf[(PAGE_SECTORS + 2) * 0x200];
@ -672,11 +672,11 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s)
return; return;
} }
mem_and(iobuf + (soff | off), s->io, MIN(s->iolen, PAGE_SIZE - off)); mem_and(iobuf + (soff | off), s->io, MIN(s->iolen, NAND_PAGE_SIZE - off));
if (off + s->iolen > PAGE_SIZE) { if (off + s->iolen > NAND_PAGE_SIZE) {
page = PAGE(s->addr); page = PAGE(s->addr);
mem_and(s->storage + (page << OOB_SHIFT), s->io + PAGE_SIZE - off, mem_and(s->storage + (page << OOB_SHIFT), s->io + NAND_PAGE_SIZE - off,
MIN(OOB_SIZE, off + s->iolen - PAGE_SIZE)); MIN(OOB_SIZE, off + s->iolen - NAND_PAGE_SIZE));
} }
if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf, if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
@ -704,7 +704,7 @@ static void glue(nand_blk_write_, PAGE_SIZE)(NANDFlashState *s)
} }
/* Erase a single block */ /* Erase a single block */
static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s) static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
{ {
uint64_t i, page, addr; uint64_t i, page, addr;
uint8_t iobuf[0x200] = { [0 ... 0x1ff] = 0xff, }; uint8_t iobuf[0x200] = { [0 ... 0x1ff] = 0xff, };
@ -716,7 +716,7 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
if (!s->blk) { if (!s->blk) {
memset(s->storage + PAGE_START(addr), memset(s->storage + PAGE_START(addr),
0xff, (PAGE_SIZE + OOB_SIZE) << s->erase_shift); 0xff, (NAND_PAGE_SIZE + OOB_SIZE) << s->erase_shift);
} else if (s->mem_oob) { } else if (s->mem_oob) {
memset(s->storage + (PAGE(addr) << OOB_SHIFT), memset(s->storage + (PAGE(addr) << OOB_SHIFT),
0xff, OOB_SIZE << s->erase_shift); 0xff, OOB_SIZE << s->erase_shift);
@ -742,7 +742,7 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
memset(iobuf, 0xff, 0x200); memset(iobuf, 0xff, 0x200);
i = (addr & ~0x1ff) + 0x200; i = (addr & ~0x1ff) + 0x200;
for (addr += ((PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200; for (addr += ((NAND_PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200;
i < addr; i += 0x200) { i < addr; i += 0x200) {
if (blk_pwrite(s->blk, i, iobuf, BDRV_SECTOR_SIZE, 0) < 0) { if (blk_pwrite(s->blk, i, iobuf, BDRV_SECTOR_SIZE, 0) < 0) {
printf("%s: write error in sector %" PRIu64 "\n", printf("%s: write error in sector %" PRIu64 "\n",
@ -763,7 +763,7 @@ static void glue(nand_blk_erase_, PAGE_SIZE)(NANDFlashState *s)
} }
} }
static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s, static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
uint64_t addr, int offset) uint64_t addr, int offset)
{ {
if (PAGE(addr) >= s->pages) { if (PAGE(addr) >= s->pages) {
@ -777,7 +777,7 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s,
printf("%s: read error in sector %" PRIu64 "\n", printf("%s: read error in sector %" PRIu64 "\n",
__func__, SECTOR(addr)); __func__, SECTOR(addr));
} }
memcpy(s->io + SECTOR_OFFSET(s->addr) + PAGE_SIZE, memcpy(s->io + SECTOR_OFFSET(s->addr) + NAND_PAGE_SIZE,
s->storage + (PAGE(s->addr) << OOB_SHIFT), s->storage + (PAGE(s->addr) << OOB_SHIFT),
OOB_SIZE); OOB_SIZE);
s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset; s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset;
@ -791,23 +791,23 @@ static void glue(nand_blk_load_, PAGE_SIZE)(NANDFlashState *s,
} }
} else { } else {
memcpy(s->io, s->storage + PAGE_START(s->addr) + memcpy(s->io, s->storage + PAGE_START(s->addr) +
offset, PAGE_SIZE + OOB_SIZE - offset); offset, NAND_PAGE_SIZE + OOB_SIZE - offset);
s->ioaddr = s->io; s->ioaddr = s->io;
} }
} }
static void glue(nand_init_, PAGE_SIZE)(NANDFlashState *s) static void glue(nand_init_, NAND_PAGE_SIZE)(NANDFlashState *s)
{ {
s->oob_shift = PAGE_SHIFT - 5; s->oob_shift = PAGE_SHIFT - 5;
s->pages = s->size >> PAGE_SHIFT; s->pages = s->size >> PAGE_SHIFT;
s->addr_shift = ADDR_SHIFT; s->addr_shift = ADDR_SHIFT;
s->blk_erase = glue(nand_blk_erase_, PAGE_SIZE); s->blk_erase = glue(nand_blk_erase_, NAND_PAGE_SIZE);
s->blk_write = glue(nand_blk_write_, PAGE_SIZE); s->blk_write = glue(nand_blk_write_, NAND_PAGE_SIZE);
s->blk_load = glue(nand_blk_load_, PAGE_SIZE); s->blk_load = glue(nand_blk_load_, NAND_PAGE_SIZE);
} }
# undef PAGE_SIZE # undef NAND_PAGE_SIZE
# undef PAGE_SHIFT # undef PAGE_SHIFT
# undef PAGE_SECTORS # undef PAGE_SECTORS
# undef ADDR_SHIFT # undef ADDR_SHIFT

4
include/qemu/osdep.h
View File

@ -104,10 +104,6 @@ extern int daemon(int, int);
#include <setjmp.h> #include <setjmp.h>
#include <signal.h> #include <signal.h>
#ifdef HAVE_SYS_SIGNAL_H
#include <sys/signal.h>
#endif
#ifndef _WIN32 #ifndef _WIN32
#include <sys/wait.h> #include <sys/wait.h>
#else #else

1
meson.build
View File

@ -1113,7 +1113,6 @@ config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h')) config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h')) config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h')) config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
config_host_data.set('HAVE_SYS_SIGNAL_H', cc.has_header('sys/signal.h'))
ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST'] arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']

2
subprojects/libvhost-user/libvhost-user.h
View File

@ -17,7 +17,7 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <sys/poll.h> #include <poll.h>
#include <linux/vhost.h> #include <linux/vhost.h>
#include <pthread.h> #include <pthread.h>
#include "standard-headers/linux/virtio_ring.h" #include "standard-headers/linux/virtio_ring.h"

7
tests/check-block.sh
View File

@ -60,6 +60,13 @@ if ! (sed --version | grep 'GNU sed') > /dev/null 2>&1 ; then
echo "GNU sed not available ==> Not running the qemu-iotests." echo "GNU sed not available ==> Not running the qemu-iotests."
exit 0 exit 0
fi fi
else
# Double-check that we're not using BusyBox' sed which says
# that "This is not GNU sed version 4.0" ...
if sed --version | grep -q 'not GNU sed' ; then
echo "BusyBox sed not supported ==> Not running the qemu-iotests."
exit 0
fi
fi fi
cd tests/qemu-iotests cd tests/qemu-iotests

55
tests/docker/dockerfiles/alpine.docker Normal file
View File

@ -0,0 +1,55 @@
FROM alpine:edge
RUN apk update
RUN apk upgrade
# Please keep this list sorted alphabetically
ENV PACKAGES \
alsa-lib-dev \
bash \
binutils \
coreutils \
curl-dev \
g++ \
gcc \
git \
glib-dev \
glib-static \
gnutls-dev \
gtk+3.0-dev \
libaio-dev \
libcap-ng-dev \
libjpeg-turbo-dev \
libnfs-dev \
libpng-dev \
libseccomp-dev \
libssh-dev \
libusb-dev \
libxml2-dev \
lzo-dev \
make \
mesa-dev \
mesa-egl \
mesa-gbm \
meson \
ncurses-dev \
ninja \
perl \
pulseaudio-dev \
python3 \
py3-sphinx \
shadow \
snappy-dev \
spice-dev \
texinfo \
usbredir-dev \
util-linux-dev \
vde2-dev \
virglrenderer-dev \
vte3-dev \
xfsprogs-dev \
zlib-dev \
zlib-static
RUN apk add $PACKAGES

10
tests/migration/stress.c
View File

@ -27,7 +27,7 @@
const char *argv0; const char *argv0;
#define PAGE_SIZE 4096 #define RAM_PAGE_SIZE 4096
#ifndef CONFIG_GETTID #ifndef CONFIG_GETTID
static int gettid(void) static int gettid(void)
@ -158,11 +158,11 @@ static unsigned long long now(void)
static void stressone(unsigned long long ramsizeMB) static void stressone(unsigned long long ramsizeMB)
{ {
size_t pagesPerMB = 1024 * 1024 / PAGE_SIZE; size_t pagesPerMB = 1024 * 1024 / RAM_PAGE_SIZE;
g_autofree char *ram = g_malloc(ramsizeMB * 1024 * 1024); g_autofree char *ram = g_malloc(ramsizeMB * 1024 * 1024);
char *ramptr; char *ramptr;
size_t i, j, k; size_t i, j, k;
g_autofree char *data = g_malloc(PAGE_SIZE); g_autofree char *data = g_malloc(RAM_PAGE_SIZE);
char *dataptr; char *dataptr;
size_t nMB = 0; size_t nMB = 0;
unsigned long long before, after; unsigned long long before, after;
@ -174,7 +174,7 @@ static void stressone(unsigned long long ramsizeMB)
* calloc instead :-) */ * calloc instead :-) */
memset(ram, 0xfe, ramsizeMB * 1024 * 1024); memset(ram, 0xfe, ramsizeMB * 1024 * 1024);
if (random_bytes(data, PAGE_SIZE) < 0) { if (random_bytes(data, RAM_PAGE_SIZE) < 0) {
return; return;
} }
@ -186,7 +186,7 @@ static void stressone(unsigned long long ramsizeMB)
for (i = 0; i < ramsizeMB; i++, nMB++) { for (i = 0; i < ramsizeMB; i++, nMB++) {
for (j = 0; j < pagesPerMB; j++) { for (j = 0; j < pagesPerMB; j++) {
dataptr = data; dataptr = data;
for (k = 0; k < PAGE_SIZE; k += sizeof(long long)) { for (k = 0; k < RAM_PAGE_SIZE; k += sizeof(long long)) {
ramptr += sizeof(long long); ramptr += sizeof(long long);
dataptr += sizeof(long long); dataptr += sizeof(long long);
*(unsigned long long *)ramptr ^= *(unsigned long long *)dataptr; *(unsigned long long *)ramptr ^= *(unsigned long long *)dataptr;

4
tests/qtest/libqos/malloc-pc.c
View File

@ -18,7 +18,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#define PAGE_SIZE (4096) #define ALLOC_PAGE_SIZE (4096)
void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags) void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags)
{ {
@ -26,7 +26,7 @@ void pc_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags)
QFWCFG *fw_cfg = pc_fw_cfg_init(qts); QFWCFG *fw_cfg = pc_fw_cfg_init(qts);
ram_size = qfw_cfg_get_u64(fw_cfg, FW_CFG_RAM_SIZE); ram_size = qfw_cfg_get_u64(fw_cfg, FW_CFG_RAM_SIZE);
alloc_init(s, flags, 1 << 20, MIN(ram_size, 0xE0000000), PAGE_SIZE); alloc_init(s, flags, 1 << 20, MIN(ram_size, 0xE0000000), ALLOC_PAGE_SIZE);
/* clean-up */ /* clean-up */
pc_fw_cfg_uninit(fw_cfg); pc_fw_cfg_uninit(fw_cfg);

4
tests/qtest/libqos/malloc-spapr.c
View File

@ -10,7 +10,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#define PAGE_SIZE 4096 #define SPAPR_PAGE_SIZE 4096
/* Memory must be a multiple of 256 MB, /* Memory must be a multiple of 256 MB,
* so we have at least 256MB * so we have at least 256MB
@ -19,5 +19,5 @@
void spapr_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags) void spapr_alloc_init(QGuestAllocator *s, QTestState *qts, QAllocOpts flags)
{ {
alloc_init(s, flags, 1 << 20, SPAPR_MIN_SIZE, PAGE_SIZE); alloc_init(s, flags, 1 << 20, SPAPR_MIN_SIZE, SPAPR_PAGE_SIZE);
} }

54
tests/qtest/m25p80-test.c
View File

@ -62,7 +62,7 @@ enum {
#define FLASH_JEDEC 0x20ba19 /* n25q256a */ #define FLASH_JEDEC 0x20ba19 /* n25q256a */
#define FLASH_SIZE (32 * 1024 * 1024) #define FLASH_SIZE (32 * 1024 * 1024)
#define PAGE_SIZE 256 #define FLASH_PAGE_SIZE 256
/* /*
* Use an explicit bswap for the values read/wrote to the flash region * Use an explicit bswap for the values read/wrote to the flash region
@ -165,7 +165,7 @@ static void read_page(uint32_t addr, uint32_t *page)
writel(ASPEED_FLASH_BASE, make_be32(addr)); writel(ASPEED_FLASH_BASE, make_be32(addr));
/* Continuous read are supported */ /* Continuous read are supported */
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
page[i] = make_be32(readl(ASPEED_FLASH_BASE)); page[i] = make_be32(readl(ASPEED_FLASH_BASE));
} }
spi_ctrl_stop_user(); spi_ctrl_stop_user();
@ -178,15 +178,15 @@ static void read_page_mem(uint32_t addr, uint32_t *page)
/* move out USER mode to use direct reads from the AHB bus */ /* move out USER mode to use direct reads from the AHB bus */
spi_ctrl_setmode(CTRL_READMODE, READ); spi_ctrl_setmode(CTRL_READMODE, READ);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
page[i] = make_be32(readl(ASPEED_FLASH_BASE + addr + i * 4)); page[i] = make_be32(readl(ASPEED_FLASH_BASE + addr + i * 4));
} }
} }
static void test_erase_sector(void) static void test_erase_sector(void)
{ {
uint32_t some_page_addr = 0x600 * PAGE_SIZE; uint32_t some_page_addr = 0x600 * FLASH_PAGE_SIZE;
uint32_t page[PAGE_SIZE / 4]; uint32_t page[FLASH_PAGE_SIZE / 4];
int i; int i;
spi_conf(CONF_ENABLE_W0); spi_conf(CONF_ENABLE_W0);
@ -200,14 +200,14 @@ static void test_erase_sector(void)
/* Previous page should be full of zeroes as backend is not /* Previous page should be full of zeroes as backend is not
* initialized */ * initialized */
read_page(some_page_addr - PAGE_SIZE, page); read_page(some_page_addr - FLASH_PAGE_SIZE, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0x0); g_assert_cmphex(page[i], ==, 0x0);
} }
/* But this one was erased */ /* But this one was erased */
read_page(some_page_addr, page); read_page(some_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0xffffffff); g_assert_cmphex(page[i], ==, 0xffffffff);
} }
@ -216,8 +216,8 @@ static void test_erase_sector(void)
static void test_erase_all(void) static void test_erase_all(void)
{ {
uint32_t some_page_addr = 0x15000 * PAGE_SIZE; uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE;
uint32_t page[PAGE_SIZE / 4]; uint32_t page[FLASH_PAGE_SIZE / 4];
int i; int i;
spi_conf(CONF_ENABLE_W0); spi_conf(CONF_ENABLE_W0);
@ -225,7 +225,7 @@ static void test_erase_all(void)
/* Check some random page. Should be full of zeroes as backend is /* Check some random page. Should be full of zeroes as backend is
* not initialized */ * not initialized */
read_page(some_page_addr, page); read_page(some_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0x0); g_assert_cmphex(page[i], ==, 0x0);
} }
@ -236,7 +236,7 @@ static void test_erase_all(void)
/* Recheck that some random page */ /* Recheck that some random page */
read_page(some_page_addr, page); read_page(some_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0xffffffff); g_assert_cmphex(page[i], ==, 0xffffffff);
} }
@ -245,9 +245,9 @@ static void test_erase_all(void)
static void test_write_page(void) static void test_write_page(void)
{ {
uint32_t my_page_addr = 0x14000 * PAGE_SIZE; /* beyond 16MB */ uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */
uint32_t some_page_addr = 0x15000 * PAGE_SIZE; uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE;
uint32_t page[PAGE_SIZE / 4]; uint32_t page[FLASH_PAGE_SIZE / 4];
int i; int i;
spi_conf(CONF_ENABLE_W0); spi_conf(CONF_ENABLE_W0);
@ -259,20 +259,20 @@ static void test_write_page(void)
writel(ASPEED_FLASH_BASE, make_be32(my_page_addr)); writel(ASPEED_FLASH_BASE, make_be32(my_page_addr));
/* Fill the page with its own addresses */ /* Fill the page with its own addresses */
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
writel(ASPEED_FLASH_BASE, make_be32(my_page_addr + i * 4)); writel(ASPEED_FLASH_BASE, make_be32(my_page_addr + i * 4));
} }
spi_ctrl_stop_user(); spi_ctrl_stop_user();
/* Check what was written */ /* Check what was written */
read_page(my_page_addr, page); read_page(my_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, my_page_addr + i * 4); g_assert_cmphex(page[i], ==, my_page_addr + i * 4);
} }
/* Check some other page. It should be full of 0xff */ /* Check some other page. It should be full of 0xff */
read_page(some_page_addr, page); read_page(some_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0xffffffff); g_assert_cmphex(page[i], ==, 0xffffffff);
} }
@ -281,9 +281,9 @@ static void test_write_page(void)
static void test_read_page_mem(void) static void test_read_page_mem(void)
{ {
uint32_t my_page_addr = 0x14000 * PAGE_SIZE; /* beyond 16MB */ uint32_t my_page_addr = 0x14000 * FLASH_PAGE_SIZE; /* beyond 16MB */
uint32_t some_page_addr = 0x15000 * PAGE_SIZE; uint32_t some_page_addr = 0x15000 * FLASH_PAGE_SIZE;
uint32_t page[PAGE_SIZE / 4]; uint32_t page[FLASH_PAGE_SIZE / 4];
int i; int i;
/* Enable 4BYTE mode for controller. This is should be strapped by /* Enable 4BYTE mode for controller. This is should be strapped by
@ -300,13 +300,13 @@ static void test_read_page_mem(void)
/* Check what was written */ /* Check what was written */
read_page_mem(my_page_addr, page); read_page_mem(my_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, my_page_addr + i * 4); g_assert_cmphex(page[i], ==, my_page_addr + i * 4);
} }
/* Check some other page. It should be full of 0xff */ /* Check some other page. It should be full of 0xff */
read_page_mem(some_page_addr, page); read_page_mem(some_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, 0xffffffff); g_assert_cmphex(page[i], ==, 0xffffffff);
} }
@ -315,8 +315,8 @@ static void test_read_page_mem(void)
static void test_write_page_mem(void) static void test_write_page_mem(void)
{ {
uint32_t my_page_addr = 0x15000 * PAGE_SIZE; uint32_t my_page_addr = 0x15000 * FLASH_PAGE_SIZE;
uint32_t page[PAGE_SIZE / 4]; uint32_t page[FLASH_PAGE_SIZE / 4];
int i; int i;
/* Enable 4BYTE mode for controller. This is should be strapped by /* Enable 4BYTE mode for controller. This is should be strapped by
@ -334,14 +334,14 @@ static void test_write_page_mem(void)
/* move out USER mode to use direct writes to the AHB bus */ /* move out USER mode to use direct writes to the AHB bus */
spi_ctrl_setmode(CTRL_WRITEMODE, PP); spi_ctrl_setmode(CTRL_WRITEMODE, PP);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
writel(ASPEED_FLASH_BASE + my_page_addr + i * 4, writel(ASPEED_FLASH_BASE + my_page_addr + i * 4,
make_be32(my_page_addr + i * 4)); make_be32(my_page_addr + i * 4));
} }
/* Check what was written */ /* Check what was written */
read_page_mem(my_page_addr, page); read_page_mem(my_page_addr, page);
for (i = 0; i < PAGE_SIZE / 4; i++) { for (i = 0; i < FLASH_PAGE_SIZE / 4; i++) {
g_assert_cmphex(page[i], ==, my_page_addr + i * 4); g_assert_cmphex(page[i], ==, my_page_addr + i * 4);
} }

5
tests/qtest/npcm7xx_pwm-test.c
View File

@ -175,6 +175,7 @@ static int pwm_index(const PWM *pwm)
static uint64_t pwm_qom_get(QTestState *qts, const char *path, const char *name) static uint64_t pwm_qom_get(QTestState *qts, const char *path, const char *name)
{ {
QDict *response; QDict *response;
uint64_t val;
g_test_message("Getting properties %s from %s", name, path); g_test_message("Getting properties %s from %s", name, path);
response = qtest_qmp(qts, "{ 'execute': 'qom-get'," response = qtest_qmp(qts, "{ 'execute': 'qom-get',"
@ -182,7 +183,9 @@ static uint64_t pwm_qom_get(QTestState *qts, const char *path, const char *name)
path, name); path, name);
/* The qom set message returns successfully. */ /* The qom set message returns successfully. */
g_assert_true(qdict_haskey(response, "return")); g_assert_true(qdict_haskey(response, "return"));
return qnum_get_uint(qobject_to(QNum, qdict_get(response, "return"))); val = qnum_get_uint(qobject_to(QNum, qdict_get(response, "return")));
qobject_unref(response);
return val;
} }
static uint64_t pwm_get_freq(QTestState *qts, int module_index, int pwm_index) static uint64_t pwm_get_freq(QTestState *qts, int module_index, int pwm_index)

2
tests/qtest/tpm-util.c
View File

@ -250,7 +250,7 @@ void tpm_util_wait_for_migration_complete(QTestState *who)
status = qdict_get_str(rsp_return, "status"); status = qdict_get_str(rsp_return, "status");
completed = strcmp(status, "completed") == 0; completed = strcmp(status, "completed") == 0;
g_assert_cmpstr(status, !=, "failed"); g_assert_cmpstr(status, !=, "failed");
qobject_unref(rsp_return); qobject_unref(rsp);
if (completed) { if (completed) {
return; return;
} }

6
tests/tcg/multiarch/system/memory.c
View File

@ -20,12 +20,12 @@
# error "Target does not specify CHECK_UNALIGNED" # error "Target does not specify CHECK_UNALIGNED"
#endif #endif
#define PAGE_SIZE 4096 /* nominal 4k "pages" */ #define MEM_PAGE_SIZE 4096 /* nominal 4k "pages" */
#define TEST_SIZE (PAGE_SIZE * 4) /* 4 pages */ #define TEST_SIZE (MEM_PAGE_SIZE * 4) /* 4 pages */
#define ARRAY_SIZE(x) ((sizeof(x) / sizeof((x)[0]))) #define ARRAY_SIZE(x) ((sizeof(x) / sizeof((x)[0])))
__attribute__((aligned(PAGE_SIZE))) __attribute__((aligned(MEM_PAGE_SIZE)))
static uint8_t test_data[TEST_SIZE]; static uint8_t test_data[TEST_SIZE];
typedef void (*init_ufn) (int offset); typedef void (*init_ufn) (int offset);

70
tests/test-xbzrle.c
View File

@ -15,7 +15,7 @@
#include "qemu/cutils.h" #include "qemu/cutils.h"
#include "../migration/xbzrle.h" #include "../migration/xbzrle.h"
#define PAGE_SIZE 4096 #define XBZRLE_PAGE_SIZE 4096
static void test_uleb(void) static void test_uleb(void)
{ {
@ -41,11 +41,11 @@ static void test_uleb(void)
static void test_encode_decode_zero(void) static void test_encode_decode_zero(void)
{ {
uint8_t *buffer = g_malloc0(PAGE_SIZE); uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *compressed = g_malloc0(PAGE_SIZE); uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
int i = 0; int i = 0;
int dlen = 0; int dlen = 0;
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006); int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
for (i = diff_len; i > 0; i--) { for (i = diff_len; i > 0; i--) {
buffer[1000 + i] = i; buffer[1000 + i] = i;
@ -55,8 +55,8 @@ static void test_encode_decode_zero(void)
buffer[1000 + diff_len + 5] = 105; buffer[1000 + diff_len + 5] = 105;
/* encode zero page */ /* encode zero page */
dlen = xbzrle_encode_buffer(buffer, buffer, PAGE_SIZE, compressed, dlen = xbzrle_encode_buffer(buffer, buffer, XBZRLE_PAGE_SIZE, compressed,
PAGE_SIZE); XBZRLE_PAGE_SIZE);
g_assert(dlen == 0); g_assert(dlen == 0);
g_free(buffer); g_free(buffer);
@ -65,11 +65,11 @@ static void test_encode_decode_zero(void)
static void test_encode_decode_unchanged(void) static void test_encode_decode_unchanged(void)
{ {
uint8_t *compressed = g_malloc0(PAGE_SIZE); uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *test = g_malloc0(PAGE_SIZE); uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
int i = 0; int i = 0;
int dlen = 0; int dlen = 0;
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006); int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
for (i = diff_len; i > 0; i--) { for (i = diff_len; i > 0; i--) {
test[1000 + i] = i + 4; test[1000 + i] = i + 4;
@ -79,8 +79,8 @@ static void test_encode_decode_unchanged(void)
test[1000 + diff_len + 5] = 109; test[1000 + diff_len + 5] = 109;
/* test unchanged buffer */ /* test unchanged buffer */
dlen = xbzrle_encode_buffer(test, test, PAGE_SIZE, compressed, dlen = xbzrle_encode_buffer(test, test, XBZRLE_PAGE_SIZE, compressed,
PAGE_SIZE); XBZRLE_PAGE_SIZE);
g_assert(dlen == 0); g_assert(dlen == 0);
g_free(test); g_free(test);
@ -89,21 +89,21 @@ static void test_encode_decode_unchanged(void)
static void test_encode_decode_1_byte(void) static void test_encode_decode_1_byte(void)
{ {
uint8_t *buffer = g_malloc0(PAGE_SIZE); uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *test = g_malloc0(PAGE_SIZE); uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *compressed = g_malloc(PAGE_SIZE); uint8_t *compressed = g_malloc(XBZRLE_PAGE_SIZE);
int dlen = 0, rc = 0; int dlen = 0, rc = 0;
uint8_t buf[2]; uint8_t buf[2];
test[PAGE_SIZE - 1] = 1; test[XBZRLE_PAGE_SIZE - 1] = 1;
dlen = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed, dlen = xbzrle_encode_buffer(buffer, test, XBZRLE_PAGE_SIZE, compressed,
PAGE_SIZE); XBZRLE_PAGE_SIZE);
g_assert(dlen == (uleb128_encode_small(&buf[0], 4095) + 2)); g_assert(dlen == (uleb128_encode_small(&buf[0], 4095) + 2));
rc = xbzrle_decode_buffer(compressed, dlen, buffer, PAGE_SIZE); rc = xbzrle_decode_buffer(compressed, dlen, buffer, XBZRLE_PAGE_SIZE);
g_assert(rc == PAGE_SIZE); g_assert(rc == XBZRLE_PAGE_SIZE);
g_assert(memcmp(test, buffer, PAGE_SIZE) == 0); g_assert(memcmp(test, buffer, XBZRLE_PAGE_SIZE) == 0);
g_free(buffer); g_free(buffer);
g_free(compressed); g_free(compressed);
@ -112,18 +112,18 @@ static void test_encode_decode_1_byte(void)
static void test_encode_decode_overflow(void) static void test_encode_decode_overflow(void)
{ {
uint8_t *compressed = g_malloc0(PAGE_SIZE); uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *test = g_malloc0(PAGE_SIZE); uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *buffer = g_malloc0(PAGE_SIZE); uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
int i = 0, rc = 0; int i = 0, rc = 0;
for (i = 0; i < PAGE_SIZE / 2 - 1; i++) { for (i = 0; i < XBZRLE_PAGE_SIZE / 2 - 1; i++) {
test[i * 2] = 1; test[i * 2] = 1;
} }
/* encode overflow */ /* encode overflow */
rc = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed, rc = xbzrle_encode_buffer(buffer, test, XBZRLE_PAGE_SIZE, compressed,
PAGE_SIZE); XBZRLE_PAGE_SIZE);
g_assert(rc == -1); g_assert(rc == -1);
g_free(buffer); g_free(buffer);
@ -133,13 +133,13 @@ static void test_encode_decode_overflow(void)
static void encode_decode_range(void) static void encode_decode_range(void)
{ {
uint8_t *buffer = g_malloc0(PAGE_SIZE); uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
uint8_t *compressed = g_malloc(PAGE_SIZE); uint8_t *compressed = g_malloc(XBZRLE_PAGE_SIZE);
uint8_t *test = g_malloc0(PAGE_SIZE); uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
int i = 0, rc = 0; int i = 0, rc = 0;
int dlen = 0; int dlen = 0;
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006); int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
for (i = diff_len; i > 0; i--) { for (i = diff_len; i > 0; i--) {
buffer[1000 + i] = i; buffer[1000 + i] = i;
@ -153,12 +153,12 @@ static void encode_decode_range(void)
test[1000 + diff_len + 5] = 109; test[1000 + diff_len + 5] = 109;
/* test encode/decode */ /* test encode/decode */
dlen = xbzrle_encode_buffer(test, buffer, PAGE_SIZE, compressed, dlen = xbzrle_encode_buffer(test, buffer, XBZRLE_PAGE_SIZE, compressed,
PAGE_SIZE); XBZRLE_PAGE_SIZE);
rc = xbzrle_decode_buffer(compressed, dlen, test, PAGE_SIZE); rc = xbzrle_decode_buffer(compressed, dlen, test, XBZRLE_PAGE_SIZE);
g_assert(rc < PAGE_SIZE); g_assert(rc < XBZRLE_PAGE_SIZE);
g_assert(memcmp(test, buffer, PAGE_SIZE) == 0); g_assert(memcmp(test, buffer, XBZRLE_PAGE_SIZE) == 0);
g_free(buffer); g_free(buffer);
g_free(compressed); g_free(compressed);