From: Prasad J Pandit <address@hidden>

When IDE AHCI emulation uses Frame Information Structures(FIS)
engine for data transfer, the mapped FIS buffer address is stored
in a static 'bounce.buffer'. When a request is made to map another
memory region, address_space_map() returns NULL because
'bounce.buffer' is in_use. It leads to a null pointer dereference
error while doing 'dma_memory_unmap'. Add a check to avoid it.

Reported-by: Zuozhi fzz <address@hidden>
Signed-off-by: Prasad J Pandit <address@hidden>

Upstream-Status: Backport
https://lists.gnu.org/archive/html/qemu-devel/2016-01/msg05740.html

CVE: CVE-2016-2197
Signed-off-by: Armin Kuster <akuster@mvista.com>

---
 hw/ide/ahci.c | 16 ++++++++++------
  1 file changed, 10 insertions(+), 6 deletions(-)

  Update as per review
    -> https://lists.gnu.org/archive/html/qemu-devel/2016-01/msg05715.html

Index: qemu-2.5.0/hw/ide/ahci.c
===================================================================
--- qemu-2.5.0.orig/hw/ide/ahci.c
+++ qemu-2.5.0/hw/ide/ahci.c
@@ -661,9 +661,11 @@ static bool ahci_map_fis_address(AHCIDev
 
 static void ahci_unmap_fis_address(AHCIDevice *ad)
 {
-    dma_memory_unmap(ad->hba->as, ad->res_fis, 256,
-                     DMA_DIRECTION_FROM_DEVICE, 256);
-    ad->res_fis = NULL;
+    if (ad->res_fis) {
+        dma_memory_unmap(ad->hba->as, ad->res_fis, 256,
+                         DMA_DIRECTION_FROM_DEVICE, 256);
+        ad->res_fis = NULL;
+    }
 }
 
 static bool ahci_map_clb_address(AHCIDevice *ad)
@@ -677,9 +679,11 @@ static bool ahci_map_clb_address(AHCIDev
 
 static void ahci_unmap_clb_address(AHCIDevice *ad)
 {
-    dma_memory_unmap(ad->hba->as, ad->lst, 1024,
-                     DMA_DIRECTION_FROM_DEVICE, 1024);
-    ad->lst = NULL;
+    if (ad->lst) {
+        dma_memory_unmap(ad->hba->as, ad->lst, 1024,
+                         DMA_DIRECTION_FROM_DEVICE, 1024);
+        ad->lst = NULL;
+    }
 }
 
 static void ahci_write_fis_sdb(AHCIState *s, NCQTransferState *ncq_tfs)
