gmane.comp.emulators.kvm.devel
http://blog.gmane.org/gmane.comp.emulators.kvm.devel
hourly
1
1901-01-01T00:00+00:00
Gmane
http://gmane.org/img/gmane-25t.png
http://gmane.org
-
Re: [PATCH v5 0/9] KVM: fast page fault
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91387
<pre>
I'll certainly be more comfortable with that, at least to start with.
</pre>
Avi Kivity
2012-05-24T07:19:23
-
Re: [PATCH v5 0/9] KVM: fast page fault
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91386
<pre>
Hmm, i do not have a better way to solve the ABA problem on indirect spte now. :(
How about only allow fast page fault to work for direct spte?
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Xiao Guangrong
2012-05-24T06:31:38
-
Re: [PATCH v5 6/9] KVM: MMU: fast path of handling guest page fault
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91385
<pre>
Avi,
Currently, The spte update/clear paths in mmu-lock think the "Dirty bit" is
not volatile if the spte is readonly. Then the "Dirty bit" caused by
lockless update can be lost.
And, for tlb flush:
| * If we overwrite a writable spte with a read-only one we
| * should flush remote TLBs. Otherwise rmap_write_protect
| * will find a read-only spte, even though the writable spte
| * might be cached on a CPU's TLB.
| */
| if (is_writable_pte(entry) && !is_writable_pte(*sptep))
| kvm_flush_remote_tlbs(vcpu->kvm);
Atomically update spte can help us to get a stable is_writable_pte().
/* Rules for using mmu_spte_update:
* Update the state bits, it means the mapped pfn is not changged.
If pfn is changed, we should clear spte first, then set the spte to
the new pfn, in kvm_set_pte_rmapp(), we have:
| mmu_spte_clear_track_bits(sptep);
| mmu_spte_set(sptep, new_spte);
Right, kvm_release_pfn_dirty is better.
Right, will fix it.
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Xiao Guangrong
2012-05-24T06:26:19
-
Re: [PATCH v2 15/15] net: invoke qemu_can_send_packet only before net queue sending function
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91384
<pre>Its code execution flow is like below:
tap_send --> qemu_send_packet_async
->qemu_send_packet_async_with_flags ->qemu_net_queue_send
So it will finally invoke qemu_can_send_packet to determine if it can
send packets. this code change delay this determination.
No, i have not done benchmark testing. When a lot of packets will go
to the guest from outside and this guest' NIC can_receive return
false, this change will cause CPU to execute some additional codes.
Hub can now do its own flow control if it provides its can_recieve.
Why need we add some counts to track in-flight packets? Do you think
that it can speed up the packets delivery? otherwise i think that it
complex the code. To be honest, i prefer current solution. Do you
think of this? :)
</pre>
Zhi Yong Wu
2012-05-24T04:05:23
-
[PATCH] vfio-powerpc: enabled and supported on power
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91383
<pre>The patch introduces support of VFIO on POWER.
The patch consists of:
1. IOMMU driver for VFIO.
It does not use IOMMU API at all, instead it calls POWER
IOMMU API directly (ppc_md callbacks).
2. A piece of code (module_init) which creates IOMMU groups.
TBD: what is a better place for it?
The patch is made on top of
git://github.com/awilliam/linux-vfio.git iommu-group-vfio-20120523
(which is iommu-group-vfio-20120521 + some fixes)
Signed-off-by: Alexey Kardashevskiy <aik< at >ozlabs.ru>
---
arch/powerpc/Kconfig | 6 +
arch/powerpc/include/asm/iommu.h | 3 +
arch/powerpc/kernel/Makefile | 1 +
arch/powerpc/kernel/iommu_vfio.c | 371 ++++++++++++++++++++++++++++++++++++++
4 files changed, 381 insertions(+), 0 deletions(-)
create mode 100644 arch/powerpc/kernel/iommu_vfio.c
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index feab3ba..13d12ac 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
< at >< at > -319,6 +319,12 < at >< at > config 8XX_MINIMAL_FPEMU
config IOMMU_HELPER
def_bool PPC64
+config IOMMU_VFIO
+select IOMMU_API
+depends on PPC64
+tristate "Enable IOMMU chardev to support user-space PCI"
+default n
+
config SWIOTLB
bool "SWIOTLB support"
default n
diff --git a/arch/powerpc/include/asm/iommu.h b/arch/powerpc/include/asm/iommu.h
index 957a83f..c64bce7 100644
--- a/arch/powerpc/include/asm/iommu.h
+++ b/arch/powerpc/include/asm/iommu.h
< at >< at > -66,6 +66,9 < at >< at > struct iommu_table {
unsigned long it_halfpoint; /* Breaking point for small/large allocs */
spinlock_t it_lock; /* Protects it_map */
unsigned long *it_map; /* A simple allocation bitmap for now */
+#ifdef CONFIG_IOMMU_API
+struct iommu_group *it_group;
+#endif
};
struct scatterlist;
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index f5808a3..7cfd68e 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
< at >< at > -90,6 +90,7 < at >< at > obj-$(CONFIG_RELOCATABLE_PPC32)+= reloc_32.o
obj-$(CONFIG_PPC32)+= entry_32.o setup_32.o
obj-$(CONFIG_PPC64)+= dma-iommu.o iommu.o
+obj-$(CONFIG_IOMMU_VFIO)+= iommu_vfio.o
obj-$(CONFIG_KGDB)+= kgdb.o
obj-$(CONFIG_PPC_OF_BOOT_TRAMPOLINE)+= prom_init.o
obj-$(CONFIG_MODULES)+= ppc_ksyms.o
diff --git a/arch/powerpc/kernel/iommu_vfio.c b/arch/powerpc/kernel/iommu_vfio.c
new file mode 100644
index 0000000..68a93dd
--- /dev/null
+++ b/arch/powerpc/kernel/iommu_vfio.c
< at >< at > -0,0 +1,371 < at >< at >
+/*
+ * VFIO: IOMMU DMA mapping support for TCE on POWER
+ *
+ * Copyright (C) 2012 IBM Corp. All rights reserved.
+ * Author: Alexey Kardashevskiy <aik< at >ozlabs.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Derived from original vfio_iommu_x86.c:
+ * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
+ * Author: Alex Williamson <alex.williamson< at >redhat.com>
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/vfio.h>
+#include <linux/err.h>
+#include <linux/spinlock.h>
+#include <asm/iommu.h>
+
+#define DRIVER_VERSION "0.1"
+#define DRIVER_AUTHOR "aik< at >ozlabs.ru"
+#define DRIVER_DESC "POWER IOMMU chardev for VFIO"
+
+#define IOMMU_CHECK_EXTENSION_IO(VFIO_TYPE, VFIO_BASE + 1)
+
+/* -------- API for POWERPC IOMMU -------- */
+
+#define POWERPC_IOMMU2
+
+struct tce_iommu_info {
+__u32 argsz;
+__u32 dma32_window_start;
+__u32 dma32_window_size;
+};
+
+#define POWERPC_IOMMU_GET_INFO_IO(VFIO_TYPE, VFIO_BASE + 12)
+
+struct tce_iommu_dma_map {
+__u32 argsz;
+__u64 va;
+__u64 dmaaddr;
+};
+
+#define POWERPC_IOMMU_MAP_DMA_IO(VFIO_TYPE, VFIO_BASE + 13)
+#define POWERPC_IOMMU_UNMAP_DMA_IO(VFIO_TYPE, VFIO_BASE + 14)
+
+/* ***************************************************************** */
+
+struct tce_iommu {
+struct iommu_table *tbl;
+};
+
+static int tce_iommu_attach_group(void *iommu_data,
+struct iommu_group *iommu_group)
+{
+struct tce_iommu *tceiommu = iommu_data;
+
+if (tceiommu->tbl) {
+printk(KERN_ERR "Only one group per IOMMU instance is allowed\n");
+return -EFAULT;
+}
+tceiommu->tbl = iommu_group_get_iommudata(iommu_group);
+
+return 0;
+}
+
+static void tce_iommu_detach_group(void *iommu_data,
+struct iommu_group *iommu_group)
+{
+struct tce_iommu *tceiommu = iommu_data;
+
+if (!tceiommu->tbl) {
+printk(KERN_ERR "IOMMU already released\n");
+return;
+}
+tceiommu->tbl = NULL;
+}
+
+static void *tce_iommu_open(unsigned long arg)
+{
+struct tce_iommu *tceiommu;
+
+if (arg != POWERPC_IOMMU)
+return ERR_PTR(-EINVAL);
+
+tceiommu = kzalloc(sizeof(*tceiommu), GFP_KERNEL);
+if (!tceiommu)
+return ERR_PTR(-ENOMEM);
+
+return tceiommu;
+}
+
+static void tce_iommu_release(void *iommu_data)
+{
+struct tce_iommu *tceiommu = iommu_data;
+kfree(tceiommu);
+}
+
+static int tce_iommu_map(struct iommu_table *tbl, unsigned long iova,
+ phys_addr_t paddr)
+{
+unsigned long entry, flags;
+int build_fail;
+
+spin_lock_irqsave(&(tbl->it_lock), flags);
+entry = iova >> IOMMU_PAGE_SHIFT;
+build_fail = ppc_md.tce_build(tbl, entry, 1/*pages*/,
+(unsigned long)paddr & IOMMU_PAGE_MASK,
+DMA_BIDIRECTIONAL, NULL/*attrs*/);
+
+/* ppc_md.tce_build() only returns non-zero for transient errors.
+ * Clean up the table bitmap in this case and return
+ * DMA_ERROR_CODE. For all other errors the functionality is
+ * not altered.
+ */
+if (unlikely(build_fail)) {
+printk("Failed to add TCE\n");
+spin_unlock_irqrestore(&(tbl->it_lock), flags);
+return -EFAULT;
+}
+/* Flush/invalidate TLB caches if necessary */
+if (ppc_md.tce_flush)
+ppc_md.tce_flush(tbl);
+
+spin_unlock_irqrestore(&(tbl->it_lock), flags);
+
+/* Make sure updates are seen by hardware */
+mb();
+
+return 0;
+}
+
+static void tce_iommu_unmap(struct iommu_table *tbl, unsigned long iova)
+{
+unsigned long entry, flags;
+entry = iova >> IOMMU_PAGE_SHIFT;
+
+spin_lock_irqsave(&(tbl->it_lock), flags);
+ppc_md.tce_free(tbl, entry, 1);
+/* Flush/invalidate TLB caches if necessary */
+if (ppc_md.tce_flush)
+ppc_md.tce_flush(tbl);
+
+spin_unlock_irqrestore(&(tbl->it_lock), flags);
+
+/* Make sure updates are seen by hardware */
+mb();
+}
+
+static phys_addr_t tce_iommu_iova_to_va(struct iommu_table *tbl,
+unsigned long iova)
+{
+unsigned long entry = iova >> IOMMU_PAGE_SHIFT;
+phys_addr_t ret = 0;
+
+if (ppc_md.tce_get)
+ret = ppc_md.tce_get(tbl, entry);
+
+return ret;
+}
+
+static struct page *tceaddr_to_page(void *addr)
+{
+return pfn_to_page(__pa(addr) >> PAGE_SHIFT);
+}
+
+static long tce_dmamap_page(struct iommu_table *tbl,
+uint64_t va, uint64_t dmaaddr)
+{
+int ret = -EFAULT;
+phys_addr_t addr;
+struct page *page[1];
+int iswrite = 1;
+void *kva;
+
+if (NULL == tbl) {
+printk(KERN_ERR"tce_iommu: (map) IOMMU table has not "
+"been initialized yet!\n");
+return -EFAULT;
+}
+addr = tce_iommu_iova_to_va(tbl, dmaaddr);
+if (addr) {
+printk(KERN_WARNING"tce_iommu: already mapped va=%llx "
+"da=%llx addr=%llx\n",
+va, dmaaddr, addr);
+/*TODO: unmap! */
+}
+
+ret = get_user_pages_fast(va, 1, iswrite, page);
+if (1 != ret) {
+printk(KERN_ERR"tce_iommu: get_user_pages_fast failed "
+"va=%llx da=%llx addr=%llx ret=%d\n",
+va, dmaaddr, addr, ret);
+return -EFAULT;
+}
+ret = -EFAULT;
+kva = (void *) page_address(page[0]);
+if (kva) {
+ret = tce_iommu_map(tbl, dmaaddr, (phys_addr_t) kva);
+}
+if (ret) {
+printk(KERN_ERR"tce_iommu: tce_iommu_map va=%llx "
+"da=%llx kva=%p\n",
+va, dmaaddr, kva);
+if (iswrite)
+SetPageDirty(page[0]);
+put_page(page[0]);
+}
+
+return ret;
+}
+
+static long tce_dmaunmap_page(struct iommu_table *tbl, uint64_t dmaaddr)
+{
+int ret = 0;
+phys_addr_t addr;
+struct page *page;
+
+if (NULL == tbl) {
+printk(KERN_ERR"tce_iommu: (unmap) IOMMU table has not been "
+"initialized yet!\n");
+return -EFAULT;
+}
+addr = tce_iommu_iova_to_va(tbl, dmaaddr);
+if (addr) {
+page = tceaddr_to_page((void*)addr);
+if (!page) {
+printk(KERN_ERR"DMAUNMAP error: pfn_to_page(%llx) "
+"failed\n", addr);
+ret = -EFAULT;
+} else {
+SetPageDirty(page);
+put_page(page);
+}
+}
+tce_iommu_unmap(tbl, dmaaddr);
+if (ret)
+printk(KERN_ERR"Failed to DMAUNMAP: da=%llx pfn=%llx\n",
+dmaaddr, addr);
+return ret;
+}
+
+
+static long tce_iommu_ioctl(void *iommu_data,
+ unsigned int cmd, unsigned long arg)
+{
+struct tce_iommu *tceiommu = iommu_data;
+unsigned long minsz;
+
+if (cmd == IOMMU_CHECK_EXTENSION) {
+switch (arg) {
+case POWERPC_IOMMU:
+return 1;
+default:
+return 0;
+}
+} else if (cmd == POWERPC_IOMMU_GET_INFO) {
+struct tce_iommu_info info;
+
+minsz = offsetofend(struct tce_iommu_info, dma32_window_size);
+
+if (copy_from_user(&info, (void __user *)arg, minsz))
+return -EFAULT;
+
+if (info.argsz < minsz)
+return -EINVAL;
+
+info.dma32_window_start =
+tceiommu->tbl->it_offset << IOMMU_PAGE_SHIFT;
+info.dma32_window_size =
+tceiommu->tbl->it_size << IOMMU_PAGE_SHIFT;
+
+return copy_to_user((void __user *)arg, &info, minsz);
+
+} else if (cmd == POWERPC_IOMMU_MAP_DMA) {
+struct tce_iommu_dma_map map;
+
+minsz = offsetofend(struct tce_iommu_dma_map, dmaaddr);
+
+if (copy_from_user(&map, (void __user *)arg, minsz))
+return -EFAULT;
+
+if (map.argsz < minsz)
+return -EINVAL;
+
+return tce_dmamap_page(tceiommu->tbl, map.va, map.dmaaddr);
+
+} else if (cmd == POWERPC_IOMMU_UNMAP_DMA) {
+struct tce_iommu_dma_map unmap;
+
+minsz = offsetofend(struct tce_iommu_dma_map, dmaaddr);
+
+if (copy_from_user(&unmap, (void __user *)arg, minsz))
+return -EFAULT;
+
+if (unmap.argsz < minsz)
+return -EINVAL;
+
+return tce_dmaunmap_page(tceiommu->tbl, unmap.dmaaddr);
+}
+
+return -ENOTTY;
+}
+
+const struct vfio_iommu_driver_ops tce_iommu_driver_ops = {
+.name= "vfio-iommu-powerpc",
+.owner= THIS_MODULE,
+.open= tce_iommu_open,
+.release= tce_iommu_release,
+.ioctl= tce_iommu_ioctl,
+.attach_group= tce_iommu_attach_group,
+.detach_group= tce_iommu_detach_group,
+};
+
+static int __init tce_iommu_init(void)
+{
+struct pci_dev *pdev = NULL;
+struct iommu_table *tbl = NULL;
+struct iommu_group *grp = NULL;
+int ret = 0;
+
+/* TODO: Do this for all devices, not just for PCI */
+for_each_pci_dev(pdev) {
+
+tbl = get_iommu_table_base(&pdev->dev);
+if (NULL == tbl) {
+printk("Skipping device %s\n", pdev->dev.kobj.name);
+continue;
+}
+if (!tbl->it_group) {
+struct iommu_group *tmp = iommu_group_alloc();
+if (IS_ERR(tmp)) {
+printk("Failed to create new IOMMU group, "
+"ret = %ld\n", PTR_ERR(tmp));
+break;
+}
+tbl->it_group = tmp;
+iommu_group_set_iommudata(tmp, tbl, NULL);
+}
+
+grp = iommu_group_get(&pdev->dev);
+if (!grp) {
+ret = iommu_group_add_device(tbl->it_group, &pdev->dev);
+if (ret < 0)
+printk("iommu_group_add_device(%s) failed "
+"with %d\n",
+pdev->dev.kobj.name, ret);
+}
+}
+
+return vfio_register_iommu_driver(&tce_iommu_driver_ops);
+}
+
+static void __exit tce_iommu_cleanup(void)
+{
+vfio_unregister_iommu_driver(&tce_iommu_driver_ops);
+}
+
+module_init(tce_iommu_init);
+module_exit(tce_iommu_cleanup);
+
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+
</pre>
Alexey Kardashevskiy
2012-05-24T03:10:03
-
Re: [PATCH 1/3 - qemu-kvm stable-1.0] Fix conditional build of various x86 specific bits
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91382
<pre>
Fedora uses qemu-kvm as their "upstream" qemu source tree for all qemu
builds, KVM and non-KVM ones, for all targets.
These fixes are necessary to make qemu in fc17 (and later) to build
ppc64-softmmu targets (with and without KVM).
Cheers,
Ben.
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Benjamin Herrenschmidt
2012-05-24T03:03:51
-
Re: [PATCH 1/3 - qemu-kvm stable-1.0] Fix conditional build of various x86 specific bits
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91381
<pre>
What is the interest of patching qemu-kvm for non-x86? It is not
supposed to be used for this. And the affected bits are history in 1.1
(or 1.2 latest). Are there distros proving QEMU based on qemu-kvm for
non-x86 hosts?
Jan
</pre>
Jan Kiszka
2012-05-24T02:51:40
-
[PATCH 1/3 - qemu-kvm stable-1.0] Fix conditional build of various x86 specific bits
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91379
<pre>This adds/modifies ifdefs etc. and moves code to make sure that
x86-specific code doesn't get compiled on non-x86 platforms.
These changes all relate to code that is in the qemu-kvm tree and
not in the qemu tree.
The change from KVM_CAP_IRQCHIP to KVM_IRQCHIP_PIC_MASTER is because
the KVM_CAP_IRQCHIP symbol is defined on all platforms (though the
capability only exists on x86), whereas KVM_IRQCHIP_PIC_MASTER is
only defined on x86. (If a better symbol exists it could be used
instead.)
Signed-off-by: Benjamin Herrenschmidt <benh< at >kernel.crashing.org>
---
An equivalent of this is already in qemu-kvm master as commit id
20ad1def644494f5055d129961d46b050c0a6158
Makefile.target | 2 ++
configure | 6 ++++--
hw/i8259.c | 6 ++++--
qemu-kvm-x86.c | 16 ++++++++++++++++
qemu-kvm.c | 30 ++++++++++++++----------------
5 files changed, 40 insertions(+), 20 deletions(-)
diff --git a/Makefile.target b/Makefile.target
index 29eaa68..0d0baf4 100644
--- a/Makefile.target
+++ b/Makefile.target
< at >< at > -80,7 +80,9 < at >< at > endif
libobj-$(TARGET_SPARC64) += vis_helper.o
libobj-$(CONFIG_NEED_MMU) += mmu.o
+ifeq ($(TARGET_BASE_ARCH), i386)
libobj-$(CONFIG_KVM) += kvm-tpr-opt.o
+endif
libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o
ifeq ($(TARGET_BASE_ARCH), sparc)
diff --git a/configure b/configure
index 4b7faec..79a49a9 100755
--- a/configure
+++ b/configure
< at >< at > -3579,8 +3579,10 < at >< at > case "$target_arch2" in
if test $kvm_cap_pit = "yes" ; then
echo "CONFIG_KVM_PIT=y" >> $config_target_mak
fi
- if test $kvm_cap_device_assignment = "yes" ; then
- echo "CONFIG_KVM_DEVICE_ASSIGNMENT=y" >> $config_target_mak
+ if test "$cpu" = "i386" -o "$cpu" = "x86_64" ; then
+ if test $kvm_cap_device_assignment = "yes" ; then
+ echo "CONFIG_KVM_DEVICE_ASSIGNMENT=y" >> $config_target_mak
+ fi
fi
fi
esac
diff --git a/hw/i8259.c b/hw/i8259.c
index a9ea9c9..c5841c0 100644
--- a/hw/i8259.c
+++ b/hw/i8259.c
< at >< at > -635,7 +635,7 < at >< at > static void pic_register(void)
static void kvm_kernel_pic_save_to_user(PicState *s)
{
-#ifdef KVM_CAP_IRQCHIP
+#ifdef KVM_IRQCHIP_PIC_MASTER
struct kvm_irqchip chip;
struct kvm_pic_state *kpic;
< at >< at > -666,7 +666,7 < at >< at > static void kvm_kernel_pic_save_to_user(PicState *s)
static int kvm_kernel_pic_load_from_user(PicState *s)
{
-#ifdef KVM_CAP_IRQCHIP
+#ifdef KVM_IRQCHIP_PIC_MASTER
struct kvm_irqchip chip;
struct kvm_pic_state *kpic;
< at >< at > -701,8 +701,10 < at >< at > static void kvm_i8259_set_irq(void *opaque, int irq, int level)
{
int pic_ret;
if (kvm_set_irq(irq, level, &pic_ret)) {
+#ifdef KVM_IRQCHIP_PIC_MASTER
if (pic_ret != 0)
apic_set_irq_delivered();
+#endif
return;
}
}
diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index a7981b1..f1db968 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
< at >< at > -23,6 +23,22 < at >< at >
#include "kvm.h"
#include "hw/apic.h"
+int kvm_reinject_control(KVMState *s, int pit_reinject)
+{
+#ifdef KVM_CAP_REINJECT_CONTROL
+ int r;
+ struct kvm_reinject_control control;
+
+ control.pit_reinject = pit_reinject;
+
+ r = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_REINJECT_CONTROL);
+ if (r > 0) {
+ return kvm_vm_ioctl(s, KVM_REINJECT_CONTROL, &control);
+ }
+#endif
+ return -ENOSYS;
+}
+
static int kvm_create_pit(KVMState *s)
{
int r;
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 8d68545..f37535d 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
< at >< at > -222,22 +222,6 < at >< at > int kvm_deassign_pci_device(KVMState *s,
}
#endif
-int kvm_reinject_control(KVMState *s, int pit_reinject)
-{
-#ifdef KVM_CAP_REINJECT_CONTROL
- int r;
- struct kvm_reinject_control control;
-
- control.pit_reinject = pit_reinject;
-
- r = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_REINJECT_CONTROL);
- if (r > 0) {
- return kvm_vm_ioctl(s, KVM_REINJECT_CONTROL, &control);
- }
-#endif
- return -ENOSYS;
-}
-
int kvm_has_gsi_routing(void)
{
int r = 0;
< at >< at > -463,6 +447,7 < at >< at > int kvm_get_irq_route_gsi(void)
return -ENOSPC;
}
+#ifdef KVM_CAP_IRQ_ROUTING
static void kvm_msi_routing_entry(struct kvm_irq_routing_entry *e,
KVMMsiMessage *msg)
< at >< at > -474,9 +459,11 < at >< at > static void kvm_msi_routing_entry(struct kvm_irq_routing_entry *e,
e->u.msi.address_hi = msg->addr_hi;
e->u.msi.data = msg->data;
}
+#endif
int kvm_msi_message_add(KVMMsiMessage *msg)
{
+#ifdef KVM_CAP_IRQ_ROUTING
struct kvm_irq_routing_entry e;
int ret;
< at >< at > -488,18 +475,26 < at >< at > int kvm_msi_message_add(KVMMsiMessage *msg)
kvm_msi_routing_entry(&e, msg);
return kvm_add_routing_entry(&e);
+#else
+ return -ENOSYS;
+#endif
}
int kvm_msi_message_del(KVMMsiMessage *msg)
{
+#ifdef KVM_CAP_IRQ_ROUTING
struct kvm_irq_routing_entry e;
kvm_msi_routing_entry(&e, msg);
return kvm_del_routing_entry(&e);
+#else
+ return -ENOSYS;
+#endif
}
int kvm_msi_message_update(KVMMsiMessage *old, KVMMsiMessage *new)
{
+#ifdef KVM_CAP_IRQ_ROUTING
struct kvm_irq_routing_entry e1, e2;
int ret;
< at >< at > -517,6 +512,9 < at >< at > int kvm_msi_message_update(KVMMsiMessage *old, KVMMsiMessage *new)
}
return 1;
+#else
+ return -ENOSYS;
+#endif
}
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Benjamin Herrenschmidt
2012-05-24T02:14:50
-
[PATCH 3/3 - qemu-kvm stable-1.0] Fix kVM_GET_ONE_REG interface
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91378
<pre>Qemu-1.0 included some code to use a new get/set one register interface
to KVM which unfortunately hadn't settled, and in the end the code that
went into the kernel provides a different interface. This updates qemu
to use the new interface.
Since the 3.3 kernel doesn't provide this interface, in either the new
or the old form, this removes the check that caused qemu to bail out
if the ioctl returns an error. In fact we don't even print a message,
since it got printed once per vcpu, which gets a bit tedious with more
than a few vcpus.
Signed-off-by: Benjamin Herrenschmidt <benh< at >kernel.crashing.org>
---
This is unnecessary in qemu-master and the main qemu as both have already
been updated with the correct interfaces.
linux-headers/asm-powerpc/kvm.h | 2 +-
linux-headers/linux/kvm.h | 35 +++++++++++++++++++----------------
target-ppc/kvm.c | 12 ++++++++----
3 files changed, 28 insertions(+), 21 deletions(-)
diff --git a/linux-headers/asm-powerpc/kvm.h b/linux-headers/asm-powerpc/kvm.h
index fb3fddc..dea2156 100644
--- a/linux-headers/asm-powerpc/kvm.h
+++ b/linux-headers/asm-powerpc/kvm.h
< at >< at > -327,6 +327,6 < at >< at > struct kvm_book3e_206_tlb_params {
__u32 reserved[8];
};
-#define KVM_ONE_REG_PPC_HIORKVM_ONE_REG_PPC | 0x100
+#define KVM_REG_PPC_HIOR(KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x1)
#endif /* __LINUX_KVM_POWERPC_H */
diff --git a/linux-headers/linux/kvm.h b/linux-headers/linux/kvm.h
index a8761d3..8c33a57 100644
--- a/linux-headers/linux/kvm.h
+++ b/linux-headers/linux/kvm.h
< at >< at > -654,30 +654,33 < at >< at > struct kvm_dirty_tlb {
/* Available with KVM_CAP_ONE_REG */
-#define KVM_ONE_REG_GENERIC0x0000000000000000ULL
+#define KVM_REG_ARCH_MASK0xff00000000000000ULL
+#define KVM_REG_GENERIC0x0000000000000000ULL
/*
* Architecture specific registers are to be defined in arch headers and
* ORed with the arch identifier.
*/
-#define KVM_ONE_REG_PPC0x1000000000000000ULL
-#define KVM_ONE_REG_X860x2000000000000000ULL
-#define KVM_ONE_REG_IA640x3000000000000000ULL
-#define KVM_ONE_REG_ARM0x4000000000000000ULL
-#define KVM_ONE_REG_S3900x5000000000000000ULL
+#define KVM_REG_PPC0x1000000000000000ULL
+#define KVM_REG_X860x2000000000000000ULL
+#define KVM_REG_IA640x3000000000000000ULL
+#define KVM_REG_ARM0x4000000000000000ULL
+#define KVM_REG_S3900x5000000000000000ULL
+
+#define KVM_REG_SIZE_SHIFT52
+#define KVM_REG_SIZE_MASK0x00f0000000000000ULL
+#define KVM_REG_SIZE_U80x0000000000000000ULL
+#define KVM_REG_SIZE_U160x0010000000000000ULL
+#define KVM_REG_SIZE_U320x0020000000000000ULL
+#define KVM_REG_SIZE_U640x0030000000000000ULL
+#define KVM_REG_SIZE_U1280x0040000000000000ULL
+#define KVM_REG_SIZE_U2560x0050000000000000ULL
+#define KVM_REG_SIZE_U5120x0060000000000000ULL
+#define KVM_REG_SIZE_U10240x0070000000000000ULL
struct kvm_one_reg {
__u64 id;
-union {
-__u8 reg8;
-__u16 reg16;
-__u32 reg32;
-__u64 reg64;
-__u8 reg128[16];
-__u8 reg256[32];
-__u8 reg512[64];
-__u8 reg1024[128];
-} u;
+__u64 addr;
};
/*
diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
index 0410901..f7c986c 100644
--- a/target-ppc/kvm.c
+++ b/target-ppc/kvm.c
< at >< at > -740,6 +740,7 < at >< at > void kvmppc_set_papr(CPUState *env)
struct kvm_one_reg reg = {};
struct kvm_sregs sregs = {};
int ret;
+ uint64_t hior = env->spr[SPR_HIOR];
cap.cap = KVM_CAP_PPC_PAPR;
ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &cap);
< at >< at > -755,11 +756,14 < at >< at > void kvmppc_set_papr(CPUState *env)
* Once we have qdev CPUs, move HIOR to a qdev property and
* remove this chunk.
*/
- reg.id = KVM_ONE_REG_PPC_HIOR;
- reg.u.reg64 = env->spr[SPR_HIOR];
+ reg.id = KVM_REG_PPC_HIOR;
+ reg.addr = (uintptr_t)&hior;
ret = kvm_vcpu_ioctl(env, KVM_SET_ONE_REG, &reg);
- if (ret) {
- goto fail;
+ if (ret && 0) {
+ fprintf(stderr, "Couldn't set HIOR. Maybe you're running an old \n"
+ "kernel with support for HV KVM but no PAPR PR \n"
+ "KVM in which case things will work. If they don't \n"
+ "please update your host kernel!\n");
}
/* Set SDR1 so kernel space finds the HTAB */
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Benjamin Herrenschmidt
2012-05-24T02:15:36
-
[PATCH 2/3 - qemu-kvm stable-1.0] Allow i8259 to build without i8254
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91377
<pre>This allows the i8259 emulation to be compiled without the i8254
emulation.
Currently the i8259 emulation code references some variables defined
in i8254.c for the "time-drift fix". This moves the definitions from
i8254.c to i8259.c so that i8259.c becomes independent of i8254.c.
Signed-off-by: Benjamin Herrenschmidt <benh< at >kernel.crashing.org>
---
This appears to be unnecessary on qemu-kvm master or the main qemu
hw/i8254.c | 3 ++-
hw/i8259.c | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/hw/i8254.c b/hw/i8254.c
index 019c7b8..878a47b 100644
--- a/hw/i8254.c
+++ b/hw/i8254.c
< at >< at > -348,7 +348,8 < at >< at > static uint32_t pit_ioport_read(void *opaque, uint32_t addr)
}
/* global counters for time-drift fix */
-int64_t timer_acks=0, timer_interrupts=0, timer_ints_to_push=0;
+extern int64_t timer_acks, timer_ints_to_push;
+int64_t timer_interrupts=0;
extern int time_drift_fix;
diff --git a/hw/i8259.c b/hw/i8259.c
index c5841c0..f33a25d 100644
--- a/hw/i8259.c
+++ b/hw/i8259.c
< at >< at > -211,7 +211,7 < at >< at > static void pic_intack(PicState *s, int irq)
}
extern int time_drift_fix;
-extern int64_t timer_acks, timer_ints_to_push;
+int64_t timer_acks=0, timer_ints_to_push=0;
int pic_read_irq(PicState *s)
{
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Benjamin Herrenschmidt
2012-05-24T02:15:10
-
Re: [PATCH qom-next 00/59] QOM CPUState, part 4: CPU_COMMON
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91372
<pre>
Unfortunately I don't have superb ideas today (as if I had them any
other day...), only second rate jokes (as if they could be called
jokes...). With 'Blah' I obviously meant that I didn't have a solution
for that particular target_ulong/target_phys_addr_t problem. I'll try
to improve on all these areas, if you know what I mean.
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Blue Swirl
2012-05-23T19:36:39
-
[PATCH v5 7/9] KVM: MMU: trace fast page fault
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91368
<pre>To see what happen on this path and help us to optimize it
Signed-off-by: Xiao Guangrong <xiaoguangrong< at >linux.vnet.ibm.com>
---
arch/x86/kvm/mmu.c | 2 ++
arch/x86/kvm/mmutrace.h | 41 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 43 insertions(+), 0 deletions(-)
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index aded056..ab4dfeb 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
< at >< at > -2801,6 +2801,8 < at >< at > static bool fast_page_fault(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
spte, gfn);
exit:
+trace_fast_page_fault(vcpu, gva, gfn, error_code, iterator.sptep,
+ spte, ret);
walk_shadow_page_lockless_end(vcpu);
return ret;
diff --git a/arch/x86/kvm/mmutrace.h b/arch/x86/kvm/mmutrace.h
index 89fb0e8..84da94f 100644
--- a/arch/x86/kvm/mmutrace.h
+++ b/arch/x86/kvm/mmutrace.h
< at >< at > -243,6 +243,47 < at >< at > TRACE_EVENT(
TP_printk("addr:%llx gfn %llx access %x", __entry->addr, __entry->gfn,
__entry->access)
);
+
+#define __spte_satisfied(__spte)\
+(__entry->retry && is_writable_pte(__entry->__spte))
+
+TRACE_EVENT(
+fast_page_fault,
+TP_PROTO(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn, u32 error_code,
+ u64 *sptep, u64 old_spte, bool retry),
+TP_ARGS(vcpu, gva, gfn, error_code, sptep, old_spte, retry),
+
+TP_STRUCT__entry(
+__field(int, vcpu_id)
+__field(gva_t, gva)
+__field(gfn_t, gfn)
+__field(u32, error_code)
+__field(u64 *, sptep)
+__field(u64, old_spte)
+__field(u64, new_spte)
+__field(bool, retry)
+),
+
+TP_fast_assign(
+__entry->vcpu_id = vcpu->vcpu_id;
+__entry->gva = gva;
+__entry->gfn = gfn;
+__entry->error_code = error_code;
+__entry->sptep = sptep;
+__entry->old_spte = old_spte;
+__entry->new_spte = *sptep;
+__entry->retry = retry;
+),
+
+TP_printk("vcpu %d gva %lx gfn %llx error_code %s sptep %p "
+ "old %#llx new %llx spurious %d fixed %d", __entry->vcpu_id,
+ __entry->gva, __entry->gfn,
+ __print_flags(__entry->error_code, "|",
+kvm_mmu_trace_pferr_flags),
+ __entry->sptep, __entry->old_spte, __entry->new_spte,
+ __spte_satisfied(old_spte), __spte_satisfied(new_spte)
+)
+);
#endif /* _TRACE_KVMMMU_H */
#undef TRACE_INCLUDE_PATH
</pre>
Xiao Guangrong
2012-05-23T08:56:30
-
[PATCH] kvm: document lapic regs field
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91365
<pre>The logic in find_highest_vector looks
strange until you realize the reason for the
weird memory layout, which is because this is
what the CPU microcode expects.
Add a comment so this stops tripping people up.
Signed-off-by: Michael S. Tsirkin <mst< at >redhat.com>
---
arch/x86/kvm/lapic.h | 5 +++++
1 files changed, 5 insertions(+), 0 deletions(-)
diff --git a/arch/x86/kvm/lapic.h b/arch/x86/kvm/lapic.h
index 41c62c7..1d1ec08 100644
--- a/arch/x86/kvm/lapic.h
+++ b/arch/x86/kvm/lapic.h
< at >< at > -15,6 +15,11 < at >< at > struct kvm_lapic {
bool irr_pending;
s16 isr_count;
int isr_cache;
+/**
+ * APIC register page. The layout matches the register layout seen by
+ * the guest 1:1, because it is accessed by the vmx microcode.
+ * Note: Only one register, the TPR, is used by the microcode.
+ */
void *regs;
gpa_t vapic_addr;
struct page *vapic_page;
</pre>
Michael S. Tsirkin
2012-05-23T16:16:14
-
Re: [PATCH v2 15/15] net: invoke qemu_can_send_packet only before net queue sending function
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91364
<pre>Il 23/05/2012 17:14, zwu.kernel< at >gmail.com ha scritto:
Can you explain this? Also, have you benchmarked the change to see what
effect it has?
Also, can you explain why you didn't implement this?
Paolo
--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to majordomo< at >vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
</pre>
Paolo Bonzini
2012-05-23T16:00:21
-
[PATCH v2 06/15] net: Remove vlan qdev property
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91363
<pre>From: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
The vlan feature is implemented using hubs and no longer uses
special-purpose VLANState structs that are accessible as qdev
properties.
Signed-off-by: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
hw/qdev-properties.c | 72 --------------------------------------------------
hw/qdev.c | 2 -
hw/qdev.h | 4 ---
net.h | 3 --
4 files changed, 0 insertions(+), 81 deletions(-)
diff --git a/hw/qdev-properties.c b/hw/qdev-properties.c
index b7b5597..d2e2afb 100644
--- a/hw/qdev-properties.c
+++ b/hw/qdev-properties.c
< at >< at > -623,71 +623,6 < at >< at > PropertyInfo qdev_prop_netdev = {
.set = set_netdev,
};
-/* --- vlan --- */
-
-static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
-{
- VLANState **ptr = qdev_get_prop_ptr(dev, prop);
-
- if (*ptr) {
- return snprintf(dest, len, "%d", (*ptr)->id);
- } else {
- return snprintf(dest, len, "<null>");
- }
-}
-
-static void get_vlan(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
-{
- DeviceState *dev = DEVICE(obj);
- Property *prop = opaque;
- VLANState **ptr = qdev_get_prop_ptr(dev, prop);
- int64_t id;
-
- id = *ptr ? (*ptr)->id : -1;
- visit_type_int(v, &id, name, errp);
-}
-
-static void set_vlan(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
-{
- DeviceState *dev = DEVICE(obj);
- Property *prop = opaque;
- VLANState **ptr = qdev_get_prop_ptr(dev, prop);
- Error *local_err = NULL;
- int64_t id;
- VLANState *vlan;
-
- if (dev->state != DEV_STATE_CREATED) {
- error_set(errp, QERR_PERMISSION_DENIED);
- return;
- }
-
- visit_type_int(v, &id, name, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- return;
- }
- if (id == -1) {
- *ptr = NULL;
- return;
- }
- vlan = qemu_find_vlan(id, 1);
- if (!vlan) {
- error_set(errp, QERR_INVALID_PARAMETER_VALUE,
- name, prop->info->name);
- return;
- }
- *ptr = vlan;
-}
-
-PropertyInfo qdev_prop_vlan = {
- .name = "vlan",
- .print = print_vlan,
- .get = get_vlan,
- .set = set_vlan,
-};
-
/* --- pointer --- */
/* Not a proper property, just for dirty hacks. TODO Remove it! */
< at >< at > -1094,13 +1029,6 < at >< at > void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *v
assert_no_error(errp);
}
-void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
-{
- Error *errp = NULL;
- object_property_set_int(OBJECT(dev), value ? value->id : -1, name, &errp);
- assert_no_error(errp);
-}
-
void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
{
Error *errp = NULL;
diff --git a/hw/qdev.c b/hw/qdev.c
index 6a8f6bd..49dd303 100644
--- a/hw/qdev.c
+++ b/hw/qdev.c
< at >< at > -316,8 +316,6 < at >< at > void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
{
qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
- if (nd->vlan)
- qdev_prop_set_vlan(dev, "vlan", nd->vlan);
if (nd->netdev)
qdev_prop_set_netdev(dev, "netdev", nd->netdev);
if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
diff --git a/hw/qdev.h b/hw/qdev.h
index 4e90119..0a50a40 100644
--- a/hw/qdev.h
+++ b/hw/qdev.h
< at >< at > -222,7 +222,6 < at >< at > extern PropertyInfo qdev_prop_macaddr;
extern PropertyInfo qdev_prop_losttickpolicy;
extern PropertyInfo qdev_prop_drive;
extern PropertyInfo qdev_prop_netdev;
-extern PropertyInfo qdev_prop_vlan;
extern PropertyInfo qdev_prop_pci_devfn;
extern PropertyInfo qdev_prop_blocksize;
< at >< at > -277,8 +276,6 < at >< at > extern PropertyInfo qdev_prop_blocksize;
DEFINE_PROP(_n, _s, _f, qdev_prop_string, char*)
#define DEFINE_PROP_NETDEV(_n, _s, _f) \
DEFINE_PROP(_n, _s, _f, qdev_prop_netdev, VLANClientState*)
-#define DEFINE_PROP_VLAN(_n, _s, _f) \
- DEFINE_PROP(_n, _s, _f, qdev_prop_vlan, VLANState*)
#define DEFINE_PROP_DRIVE(_n, _s, _f) \
DEFINE_PROP(_n, _s, _f, qdev_prop_drive, BlockDriverState *)
#define DEFINE_PROP_MACADDR(_n, _s, _f) \
< at >< at > -305,7 +302,6 < at >< at > void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value);
void qdev_prop_set_string(DeviceState *dev, const char *name, char *value);
void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value);
void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value);
-void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value);
int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value) QEMU_WARN_UNUSED_RESULT;
void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value);
void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value);
diff --git a/net.h b/net.h
index d3d6e4c..7d18b10 100644
--- a/net.h
+++ b/net.h
< at >< at > -16,14 +16,12 < at >< at > struct MACAddr {
typedef struct NICConf {
MACAddr macaddr;
- VLANState *vlan;
VLANClientState *peer;
int32_t bootindex;
} NICConf;
#define DEFINE_NIC_PROPERTIES(_state, _conf) \
DEFINE_PROP_MACADDR("mac", _state, _conf.macaddr), \
- DEFINE_PROP_VLAN("vlan", _state, _conf.vlan), \
DEFINE_PROP_NETDEV("netdev", _state, _conf.peer), \
DEFINE_PROP_INT32("bootindex", _state, _conf.bootindex, -1)
< at >< at > -134,7 +132,6 < at >< at > struct NICInfo {
char *model;
char *name;
char *devaddr;
- VLANState *vlan;
VLANClientState *netdev;
int used; /* is this slot in nd_table[] being used? */
int instantiated; /* does this NICInfo correspond to an instantiated NIC? */
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:13:56
-
[PATCH v2 08/15] net: Remove VLANState
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91362
<pre>From: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
VLANState is no longer used and can be removed.
Signed-off-by: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net.c | 127 ++++++++++-----------------------------------------------
net.h | 8 ----
net/socket.c | 6 +-
net/tap.c | 6 +-
net/tap.h | 2 +-
qemu-common.h | 1 -
6 files changed, 29 insertions(+), 121 deletions(-)
diff --git a/net.c b/net.c
index abf5a3d..eb2ad06 100644
--- a/net.c
+++ b/net.c
< at >< at > -44,7 +44,6 < at >< at >
# define CONFIG_NET_BRIDGE
#endif
-static QTAILQ_HEAD(, VLANState) vlans;
static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
int default_net = 1;
< at >< at > -249,11 +248,7 < at >< at > NICState *qemu_new_nic(NetClientInfo *info,
static void qemu_cleanup_vlan_client(VLANClientState *vc)
{
- if (vc->vlan) {
- QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
- } else {
- QTAILQ_REMOVE(&non_vlan_clients, vc, next);
- }
+ QTAILQ_REMOVE(&non_vlan_clients, vc, next);
if (vc->info->cleanup) {
vc->info->cleanup(vc);
< at >< at > -262,13 +257,11 < at >< at > static void qemu_cleanup_vlan_client(VLANClientState *vc)
static void qemu_free_vlan_client(VLANClientState *vc)
{
- if (!vc->vlan) {
- if (vc->send_queue) {
- qemu_del_net_queue(vc->send_queue);
- }
- if (vc->peer) {
- vc->peer->peer = NULL;
- }
+ if (vc->send_queue) {
+ qemu_del_net_queue(vc->send_queue);
+ }
+ if (vc->peer) {
+ vc->peer->peer = NULL;
}
g_free(vc->name);
g_free(vc->model);
< at >< at > -278,7 +271,7 < at >< at > static void qemu_free_vlan_client(VLANClientState *vc)
void qemu_del_vlan_client(VLANClientState *vc)
{
/* If there is a peer NIC, delete and cleanup client, but do not free. */
- if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
+ if (vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
if (nic->peer_deleted) {
return;
< at >< at > -294,7 +287,7 < at >< at > void qemu_del_vlan_client(VLANClientState *vc)
}
/* If this is a peer NIC and peer has already been deleted, free it now. */
- if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
+ if (vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
NICState *nic = DO_UPCAST(NICState, nc, vc);
if (nic->peer_deleted) {
qemu_free_vlan_client(vc->peer);
< at >< at > -308,52 +301,25 < at >< at > void qemu_del_vlan_client(VLANClientState *vc)
void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
{
VLANClientState *nc;
- VLANState *vlan;
QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
if (nc->info->type == NET_CLIENT_TYPE_NIC) {
func(DO_UPCAST(NICState, nc, nc), opaque);
}
}
-
- QTAILQ_FOREACH(vlan, &vlans, next) {
- QTAILQ_FOREACH(nc, &vlan->clients, next) {
- if (nc->info->type == NET_CLIENT_TYPE_NIC) {
- func(DO_UPCAST(NICState, nc, nc), opaque);
- }
- }
- }
}
int qemu_can_send_packet(VLANClientState *sender)
{
- VLANState *vlan = sender->vlan;
- VLANClientState *vc;
-
- if (sender->peer) {
- if (sender->peer->receive_disabled) {
- return 0;
- } else if (sender->peer->info->can_receive &&
- !sender->peer->info->can_receive(sender->peer)) {
- return 0;
- } else {
- return 1;
- }
- }
-
- if (!sender->vlan) {
+ if (!sender->peer) {
return 1;
}
- QTAILQ_FOREACH(vc, &vlan->clients, next) {
- if (vc == sender) {
- continue;
- }
-
- /* no can_receive() handler, they can always receive */
- if (vc->info->can_receive && !vc->info->can_receive(vc)) {
- return 0;
- }
+ if (sender->peer->receive_disabled) {
+ return 0;
+ } else if (sender->peer->info->can_receive &&
+ !sender->peer->info->can_receive(sender->peer)) {
+ return 0;
}
return 1;
}
< at >< at > -390,34 +356,18 < at >< at > static ssize_t qemu_deliver_packet(VLANClientState *sender,
void qemu_purge_queued_packets(VLANClientState *vc)
{
- NetQueue *queue;
-
- if (!vc->peer && !vc->vlan) {
+ if (!vc->peer) {
return;
}
- if (vc->peer) {
- queue = vc->peer->send_queue;
- } else {
- queue = vc->vlan->send_queue;
- }
-
- qemu_net_queue_purge(queue, vc);
+ qemu_net_queue_purge(vc->peer->send_queue, vc);
}
void qemu_flush_queued_packets(VLANClientState *vc)
{
- NetQueue *queue;
-
vc->receive_disabled = 0;
- if (vc->vlan) {
- queue = vc->vlan->send_queue;
- } else {
- queue = vc->send_queue;
- }
-
- qemu_net_queue_flush(queue);
+ qemu_net_queue_flush(vc->send_queue);
}
static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
< at >< at > -432,15 +382,11 < at >< at > static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
hex_dump(stdout, buf, size);
#endif
- if (sender->link_down || (!sender->peer && !sender->vlan)) {
+ if (sender->link_down || !sender->peer) {
return size;
}
- if (sender->peer) {
- queue = sender->peer->send_queue;
- } else {
- queue = sender->vlan->send_queue;
- }
+ queue = sender->peer->send_queue;
return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
}
< at >< at > -500,15 +446,11 < at >< at > ssize_t qemu_sendv_packet_async(VLANClientState *sender,
{
NetQueue *queue;
- if (sender->link_down || (!sender->peer && !sender->vlan)) {
+ if (sender->link_down || !sender->peer) {
return iov_size(iov, iovcnt);
}
- if (sender->peer) {
- queue = sender->peer->send_queue;
- } else {
- queue = sender->vlan->send_queue;
- }
+ queue = sender->peer->send_queue;
return qemu_net_queue_send_iov(queue, sender,
QEMU_NET_PACKET_FLAG_NONE,
< at >< at > -1134,18 +1076,9 < at >< at > static void print_net_client(Monitor *mon, VLANClientState *vc)
void do_info_network(Monitor *mon)
{
- VLANState *vlan;
VLANClientState *vc, *peer;
net_client_type type;
- QTAILQ_FOREACH(vlan, &vlans, next) {
- monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
-
- QTAILQ_FOREACH(vc, &vlan->clients, next) {
- monitor_printf(mon, " ");
- print_net_client(mon, vc);
- }
- }
monitor_printf(mon, "Devices not on any VLAN:\n");
QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
peer = vc->peer;
< at >< at > -1164,16 +1097,8 < at >< at > void do_info_network(Monitor *mon)
void qmp_set_link(const char *name, bool up, Error **errp)
{
- VLANState *vlan;
VLANClientState *vc = NULL;
- QTAILQ_FOREACH(vlan, &vlans, next) {
- QTAILQ_FOREACH(vc, &vlan->clients, next) {
- if (strcmp(vc->name, name) == 0) {
- goto done;
- }
- }
- }
QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
if (!strcmp(vc->name, name)) {
goto done;
< at >< at > -1182,7 +1107,7 < at >< at > void qmp_set_link(const char *name, bool up, Error **errp)
done:
if (!vc) {
- error_set(errp, QERR_DEVICE_NOT_FOUND, name);
+ qerror_report(QERR_DEVICE_NOT_FOUND, name);
return;
}
< at >< at > -1206,15 +1131,8 < at >< at > done:
void net_cleanup(void)
{
- VLANState *vlan;
VLANClientState *vc, *next_vc;
- QTAILQ_FOREACH(vlan, &vlans, next) {
- QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
- qemu_del_vlan_client(vc);
- }
- }
-
QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
qemu_del_vlan_client(vc);
}
< at >< at > -1286,7 +1204,6 < at >< at > int net_init_clients(void)
#endif
}
- QTAILQ_INIT(&vlans);
QTAILQ_INIT(&non_vlan_clients);
if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
diff --git a/net.h b/net.h
index a4ac48d..2482546 100644
--- a/net.h
+++ b/net.h
< at >< at > -64,7 +64,6 < at >< at > struct VLANClientState {
NetClientInfo *info;
int link_down;
QTAILQ_ENTRY(VLANClientState) next;
- struct VLANState *vlan;
VLANClientState *peer;
NetQueue *send_queue;
char *model;
< at >< at > -80,13 +79,6 < at >< at > typedef struct NICState {
bool peer_deleted;
} NICState;
-struct VLANState {
- int id;
- QTAILQ_HEAD(, VLANClientState) clients;
- QTAILQ_ENTRY(VLANState) next;
- NetQueue *send_queue;
-};
-
VLANClientState *qemu_find_netdev(const char *id);
VLANClientState *qemu_new_net_client(NetClientInfo *info,
VLANClientState *peer,
diff --git a/net/socket.c b/net/socket.c
index bf7a793..5676bd5 100644
--- a/net/socket.c
+++ b/net/socket.c
< at >< at > -536,7 +536,7 < at >< at > static int net_socket_mcast_init(VLANClientState *peer,
}
-static int net_socket_udp_init(VLANState *vlan,
+static int net_socket_udp_init(NetClientState *peer,
const char *model,
const char *name,
const char *rhost,
< at >< at > -574,7 +574,7 < at >< at > static int net_socket_udp_init(VLANState *vlan,
return -1;
}
- s = net_socket_fd_init(vlan, model, name, fd, 0);
+ s = net_socket_fd_init(peer, model, name, fd, 0);
if (!s) {
return -1;
}
< at >< at > -680,7 +680,7 < at >< at > int net_init_socket(QemuOpts *opts,
return -1;
}
- if (net_socket_udp_init(vlan, "udp", name, udp, localaddr) == -1) {
+ if (net_socket_udp_init(peer, "udp", name, udp, localaddr) == -1) {
return -1;
}
} else {
diff --git a/net/tap.c b/net/tap.c
index 3a68d7e..7dbf643 100644
--- a/net/tap.c
+++ b/net/tap.c
< at >< at > -513,7 +513,7 < at >< at > static int net_bridge_run_helper(const char *helper, const char *bridge)
}
int net_init_bridge(QemuOpts *opts, Monitor *mon, const char *name,
- VLANState *vlan)
+ NetClientState *peer)
{
TAPState *s;
int fd, vnet_hdr;
< at >< at > -535,7 +535,7 < at >< at > int net_init_bridge(QemuOpts *opts, Monitor *mon, const char *name,
vnet_hdr = tap_probe_vnet_hdr(fd);
- s = net_tap_fd_init(vlan, "bridge", name, fd, vnet_hdr);
+ s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
if (!s) {
close(fd);
return -1;
< at >< at > -651,7 +651,7 < at >< at > int net_init_tap(QemuOpts *opts, Monitor *mon, const char *name,
model = "tap";
}
- s = net_tap_fd_init(vlan, model, name, fd, vnet_hdr);
+ s = net_tap_fd_init(peer, model, name, fd, vnet_hdr);
if (!s) {
close(fd);
return -1;
diff --git a/net/tap.h b/net/tap.h
index c194684..8d949cd 100644
--- a/net/tap.h
+++ b/net/tap.h
< at >< at > -59,6 +59,6 < at >< at > struct vhost_net;
struct vhost_net *tap_get_vhost_net(VLANClientState *vc);
int net_init_bridge(QemuOpts *opts, Monitor *mon, const char *name,
- VLANState *vlan);
+ NetClientState *peer);
#endif /* QEMU_NET_TAP_H */
diff --git a/qemu-common.h b/qemu-common.h
index cccfb42..9443c7a 100644
--- a/qemu-common.h
+++ b/qemu-common.h
< at >< at > -235,7 +235,6 < at >< at > typedef struct TextConsole TextConsole;
typedef TextConsole QEMUConsole;
typedef struct CharDriverState CharDriverState;
typedef struct MACAddr MACAddr;
-typedef struct VLANState VLANState;
typedef struct VLANClientState VLANClientState;
typedef struct i2c_bus i2c_bus;
typedef struct ISABus ISABus;
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:13:58
-
[PATCH v2 15/15] net: invoke qemu_can_send_packet only before net queue sending function
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91358
<pre>From: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net/queue.c | 4 ++--
net/slirp.c | 7 -------
net/tap.c | 2 +-
slirp/if.c | 5 -----
slirp/libslirp.h | 1 -
5 files changed, 3 insertions(+), 16 deletions(-)
diff --git a/net/queue.c b/net/queue.c
index 0afd783..d2e57de 100644
--- a/net/queue.c
+++ b/net/queue.c
< at >< at > -176,7 +176,7 < at >< at > ssize_t qemu_net_queue_send(NetQueue *queue,
{
ssize_t ret;
- if (queue->delivering) {
+ if (queue->delivering || !qemu_can_send_packet(sender)) {
return qemu_net_queue_append(queue, sender, flags, data, size, NULL);
}
< at >< at > -200,7 +200,7 < at >< at > ssize_t qemu_net_queue_send_iov(NetQueue *queue,
{
ssize_t ret;
- if (queue->delivering) {
+ if (queue->delivering || !qemu_can_send_packet(sender)) {
return qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, NULL);
}
diff --git a/net/slirp.c b/net/slirp.c
index a6ede2b..248f7ff 100644
--- a/net/slirp.c
+++ b/net/slirp.c
< at >< at > -96,13 +96,6 < at >< at > static void slirp_smb_cleanup(SlirpState *s);
static inline void slirp_smb_cleanup(SlirpState *s) { }
#endif
-int slirp_can_output(void *opaque)
-{
- SlirpState *s = opaque;
-
- return qemu_can_send_packet(&s->nc);
-}
-
void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
{
SlirpState *s = opaque;
diff --git a/net/tap.c b/net/tap.c
index 65f45b8..7b1992b 100644
--- a/net/tap.c
+++ b/net/tap.c
< at >< at > -210,7 +210,7 < at >< at > static void tap_send(void *opaque)
if (size == 0) {
tap_read_poll(s, 0);
}
- } while (size > 0 && qemu_can_send_packet(&s->nc));
+ } while (size > 0);
}
int tap_has_ufo(NetClientState *nc)
diff --git a/slirp/if.c b/slirp/if.c
index 096cf6f..533295d 100644
--- a/slirp/if.c
+++ b/slirp/if.c
< at >< at > -177,11 +177,6 < at >< at > void if_start(Slirp *slirp)
}
while (ifm_next) {
- /* check if we can really output */
- if (!slirp_can_output(slirp->opaque)) {
- break;
- }
-
ifm = ifm_next;
from_batchq = next_from_batchq;
diff --git a/slirp/libslirp.h b/slirp/libslirp.h
index 77527ad..9b471b5 100644
--- a/slirp/libslirp.h
+++ b/slirp/libslirp.h
< at >< at > -25,7 +25,6 < at >< at > void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len);
/* you must provide the following functions: */
-int slirp_can_output(void *opaque);
void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len);
int slirp_add_hostfwd(Slirp *slirp, int is_udp,
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:14:05
-
[PATCH v2 05/15] net: Drop vlan argument to qemu_new_net_client()
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91357
<pre>From: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Since hubs are now used to implement the 'vlan' feature and the vlan
argument is always NULL, remove the argument entirely and update all net
clients that use qemu_new_net_client().
Signed-off-by: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net.c | 27 ++++++++++-----------------
net.h | 1 -
net/dump.c | 2 +-
net/hub.c | 2 +-
net/slirp.c | 2 +-
net/socket.c | 4 ++--
net/tap-win32.c | 2 +-
net/tap.c | 2 +-
net/vde.c | 2 +-
9 files changed, 18 insertions(+), 26 deletions(-)
diff --git a/net.c b/net.c
index 88b9e1f..96252f9 100644
--- a/net.c
+++ b/net.c
< at >< at > -194,7 +194,6 < at >< at > static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
void *opaque);
VLANClientState *qemu_new_net_client(NetClientInfo *info,
- VLANState *vlan,
VLANClientState *peer,
const char *model,
const char *name)
< at >< at > -213,22 +212,16 < at >< at > VLANClientState *qemu_new_net_client(NetClientInfo *info,
vc->name = assign_name(vc, model);
}
- if (vlan) {
- assert(!peer);
- vc->vlan = vlan;
- QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
- } else {
- if (peer) {
- assert(!peer->peer);
- vc->peer = peer;
- peer->peer = vc;
- }
- QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
-
- vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
- qemu_deliver_packet_iov,
- vc);
+ if (peer) {
+ assert(!peer->peer);
+ vc->peer = peer;
+ peer->peer = vc;
}
+ QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
+
+ vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
+ qemu_deliver_packet_iov,
+ vc);
return vc;
}
< at >< at > -245,7 +238,7 < at >< at > NICState *qemu_new_nic(NetClientInfo *info,
assert(info->type == NET_CLIENT_TYPE_NIC);
assert(info->size >= sizeof(NICState));
- nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
+ nc = qemu_new_net_client(info, conf->peer, model, name);
nic = DO_UPCAST(NICState, nc, nc);
nic->conf = conf;
diff --git a/net.h b/net.h
index 50c55ad..d3d6e4c 100644
--- a/net.h
+++ b/net.h
< at >< at > -92,7 +92,6 < at >< at > struct VLANState {
VLANState *qemu_find_vlan(int id, int allocate);
VLANClientState *qemu_find_netdev(const char *id);
VLANClientState *qemu_new_net_client(NetClientInfo *info,
- VLANState *vlan,
VLANClientState *peer,
const char *model,
const char *name);
diff --git a/net/dump.c b/net/dump.c
index 37cec3c..621f4e7 100644
--- a/net/dump.c
+++ b/net/dump.c
< at >< at > -129,7 +129,7 < at >< at > static int net_dump_init(VLANClientState *peer, const char *device,
return -1;
}
- nc = qemu_new_net_client(&net_dump_info, NULL, peer, device, name);
+ nc = qemu_new_net_client(&net_dump_info, peer, device, name);
snprintf(nc->info_str, sizeof(nc->info_str),
"dump to %s (len=%d)", filename, len);
diff --git a/net/hub.c b/net/hub.c
index 19c1169..af3de9c 100644
--- a/net/hub.c
+++ b/net/hub.c
< at >< at > -124,7 +124,7 < at >< at > static NetHubPort *net_hub_port_new(NetHub *hub)
snprintf(name, sizeof name, "hub%uport%u", hub->id, id);
- nc = qemu_new_net_client(&net_hub_port_info, NULL, NULL, "hub", name);
+ nc = qemu_new_net_client(&net_hub_port_info, NULL, "hub", name);
port = DO_UPCAST(NetHubPort, nc, nc);
port->id = id;
port->hub = hub;
diff --git a/net/slirp.c b/net/slirp.c
index edb4621..5ed7036 100644
--- a/net/slirp.c
+++ b/net/slirp.c
< at >< at > -238,7 +238,7 < at >< at > static int net_slirp_init(VLANClientState *peer, const char *model,
}
#endif
- nc = qemu_new_net_client(&net_slirp_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_slirp_info, peer, model, name);
snprintf(nc->info_str, sizeof(nc->info_str),
"net=%s,restrict=%s", inet_ntoa(net),
diff --git a/net/socket.c b/net/socket.c
index ed28cbd..bf7a793 100644
--- a/net/socket.c
+++ b/net/socket.c
< at >< at > -286,7 +286,7 < at >< at > static NetSocketState *net_socket_fd_init_dgram(VLANClientState *peer,
}
}
- nc = qemu_new_net_client(&net_dgram_socket_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
snprintf(nc->info_str, sizeof(nc->info_str),
"socket: fd=%d (%s mcast=%s:%d)",
< at >< at > -330,7 +330,7 < at >< at > static NetSocketState *net_socket_fd_init_stream(VLANClientState *peer,
VLANClientState *nc;
NetSocketState *s;
- nc = qemu_new_net_client(&net_socket_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_socket_info, peer, model, name);
snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
diff --git a/net/tap-win32.c b/net/tap-win32.c
index 2436c26..c1f90c7 100644
--- a/net/tap-win32.c
+++ b/net/tap-win32.c
< at >< at > -685,7 +685,7 < at >< at > static int tap_win32_init(VLANClientState *peer, const char *model,
return -1;
}
- nc = qemu_new_net_client(&net_tap_win32_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_tap_win32_info, peer, model, name);
s = DO_UPCAST(TAPState, nc, nc);
diff --git a/net/tap.c b/net/tap.c
index 8855c57..3a68d7e 100644
--- a/net/tap.c
+++ b/net/tap.c
< at >< at > -330,7 +330,7 < at >< at > static TAPState *net_tap_fd_init(VLANClientState *peer,
VLANClientState *nc;
TAPState *s;
- nc = qemu_new_net_client(&net_tap_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_tap_info, peer, model, name);
s = DO_UPCAST(TAPState, nc, nc);
diff --git a/net/vde.c b/net/vde.c
index d998daf..24d12d4 100644
--- a/net/vde.c
+++ b/net/vde.c
< at >< at > -96,7 +96,7 < at >< at > static int net_vde_init(VLANClientState *peer, const char *model,
return -1;
}
- nc = qemu_new_net_client(&net_vde_info, NULL, peer, model, name);
+ nc = qemu_new_net_client(&net_vde_info, peer, model, name);
snprintf(nc->info_str, sizeof(nc->info_str), "sock=%s,fd=%d",
sock, vde_datafd(vde));
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:13:55
-
[PATCH v2 03/15] net: Look up 'vlan' net clients using hubs
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91356
<pre>From: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net.c | 28 +---------------------------
net/hub.c | 24 ++++++++++++++++++++++++
net/hub.h | 2 ++
net/slirp.c | 5 +++--
4 files changed, 30 insertions(+), 29 deletions(-)
diff --git a/net.c b/net.c
index 8c02559..d9c7eac 100644
--- a/net.c
+++ b/net.c
< at >< at > -312,32 +312,6 < at >< at > void qemu_del_vlan_client(VLANClientState *vc)
qemu_free_vlan_client(vc);
}
-VLANClientState *
-qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
- const char *client_str)
-{
- VLANState *vlan;
- VLANClientState *vc;
-
- vlan = qemu_find_vlan(vlan_id, 0);
- if (!vlan) {
- monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
- return NULL;
- }
-
- QTAILQ_FOREACH(vc, &vlan->clients, next) {
- if (!strcmp(vc->name, client_str)) {
- break;
- }
- }
- if (!vc) {
- monitor_printf(mon, "can't find device %s on VLAN %d\n",
- client_str, vlan_id);
- }
-
- return vc;
-}
-
void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
{
VLANClientState *nc;
< at >< at > -1223,7 +1197,7 < at >< at > void net_host_device_remove(Monitor *mon, const QDict *qdict)
int vlan_id = qdict_get_int(qdict, "vlan_id");
const char *device = qdict_get_str(qdict, "device");
- vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
+ vc = net_hub_find_client_by_name(vlan_id, device);
if (!vc) {
return;
}
diff --git a/net/hub.c b/net/hub.c
index 0d3df7f..3cd1249 100644
--- a/net/hub.c
+++ b/net/hub.c
< at >< at > -159,6 +159,30 < at >< at > VLANClientState *net_hub_add_port(unsigned int hub_id)
}
/**
+ * Find a specific client on a hub
+ */
+VLANClientState *net_hub_find_client_by_name(unsigned int hub_id,
+ const char *name)
+{
+ NetHub *hub;
+ NetHubPort *port;
+ VLANClientState *peer;
+
+ QLIST_FOREACH(hub, &hubs, next) {
+ if (hub->id == hub_id) {
+ QLIST_FOREACH(port, &hub->ports, next) {
+ peer = port->nc.peer;
+
+ if (peer && strcmp(peer->name, name) == 0) {
+ return peer;
+ }
+ }
+ }
+ }
+ return NULL;
+}
+
+/**
* Print hub configuration
*/
void net_hub_info(Monitor *mon)
diff --git a/net/hub.h b/net/hub.h
index 3ca05dc..60d4cae 100644
--- a/net/hub.h
+++ b/net/hub.h
< at >< at > -17,6 +17,8 < at >< at >
#include "qemu-common.h"
VLANClientState *net_hub_add_port(unsigned int hub_id);
+VLANClientState *net_hub_find_client_by_name(unsigned int hub_id,
+ const char *name);
void net_hub_info(Monitor *mon);
int net_hub_id_for_client(VLANClientState *nc, unsigned int *id);
diff --git a/net/slirp.c b/net/slirp.c
index fa7c7fc..edb4621 100644
--- a/net/slirp.c
+++ b/net/slirp.c
< at >< at > -29,6 +29,7 < at >< at >
#include <sys/wait.h>
#endif
#include "net.h"
+#include "net/hub.h"
#include "monitor.h"
#include "qemu_socket.h"
#include "slirp/libslirp.h"
< at >< at > -283,7 +284,7 < at >< at > static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
if (vlan) {
VLANClientState *nc;
- nc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
+ nc = net_hub_find_client_by_name(strtol(vlan, NULL, 0), stack);
if (!nc) {
return NULL;
}
< at >< at > -648,7 +649,7 < at >< at > void do_info_usernet(Monitor *mon)
QTAILQ_FOREACH(s, &slirp_stacks, entry) {
monitor_printf(mon, "VLAN %d (%s):\n",
- s->nc.vlan ? s->nc.vlan->id : -1,
+ -1, /* TODO */
s->nc.name);
slirp_connection_info(s->slirp, mon);
}
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:13:53
-
[PATCH v2 04/15] hub: Check that hubs are configured correctly
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91352
<pre>From: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Checks can be performed to make sure that hubs have at least one NIC and
one host device, warning the user if this is not the case.
Configurations which do not meet this rule tend to be broken but just
emit a warning. This patch preserves compatibility with the checks
performed by net core on vlans.
Signed-off-by: Stefan Hajnoczi <stefanha< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net.c | 25 +------------------------
net/hub.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
net/hub.h | 1 +
3 files changed, 47 insertions(+), 24 deletions(-)
diff --git a/net.c b/net.c
index d9c7eac..88b9e1f 100644
--- a/net.c
+++ b/net.c
< at >< at > -1337,7 +1337,6 < at >< at > void net_cleanup(void)
void net_check_clients(void)
{
- VLANState *vlan;
VLANClientState *vc;
int i;
< at >< at > -1353,30 +1352,8 < at >< at > void net_check_clients(void)
return;
}
- QTAILQ_FOREACH(vlan, &vlans, next) {
- int has_nic = 0, has_host_dev = 0;
+ net_hub_check_clients();
- QTAILQ_FOREACH(vc, &vlan->clients, next) {
- switch (vc->info->type) {
- case NET_CLIENT_TYPE_NIC:
- has_nic = 1;
- break;
- case NET_CLIENT_TYPE_USER:
- case NET_CLIENT_TYPE_TAP:
- case NET_CLIENT_TYPE_SOCKET:
- case NET_CLIENT_TYPE_VDE:
- has_host_dev = 1;
- break;
- default: ;
- }
- }
- if (has_host_dev && !has_nic)
- fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
- if (has_nic && !has_host_dev)
- fprintf(stderr,
- "Warning: vlan %d is not connected to host network\n",
- vlan->id);
- }
QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
if (!vc->peer) {
fprintf(stderr, "Warning: %s %s has no peer\n",
diff --git a/net/hub.c b/net/hub.c
index 3cd1249..19c1169 100644
--- a/net/hub.c
+++ b/net/hub.c
< at >< at > -222,3 +222,48 < at >< at > int net_hub_id_for_client(VLANClientState *nc, unsigned int *id)
}
return -ENOENT;
}
+
+/**
+ * Warn if hub configurations are likely wrong
+ */
+void net_hub_check_clients(void)
+{
+ NetHub *hub;
+ NetHubPort *port;
+ VLANClientState *peer;
+
+ QLIST_FOREACH(hub, &hubs, next) {
+ int has_nic = 0, has_host_dev = 0;
+
+ QLIST_FOREACH(port, &hub->ports, next) {
+ peer = port->nc.peer;
+ if (!peer) {
+ fprintf(stderr, "Warning: hub port %s has no peer\n",
+ port->nc.name);
+ continue;
+ }
+
+ switch (peer->info->type) {
+ case NET_CLIENT_TYPE_NIC:
+ has_nic = 1;
+ break;
+ case NET_CLIENT_TYPE_USER:
+ case NET_CLIENT_TYPE_TAP:
+ case NET_CLIENT_TYPE_SOCKET:
+ case NET_CLIENT_TYPE_VDE:
+ has_host_dev = 1;
+ break;
+ default:
+ break;
+ }
+ }
+ if (has_host_dev && !has_nic) {
+ fprintf(stderr, "Warning: vlan %u with no nics\n", hub->id);
+ }
+ if (has_nic && !has_host_dev) {
+ fprintf(stderr,
+ "Warning: vlan %u is not connected to host network\n",
+ hub->id);
+ }
+ }
+}
diff --git a/net/hub.h b/net/hub.h
index 60d4cae..caa3b16 100644
--- a/net/hub.h
+++ b/net/hub.h
< at >< at > -21,5 +21,6 < at >< at > VLANClientState *net_hub_find_client_by_name(unsigned int hub_id,
const char *name);
void net_hub_info(Monitor *mon);
int net_hub_id_for_client(VLANClientState *nc, unsigned int *id);
+void net_hub_check_clients(void);
#endif /* NET_HUB_H */
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:13:54
-
[PATCH v2 14/15] net: cleanup deliver/deliver_iov func pointers
http://permalink.gmane.org/gmane.comp.emulators.kvm.devel/91348
<pre>From: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
Signed-off-by: Zhi Yong Wu <wuzhy< at >linux.vnet.ibm.com>
---
net.c | 35 +++++++++++------------------------
net.h | 11 +++++++++++
net/queue.c | 13 ++++---------
net/queue.h | 17 ++---------------
4 files changed, 28 insertions(+), 48 deletions(-)
diff --git a/net.c b/net.c
index 8c8e703..7360d26 100644
--- a/net.c
+++ b/net.c
< at >< at > -181,17 +181,6 < at >< at > static char *assign_name(NetClientState *nc1, const char *model)
return g_strdup(buf);
}
-static ssize_t qemu_deliver_packet(NetClientState *sender,
- unsigned flags,
- const uint8_t *data,
- size_t size,
- void *opaque);
-static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
- unsigned flags,
- const struct iovec *iov,
- int iovcnt,
- void *opaque);
-
NetClientState *qemu_new_net_client(NetClientInfo *info,
NetClientState *peer,
const char *model,
< at >< at > -218,9 +207,7 < at >< at > NetClientState *qemu_new_net_client(NetClientInfo *info,
}
QTAILQ_INSERT_TAIL(&net_clients, nc, next);
- nc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
- qemu_deliver_packet_iov,
- nc);
+ nc->send_queue = qemu_new_net_queue(nc);
return nc;
}
< at >< at > -324,11 +311,11 < at >< at > int qemu_can_send_packet(NetClientState *sender)
return 1;
}
-static ssize_t qemu_deliver_packet(NetClientState *sender,
- unsigned flags,
- const uint8_t *data,
- size_t size,
- void *opaque)
+ssize_t qemu_deliver_packet(NetClientState *sender,
+ unsigned flags,
+ const uint8_t *data,
+ size_t size,
+ void *opaque)
{
NetClientState *nc = opaque;
ssize_t ret;
< at >< at > -421,11 +408,11 < at >< at > static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
return nc->info->receive(nc, buffer, offset);
}
-static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
- unsigned flags,
- const struct iovec *iov,
- int iovcnt,
- void *opaque)
+ssize_t qemu_deliver_packet_iov(NetClientState *sender,
+ unsigned flags,
+ const struct iovec *iov,
+ int iovcnt,
+ void *opaque)
{
NetClientState *nc = opaque;
diff --git a/net.h b/net.h
index 250669a..7779b6a 100644
--- a/net.h
+++ b/net.h
< at >< at > -112,6 +112,17 < at >< at > void qemu_check_nic_model(NICInfo *nd, const char *model);
int qemu_find_nic_model(NICInfo *nd, const char * const *models,
const char *default_model);
+ssize_t qemu_deliver_packet(NetClientState *sender,
+ unsigned flags,
+ const uint8_t *data,
+ size_t size,
+ void *opaque);
+ssize_t qemu_deliver_packet_iov(NetClientState *sender,
+ unsigned flags,
+ const struct iovec *iov,
+ int iovcnt,
+ void *opaque);
+
void do_info_network(Monitor *mon);
/* NIC info */
diff --git a/net/queue.c b/net/queue.c
index 35c3463..0afd783 100644
--- a/net/queue.c
+++ b/net/queue.c
< at >< at > -23,6 +23,7 < at >< at >
#include "net/queue.h"
#include "qemu-queue.h"
+#include "net.h"
/* The delivery handler may only return zero if it will call
* qemu_net_queue_flush() when it determines that it is once again able
< at >< at > -48,8 +49,6 < at >< at > struct NetPacket {
};
struct NetQueue {
- NetPacketDeliver *deliver;
- NetPacketDeliverIOV *deliver_iov;
void *opaque;
QTAILQ_HEAD(packets, NetPacket) packets;
< at >< at > -57,16 +56,12 < at >< at > struct NetQueue {
unsigned delivering : 1;
};
-NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver,
- NetPacketDeliverIOV *deliver_iov,
- void *opaque)
+NetQueue *qemu_new_net_queue(void *opaque)
{
NetQueue *queue;
queue = g_malloc0(sizeof(NetQueue));
- queue->deliver = deliver;
- queue->deliver_iov = deliver_iov;
queue->opaque = opaque;
QTAILQ_INIT(&queue->packets);
< at >< at > -151,7 +146,7 < at >< at > static ssize_t qemu_net_queue_deliver(NetQueue *queue,
ssize_t ret = -1;
queue->delivering = 1;
- ret = queue->deliver(sender, flags, data, size, queue->opaque);
+ ret = qemu_deliver_packet(sender, flags, data, size, queue->opaque);
queue->delivering = 0;
return ret;
< at >< at > -166,7 +161,7 < at >< at > static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue,
ssize_t ret = -1;
queue->delivering = 1;
- ret = queue->deliver_iov(sender, flags, iov, iovcnt, queue->opaque);
+ ret = qemu_deliver_packet_iov(sender, flags, iov, iovcnt, queue->opaque);
queue->delivering = 0;
return ret;
diff --git a/net/queue.h b/net/queue.h
index d8eac0b..9d44a9b 100644
--- a/net/queue.h
+++ b/net/queue.h
< at >< at > -31,24 +31,11 < at >< at > typedef struct NetQueue NetQueue;
typedef void (NetPacketSent) (NetClientState *sender, ssize_t ret);
-typedef ssize_t (NetPacketDeliver) (NetClientState *sender,
- unsigned flags,
- const uint8_t *buf,
- size_t size,
- void *opaque);
-
-typedef ssize_t (NetPacketDeliverIOV) (NetClientState *sender,
- unsigned flags,
- const struct iovec *iov,
- int iovcnt,
- void *opaque);
-
#define QEMU_NET_PACKET_FLAG_NONE 0
#define QEMU_NET_PACKET_FLAG_RAW (1<<0)
-NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver,
- NetPacketDeliverIOV *deliver_iov,
- void *opaque);
+NetQueue *qemu_new_net_queue(void *opaque);
+
void qemu_del_net_queue(NetQueue *queue);
ssize_t qemu_net_queue_send(NetQueue *queue,
</pre>
zwu.kernel< at >gmail.com
2012-05-23T15:14:04
Search Engine
Search the mailing list at Gmane
query
http://search.gmane.org/?group=$group=gmane.comp.emulators.kvm.devel