VirtualBox

Ignore:
Timestamp:
Dec 2, 2015 11:00:35 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
104477
Message:

VBoxPci/linux: Save and restore the AC bit properly when calling kernel APIs. Some restructuring of the module (not complete)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/VBoxPci/linux/VBoxPci-linux.c

    r58340 r58963  
    208208}
    209209
    210 int vboxPciOsDevRegisterWithIommu(PVBOXRAWPCIINS pIns)
    211 {
    212 #ifdef VBOX_WITH_IOMMU
    213     int rc;
    214     int status;
    215     struct pci_dev *pPciDev = pIns->pPciDev;
    216     PVBOXRAWPCIDRVVM pData = VBOX_DRV_VMDATA(pIns);
    217 
    218     if (!pData)
    219     {
    220         vbpci_printk(KERN_DEBUG, pPciDev,
    221                      "cannot attach to IOMMU, no VM data\n");
    222         return VERR_INVALID_PARAMETER;
    223     }
    224 
    225     if (!pData->pIommuDomain)
    226     {
    227         vbpci_printk(KERN_DEBUG, pIns->pPciDev,
    228                      "cannot attach to IOMMU, no domain\n");
    229         return VERR_NOT_FOUND;
    230     }
    231 
    232     status = iommu_attach_device(pData->pIommuDomain, &pPciDev->dev);
    233     if (status == 0)
    234     {
    235         vbpci_printk(KERN_DEBUG, pPciDev, "attached to IOMMU\n");
    236         pIns->fIommuUsed = true;
    237         rc = VINF_SUCCESS;
    238     }
    239     else
    240     {
    241         vbpci_printk(KERN_DEBUG, pPciDev,
    242                      "failed to attach to IOMMU, error %d\n", status);
    243         rc = VERR_INTERNAL_ERROR;
    244     }
    245 
    246     /* @todo: KVM checks IOMMU_CAP_CACHE_COHERENCY and sets
    247        flag IOMMU_CACHE later used when mapping physical
    248        addresses, which could improve performance. */
    249 
    250     return rc;
    251 #else
    252     return VERR_NOT_SUPPORTED;
    253 #endif
    254 }
    255 
    256 int vboxPciOsDevUnregisterWithIommu(PVBOXRAWPCIINS pIns)
     210static int vboxPciLinuxDevRegisterWithIommu(PVBOXRAWPCIINS pIns)
    257211{
    258212#ifdef VBOX_WITH_IOMMU
    … …  
    260214    struct pci_dev *pPciDev = pIns->pPciDev;
    261215    PVBOXRAWPCIDRVVM pData = VBOX_DRV_VMDATA(pIns);
    262 
    263     if (!pData)
    264     {
    265         vbpci_printk(KERN_DEBUG, pPciDev,
    266                      "cannot detach from IOMMU, no VM data\n");
    267         return VERR_INVALID_PARAMETER;
    268     }
    269 
    270     if (!pData->pIommuDomain)
    271     {
    272         vbpci_printk(KERN_DEBUG, pPciDev,
    273                      "cannot detach from IOMMU, no domain\n");
    274         return VERR_NOT_FOUND;
    275     }
    276 
    277     if (pIns->fIommuUsed)
    278     {
    279         iommu_detach_device(pData->pIommuDomain, &pIns->pPciDev->dev);
    280         vbpci_printk(KERN_DEBUG, pPciDev, "detached from IOMMU\n");
    281         pIns->fIommuUsed = false;
    282     }
    283 
     216    IPRT_LINUX_SAVE_EFL_AC();
     217
     218    if (RT_LIKELY(pData))
     219    {
     220        if (RT_LIKELY(pData->pIommuDomain))
     221        {
     222            /** @todo: KVM checks IOMMU_CAP_CACHE_COHERENCY and sets
     223             *  flag IOMMU_CACHE later used when mapping physical
     224             *  addresses, which could improve performance.
     225             */
     226            int rcLnx = iommu_attach_device(pData->pIommuDomain, &pPciDev->dev);
     227            if (!rcLnx)
     228            {
     229                vbpci_printk(KERN_DEBUG, pPciDev, "attached to IOMMU\n");
     230                pIns->fIommuUsed = true;
     231                rc = VINF_SUCCESS;
     232            }
     233            else
     234            {
     235                vbpci_printk(KERN_DEBUG, pPciDev, "failed to attach to IOMMU, error %d\n", rcLnx);
     236                rc = VERR_INTERNAL_ERROR;
     237            }
     238        }
     239        else
     240        {
     241           vbpci_printk(KERN_DEBUG, pIns->pPciDev, "cannot attach to IOMMU, no domain\n");
     242            rc = VERR_NOT_FOUND;
     243        }
     244    }
     245    else
     246    {
     247        vbpci_printk(KERN_DEBUG, pPciDev, "cannot attach to IOMMU, no VM data\n");
     248        rc = VERR_INVALID_PARAMETER;
     249    }
     250
     251    IPRT_LINUX_RESTORE_EFL_AC();
    284252    return rc;
    285253#else
    … …  
    288256}
    289257
    290 int vboxPciOsDevReset(PVBOXRAWPCIINS pIns)
    291 {
     258static int vboxPciLinuxDevUnregisterWithIommu(PVBOXRAWPCIINS pIns)
     259{
     260#ifdef VBOX_WITH_IOMMU
    292261    int rc = VINF_SUCCESS;
    293 
    294     if (pIns->pPciDev)
     262    struct pci_dev *pPciDev = pIns->pPciDev;
     263    PVBOXRAWPCIDRVVM pData = VBOX_DRV_VMDATA(pIns);
     264    IPRT_LINUX_SAVE_EFL_AC();
     265
     266    if (RT_LIKELY(pData))
     267    {
     268        if (RT_LIKELY(pData->pIommuDomain))
     269        {
     270            if (pIns->fIommuUsed)
     271            {
     272                iommu_detach_device(pData->pIommuDomain, &pIns->pPciDev->dev);
     273                vbpci_printk(KERN_DEBUG, pPciDev, "detached from IOMMU\n");
     274                pIns->fIommuUsed = false;
     275            }
     276        }
     277        else
     278        {
     279            vbpci_printk(KERN_DEBUG, pPciDev,
     280                         "cannot detach from IOMMU, no domain\n");
     281            rc = VERR_NOT_FOUND;
     282        }
     283    }
     284    else
     285    {
     286        vbpci_printk(KERN_DEBUG, pPciDev,
     287                     "cannot detach from IOMMU, no VM data\n");
     288        rc = VERR_INVALID_PARAMETER;
     289    }
     290
     291    IPRT_LINUX_RESTORE_EFL_AC();
     292    return rc;
     293#else
     294    return VERR_NOT_SUPPORTED;
     295#endif
     296}
     297
     298static int vboxPciLinuxDevReset(PVBOXRAWPCIINS pIns)
     299{
     300    int rc = VINF_SUCCESS;
     301    IPRT_LINUX_SAVE_EFL_AC();
     302
     303    if (RT_LIKELY(pIns->pPciDev))
    295304    {
    296305#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
    … …  
    305314#endif
    306315    }
    307 
     316    else
     317        rc = VERR_INVALID_PARAMETER;
     318
     319    IPRT_LINUX_RESTORE_EFL_AC();
    308320    return rc;
    309321}
    … …  
    353365}
    354366
    355 #if 0
    356 static int vboxPciFileRead(struct file* file, unsigned long long offset, unsigned char* data, unsigned int size)
    357 {
    358     int ret;
    359     mm_segment_t fs_save;
    360 
    361     fs_save = get_fs();
    362     set_fs(get_ds());
    363     ret = vfs_read(file, data, size, &offset);
    364     set_fs(fs_save);
    365 
    366     return ret;
    367 }
    368 #endif
    369 
    370 int vboxPciOsDevDetachHostDriver(PVBOXRAWPCIINS pIns)
     367static int vboxPciLinuxDevDetachHostDriver(PVBOXRAWPCIINS pIns)
    371368{
    372369    struct pci_dev *pPciDev = NULL;
    … …  
    525522}
    526523
    527 int vboxPciOsDevReattachHostDriver(PVBOXRAWPCIINS pIns)
     524static int vboxPciLinuxDevReattachHostDriver(PVBOXRAWPCIINS pIns)
    528525{
    529526    struct pci_dev *pPciDev = pIns->pPciDev;
    … …  
    617614}
    618615
    619 int vboxPciOsDevInit(PVBOXRAWPCIINS pIns, uint32_t fFlags)
     616DECLHIDDEN(int) vboxPciOsDevInit(PVBOXRAWPCIINS pIns, uint32_t fFlags)
    620617{
    621618    struct pci_dev *pPciDev = NULL;
    622     int rc;
     619    int rc = VINF_SUCCESS;
     620    IPRT_LINUX_SAVE_EFL_AC();
    623621
    624622    if (fFlags & PCIRAWDRIVERRFLAG_DETACH_HOST_DRIVER)
    625623    {
    626         rc = vboxPciOsDevDetachHostDriver(pIns);
     624        rc = vboxPciLinuxDevDetachHostDriver(pIns);
    627625        if (RT_FAILURE(rc))
    628626        {
    629627            printk(KERN_DEBUG "Cannot detach host driver for device %x: %d\n",
    630628                   pIns->HostPciAddress, rc);
    631             return VERR_ACCESS_DENIED;
    632         }
    633     }
    634 
    635 
    636     pPciDev = PCI_DEV_GET_SLOT((pIns->HostPciAddress) >> 8,
    637                                (pIns->HostPciAddress) & 0xff);
    638 
    639     if (!pPciDev)
    640         return 0;
    641 
    642     pIns->pPciDev = pPciDev;
     629        }
     630    }
     631
     632    if (RT_SUCCESS(rc))
     633    {
     634        pPciDev = PCI_DEV_GET_SLOT((pIns->HostPciAddress) >> 8,
     635                                   (pIns->HostPciAddress) & 0xff);
     636
     637        if (RT_LIKELY(pPciDev))
     638        {
     639            int rcLnx = pci_enable_device(pPciDev);
     640
     641            if (!rcLnx)
     642            {
     643                pIns->pPciDev = pPciDev;
     644                vbpci_printk(KERN_DEBUG, pPciDev, "%s\n", __func__);
     645
     646#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 1)
     647                if (pci_enable_msi(pPciDev) == 0)
     648                    pIns->fMsiUsed = true;
     649#endif
     650
     651                /** @todo
     652                 * pci_enable_msix(pPciDev, entries, nvec)
     653                 *
     654                 * In fact, if device uses interrupts, and cannot be forced to use MSI or MSI-X
     655                 * we have to refuse using it, as we cannot work with shared PCI interrupts (unless we're lucky
     656                 * to grab unshared PCI interrupt).
     657                 */
     658            }
     659            else
     660                rc = RTErrConvertFromErrno(RT_ABS(rcLnx));
     661        }
     662        else
     663            rc = VERR_NOT_FOUND;
     664    }
     665
     666    IPRT_LINUX_RESTORE_EFL_AC();
     667    return rc;
     668}
     669
     670DECLHIDDEN(int) vboxPciOsDevDeinit(PVBOXRAWPCIINS pIns, uint32_t fFlags)
     671{
     672    int rc = VINF_SUCCESS;
     673    struct pci_dev *pPciDev = pIns->pPciDev;
     674    IPRT_LINUX_SAVE_EFL_AC();
     675
    643676    vbpci_printk(KERN_DEBUG, pPciDev, "%s\n", __func__);
    644677
    645     rc = pci_enable_device(pPciDev);
    646 
    647 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 1)
    648     if (pci_enable_msi(pPciDev) == 0)
    649     {
    650         pIns->fMsiUsed = true;
    651     }
    652 #endif
    653 
    654     // pci_enable_msix(pPciDev, entries, nvec)
    655 
    656     /* In fact, if device uses interrupts, and cannot be forced to use MSI or MSI-X
    657        we have to refuse using it, as we cannot work with shared PCI interrupts (unless we're lucky
    658        to grab unshared PCI interrupt). */
    659 
    660     return VINF_SUCCESS;
    661 }
    662 
    663 int  vboxPciOsDevDeinit(PVBOXRAWPCIINS pIns, uint32_t fFlags)
    664 {
    665     struct pci_dev *pPciDev = pIns->pPciDev;
    666 
    667     vbpci_printk(KERN_DEBUG, pPciDev, "%s\n", __func__);
    668 
    669     if (pPciDev)
     678    if (RT_LIKELY(pPciDev))
    670679    {
    671680        int iRegion;
    … …  
    680689        }
    681690
    682         vboxPciOsDevUnregisterWithIommu(pIns);
     691        vboxPciLinuxDevUnregisterWithIommu(pIns);
    683692
    684693#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 1)
    … …  
    688697        // pci_disable_msix(pPciDev);
    689698        pci_disable_device(pPciDev);
    690         vboxPciOsDevReattachHostDriver(pIns);
     699        vboxPciLinuxDevReattachHostDriver(pIns);
    691700
    692701        PCI_DEV_PUT(pPciDev);
    693702        pIns->pPciDev = NULL;
    694703    }
    695 
    696     return 0;
    697 }
    698 
    699 int  vboxPciOsDevDestroy(PVBOXRAWPCIINS pIns)
    700 {
    701     return 0;
    702 }
    703 
    704 int  vboxPciOsDevGetRegionInfo(PVBOXRAWPCIINS pIns,
    705                                int32_t        iRegion,
    706                                RTHCPHYS       *pRegionStart,
    707                                uint64_t       *pu64RegionSize,
    708                                bool           *pfPresent,
    709                                uint32_t       *pfFlags)
    710 {
    711     int flags;
     704    else
     705        rc = VERR_INVALID_PARAMETER;
     706
     707    IPRT_LINUX_RESTORE_EFL_AC();
     708    return rc;
     709}
     710
     711DECLHIDDEN(int) vboxPciOsDevDestroy(PVBOXRAWPCIINS pIns)
     712{
     713    return VINF_SUCCESS;
     714}
     715
     716DECLHIDDEN(int) vboxPciOsDevGetRegionInfo(PVBOXRAWPCIINS pIns,
     717                                          int32_t        iRegion,
     718                                          RTHCPHYS       *pRegionStart,
     719                                          uint64_t       *pu64RegionSize,
     720                                          bool           *pfPresent,
     721                                          uint32_t       *pfFlags)
     722{
     723    int rc = VINF_SUCCESS;
    712724    struct pci_dev *pPciDev = pIns->pPciDev;
    713     uint32_t fResFlags;
    714 
    715     if (!pPciDev)
     725    IPRT_LINUX_SAVE_EFL_AC();
     726
     727    if (RT_LIKELY(pPciDev))
     728    {
     729        int fFlags = pci_resource_flags(pPciDev, iRegion);
     730
     731        if (   ((fFlags & (IORESOURCE_MEM | IORESOURCE_IO)) == 0)
     732            || ((fFlags & IORESOURCE_DISABLED) != 0))
     733        {
     734            *pfPresent = false;
     735            rc = VERR_INVALID_PARAMETER;
     736        }
     737        else
     738        {
     739            uint32_t fResFlags = 0;
     740            *pfPresent = true;
     741
     742            if (fFlags & IORESOURCE_MEM)
     743                fResFlags |= PCIRAW_ADDRESS_SPACE_MEM;
     744
     745            if (fFlags & IORESOURCE_IO)
     746                fResFlags |= PCIRAW_ADDRESS_SPACE_IO;
     747
     748#ifdef IORESOURCE_MEM_64
     749            if (fFlags & IORESOURCE_MEM_64)
     750                fResFlags |= PCIRAW_ADDRESS_SPACE_BAR64;
     751#endif
     752
     753            if (fFlags & IORESOURCE_PREFETCH)
     754                fResFlags |=  PCIRAW_ADDRESS_SPACE_MEM_PREFETCH;
     755
     756            *pfFlags        = fResFlags;
     757            *pRegionStart   = pci_resource_start(pPciDev, iRegion);
     758            *pu64RegionSize = pci_resource_len  (pPciDev, iRegion);
     759
     760            vbpci_printk(KERN_DEBUG, pPciDev,
     761                         "region %d: %s %llx+%lld\n",
     762                         iRegion, (fFlags & IORESOURCE_MEM) ? "mmio" : "pio",
     763                         *pRegionStart, *pu64RegionSize);
     764        }
     765    }
     766    else
    716767    {
    717768        *pfPresent = false;
    718         return 0;
    719     }
    720 
    721     flags = pci_resource_flags(pPciDev, iRegion);
    722     if (((flags & (IORESOURCE_MEM | IORESOURCE_IO)) == 0)
    723         ||
    724         ((flags & IORESOURCE_DISABLED) != 0))
    725     {
    726         *pfPresent = false;
    727         return 0;
    728     }
    729 
    730     *pfPresent = true;
    731     fResFlags = 0;
    732 
    733     if (flags & IORESOURCE_MEM)
    734         fResFlags |= PCIRAW_ADDRESS_SPACE_MEM;
    735 
    736     if (flags & IORESOURCE_IO)
    737         fResFlags |= PCIRAW_ADDRESS_SPACE_IO;
    738 
    739 #ifdef IORESOURCE_MEM_64
    740     if (flags & IORESOURCE_MEM_64)
    741         fResFlags |= PCIRAW_ADDRESS_SPACE_BAR64;
    742 #endif
    743 
    744     if (flags & IORESOURCE_PREFETCH)
    745         fResFlags |=  PCIRAW_ADDRESS_SPACE_MEM_PREFETCH;
    746 
    747     *pfFlags        = fResFlags;
    748     *pRegionStart   = pci_resource_start(pPciDev, iRegion);
    749     *pu64RegionSize = pci_resource_len  (pPciDev, iRegion);
    750 
    751     vbpci_printk(KERN_DEBUG, pPciDev,
    752                  "region %d: %s %llx+%lld\n",
    753                  iRegion, (flags & IORESOURCE_MEM) ? "mmio" : "pio",
    754                  *pRegionStart, *pu64RegionSize);
    755 
    756     return 0;
    757 }
    758 
    759 int  vboxPciOsDevMapRegion(PVBOXRAWPCIINS pIns,
    760                            int32_t        iRegion,
    761                            RTHCPHYS       RegionStart,
    762                            uint64_t       u64RegionSize,
    763                            uint32_t       fFlags,
    764                            RTR0PTR        *pRegionBase)
    765 {
     769        rc = VERR_INVALID_PARAMETER;
     770    }
     771
     772    IPRT_LINUX_RESTORE_EFL_AC();
     773    return rc;
     774}
     775
     776DECLHIDDEN(int) vboxPciOsDevMapRegion(PVBOXRAWPCIINS pIns,
     777                                      int32_t        iRegion,
     778                                      RTHCPHYS       RegionStart,
     779                                      uint64_t       u64RegionSize,
     780                                      uint32_t       fFlags,
     781                                      RTR0PTR        *pRegionBase)
     782{
     783    int rc = VINF_SUCCESS;
    766784    struct pci_dev  *pPciDev = pIns->pPciDev;
    767     RTR0PTR          result = 0;
    768     int              error;
     785    IPRT_LINUX_SAVE_EFL_AC();
     786
     787    if (!pPciDev || iRegion < 0 || iRegion > 0)
     788    {
     789        if (pPciDev)
     790            vbpci_printk(KERN_DEBUG, pPciDev, "invalid region %d\n", iRegion);
     791
     792        IPRT_LINUX_RESTORE_EFL_AC();
     793        return VERR_INVALID_PARAMETER;
     794    }
    769795
    770796    vbpci_printk(KERN_DEBUG, pPciDev, "reg=%d start=%llx size=%lld\n",
    771797                 iRegion, RegionStart, u64RegionSize);
    772798
    773     if (!pPciDev)
     799    if (   (pci_resource_flags(pPciDev, iRegion) & IORESOURCE_IO)
     800        || RegionStart != pci_resource_start(pPciDev, iRegion)
     801        || u64RegionSize != pci_resource_len(pPciDev, iRegion))
     802    {
     803        IPRT_LINUX_RESTORE_EFL_AC();
    774804        return VERR_INVALID_PARAMETER;
    775 
    776     if (iRegion < 0 || iRegion > 6)
    777     {
    778         vbpci_printk(KERN_DEBUG, pPciDev, "invalid region %d\n", iRegion);
    779         return VERR_INVALID_PARAMETER;
    780     }
    781 
    782     if (pci_resource_flags(pPciDev, iRegion) & IORESOURCE_IO)
    783         return VERR_INVALID_PARAMETER;
    784 
    785     if (RegionStart != pci_resource_start(pPciDev, iRegion))
    786         return VERR_INVALID_PARAMETER;
    787 
    788     if (u64RegionSize != pci_resource_len(pPciDev, iRegion))
    789         return VERR_INVALID_PARAMETER;
     805    }
    790806
    791807    /*
    … …  
    793809     * only request and map resources once.
    794810     */
    795     if (pIns->aRegionR0Mapping[iRegion])
    796     {
     811    if (!pIns->aRegionR0Mapping[iRegion])
     812    {
     813        int     rcLnx;
    797814        *pRegionBase = pIns->aRegionR0Mapping[iRegion];
    798         return VINF_SUCCESS;
    799     }
    800 
    801 
    802     error = pci_request_region(pPciDev, iRegion, "vboxpci");
    803     if (error)
    804         return VERR_RESOURCE_BUSY;
    805 
    806     /* For now no caching, try to optimize later. */
    807     result = ioremap_nocache(pci_resource_start(pPciDev, iRegion),
    808                              pci_resource_len(pPciDev, iRegion));
    809 
    810     if (!result)
    811     {
    812         vbpci_printk(KERN_DEBUG, pPciDev, "ioremap_nocache() failed\n");
    813         pci_release_region(pPciDev, iRegion);
    814         return VERR_MAP_FAILED;
    815     }
    816 
    817     *pRegionBase = pIns->aRegionR0Mapping[iRegion] = result;
    818 
    819     return VINF_SUCCESS;
    820 }
    821 
    822 int  vboxPciOsDevUnmapRegion(PVBOXRAWPCIINS pIns,
    823                              int32_t        iRegion,
    824                              RTHCPHYS       RegionStart,
    825                              uint64_t       u64RegionSize,
    826                              RTR0PTR        RegionBase)
     815
     816        rcLnx = pci_request_region(pPciDev, iRegion, "vboxpci");
     817        if (!rcLnx)
     818        {
     819            /* For now no caching, try to optimize later. */
     820            RTR0PTR R0PtrMapping = ioremap_nocache(pci_resource_start(pPciDev, iRegion),
     821                                                   pci_resource_len(pPciDev, iRegion));
     822
     823            if (R0PtrMapping != NIL_RTR0PTR)
     824                pIns->aRegionR0Mapping[iRegion] = R0PtrMapping;
     825            else
     826            {
     827                vbpci_printk(KERN_DEBUG, pPciDev, "ioremap_nocache() failed\n");
     828                pci_release_region(pPciDev, iRegion);
     829                rc = VERR_MAP_FAILED;
     830            }
     831        }
     832        else
     833            rc = VERR_RESOURCE_BUSY;
     834    }
     835
     836    if (RT_SUCCESS(rc))
     837        *pRegionBase = pIns->aRegionR0Mapping[iRegion];
     838
     839    IPRT_LINUX_RESTORE_EFL_AC();
     840    return rc;
     841}
     842
     843DECLHIDDEN(int) vboxPciOsDevUnmapRegion(PVBOXRAWPCIINS pIns,
     844                                        int32_t        iRegion,
     845                                        RTHCPHYS       RegionStart,
     846                                        uint64_t       u64RegionSize,
     847                                        RTR0PTR        RegionBase)
    827848{
    828849    /* XXX: Current code never calls unmap. */
    … …  
    830851}
    831852
    832 int vboxPciOsDevPciCfgWrite(PVBOXRAWPCIINS pIns, uint32_t Register, PCIRAWMEMLOC *pValue)
     853DECLHIDDEN(int) vboxPciOsDevPciCfgWrite(PVBOXRAWPCIINS pIns, uint32_t Register, PCIRAWMEMLOC *pValue)
    833854{
    834855    struct pci_dev *pPciDev = pIns->pPciDev;
    835 
    836     if (!pPciDev)
    837         return VINF_SUCCESS;
    838 
    839     switch (pValue->cb)
    840     {
    841         case 1:
    842             pci_write_config_byte(pPciDev,  Register, pValue->u.u8);
    843             break;
    844         case 2:
    845             pci_write_config_word(pPciDev,  Register, pValue->u.u16);
    846             break;
    847         case 4:
    848             pci_write_config_dword(pPciDev, Register, pValue->u.u32);
    849             break;
    850     }
    851 
    852     return VINF_SUCCESS;
    853 }
    854 
    855 int  vboxPciOsDevPciCfgRead (PVBOXRAWPCIINS pIns, uint32_t Register, PCIRAWMEMLOC *pValue)
     856    int rc = VINF_SUCCESS;
     857    IPRT_LINUX_SAVE_EFL_AC();
     858
     859    if (RT_LIKELY(pPciDev))
     860    {
     861        switch (pValue->cb)
     862        {
     863            case 1:
     864                pci_write_config_byte(pPciDev,  Register, pValue->u.u8);
     865                break;
     866            case 2:
     867                pci_write_config_word(pPciDev,  Register, pValue->u.u16);
     868                break;
     869            case 4:
     870                pci_write_config_dword(pPciDev, Register, pValue->u.u32);
     871                break;
     872        }
     873    }
     874    else
     875        rc = VERR_INVALID_PARAMETER;
     876
     877    IPRT_LINUX_RESTORE_EFL_AC();
     878    return rc;
     879}
     880
     881DECLHIDDEN(int) vboxPciOsDevPciCfgRead(PVBOXRAWPCIINS pIns, uint32_t Register, PCIRAWMEMLOC *pValue)
    856882{
    857883    struct pci_dev *pPciDev = pIns->pPciDev;
    858 
    859     if (!pPciDev)
    860         return VINF_SUCCESS;
    861 
    862     switch (pValue->cb)
    863     {
    864         case 1:
    865             pci_read_config_byte(pPciDev, Register, &pValue->u.u8);
    866             break;
    867         case 2:
    868             pci_read_config_word(pPciDev, Register, &pValue->u.u16);
    869             break;
    870         case 4:
    871             pci_read_config_dword(pPciDev, Register, &pValue->u.u32);
    872             break;
    873     }
    874 
    875     return VINF_SUCCESS;
     884    int rc = VINF_SUCCESS;
     885
     886    if (RT_LIKELY(pPciDev))
     887    {
     888        IPRT_LINUX_SAVE_EFL_AC();
     889
     890        switch (pValue->cb)
     891        {
     892            case 1:
     893                pci_read_config_byte(pPciDev, Register, &pValue->u.u8);
     894                break;
     895            case 2:
     896                pci_read_config_word(pPciDev, Register, &pValue->u.u16);
     897                break;
     898            case 4:
     899                pci_read_config_dword(pPciDev, Register, &pValue->u.u32);
     900                break;
     901        }
     902
     903        IPRT_LINUX_RESTORE_EFL_AC();
     904    }
     905    else
     906        rc = VERR_INVALID_PARAMETER;
     907
     908    return rc;
    876909}
    877910
    … …  
    904937}
    905938
    906 int vboxPciOsDevRegisterIrqHandler(PVBOXRAWPCIINS pIns, PFNRAWPCIISR pfnHandler, void* pIrqContext, int32_t *piHostIrq)
     939DECLHIDDEN(int) vboxPciOsDevRegisterIrqHandler(PVBOXRAWPCIINS pIns, PFNRAWPCIISR pfnHandler, void* pIrqContext, int32_t *piHostIrq)
    907940{
    908941    int rc;
    909942    int32_t iIrq = pIns->pPciDev->irq;
     943    IPRT_LINUX_SAVE_EFL_AC();
    910944
    911945    if (iIrq == 0)
    912946    {
    913947        vbpci_printk(KERN_NOTICE, pIns->pPciDev, "no irq assigned\n");
     948        IPRT_LINUX_RESTORE_EFL_AC();
    914949        return VERR_INVALID_PARAMETER;
    915950    }
    … …  
    941976        vbpci_printk(KERN_DEBUG, pIns->pPciDev,
    942977                     "could not request irq %d, error %d\n", iIrq, rc);
     978        IPRT_LINUX_RESTORE_EFL_AC();
    943979        return VERR_RESOURCE_BUSY;
    944980    }
    … …  
    946982    vbpci_printk(KERN_DEBUG, pIns->pPciDev, "got irq %d\n", iIrq);
    947983    *piHostIrq = iIrq;
     984
     985    IPRT_LINUX_RESTORE_EFL_AC();
    948986    return VINF_SUCCESS;
    949987}
    950988
    951 int vboxPciOsDevUnregisterIrqHandler(PVBOXRAWPCIINS pIns, int32_t iHostIrq)
    952 {
     989DECLHIDDEN(int) vboxPciOsDevUnregisterIrqHandler(PVBOXRAWPCIINS pIns, int32_t iHostIrq)
     990{
     991    IPRT_LINUX_SAVE_EFL_AC();
     992
    953993    vbpci_printk(KERN_DEBUG, pIns->pPciDev, "freeing irq %d\n", iHostIrq);
    954994    free_irq(iHostIrq, pIns);
     995
     996    IPRT_LINUX_RESTORE_EFL_AC();
    955997    return VINF_SUCCESS;
    956998}
    957999
    958 int vboxPciOsDevPowerStateChange(PVBOXRAWPCIINS pIns, PCIRAWPOWERSTATE  aState)
     1000DECLHIDDEN(int) vboxPciOsDevPowerStateChange(PVBOXRAWPCIINS pIns, PCIRAWPOWERSTATE  aState)
    9591001{
    9601002    int rc;
    … …  
    9651007            vbpci_printk(KERN_DEBUG, pIns->pPciDev, "PCIRAW_POWER_ON\n");
    9661008            /* Reset device, just in case. */
    967             vboxPciOsDevReset(pIns);
     1009            vboxPciLinuxDevReset(pIns);
    9681010            /* register us with IOMMU */
    969             rc = vboxPciOsDevRegisterWithIommu(pIns);
     1011            rc = vboxPciLinuxDevRegisterWithIommu(pIns);
    9701012            break;
    9711013        case PCIRAW_POWER_RESET:
    9721014            vbpci_printk(KERN_DEBUG, pIns->pPciDev, "PCIRAW_POWER_RESET\n");
    973             rc = vboxPciOsDevReset(pIns);
     1015            rc = vboxPciLinuxDevReset(pIns);
    9741016            break;
    9751017        case PCIRAW_POWER_OFF:
    9761018            vbpci_printk(KERN_DEBUG, pIns->pPciDev, "PCIRAW_POWER_OFF\n");
    9771019            /* unregister us from IOMMU */
    978             rc = vboxPciOsDevUnregisterWithIommu(pIns);
     1020            rc = vboxPciLinuxDevUnregisterWithIommu(pIns);
    9791021            break;
    9801022        case PCIRAW_POWER_SUSPEND:
    … …  
    10011043#ifdef VBOX_WITH_IOMMU
    10021044/** Callback for FNRAWPCICONTIGPHYSMEMINFO. */
    1003 static int vboxPciOsContigMemInfo(PRAWPCIPERVM pVmCtx, RTHCPHYS HostStart, RTGCPHYS GuestStart, uint64_t cMemSize, PCIRAWMEMINFOACTION Action)
     1045static DECLCALLBACK(int) vboxPciOsContigMemInfo(PRAWPCIPERVM pVmCtx, RTHCPHYS HostStart, RTGCPHYS GuestStart,
     1046                                                uint64_t cMemSize, PCIRAWMEMINFOACTION Action)
    10041047{
    10051048    struct iommu_domain* domain = ((PVBOXRAWPCIDRVVM)(pVmCtx->pDriverData))->pIommuDomain;
    10061049    int rc = VINF_SUCCESS;
     1050    IPRT_LINUX_SAVE_EFL_AC();
    10071051
    10081052    switch (Action)
    … …  
    10431087    }
    10441088
     1089    IPRT_LINUX_RESTORE_EFL_AC();
    10451090    return rc;
    10461091}
    10471092#endif
    10481093
    1049 int  vboxPciOsInitVm(PVBOXRAWPCIDRVVM pThis, PVM pVM, PRAWPCIPERVM pVmData)
    1050 {
     1094DECLHIDDEN(int) vboxPciOsInitVm(PVBOXRAWPCIDRVVM pThis, PVM pVM, PRAWPCIPERVM pVmData)
     1095{
     1096    int rc = VINF_SUCCESS;
     1097
    10511098#ifdef VBOX_WITH_IOMMU
     1099    IPRT_LINUX_SAVE_EFL_AC();
     1100
    10521101    if (IOMMU_PRESENT())
    10531102    {
    … …  
    10561105        {
    10571106            vbpci_printk(KERN_DEBUG, NULL, "cannot allocate IOMMU domain\n");
    1058             return VERR_NO_MEMORY;
    1059         }
    1060 
    1061         pVmData->pfnContigMemInfo = vboxPciOsContigMemInfo;
    1062 
    1063         vbpci_printk(KERN_DEBUG, NULL, "created IOMMU domain %p\n",
    1064                      pThis->pIommuDomain);
    1065     }
    1066 #endif
    1067     return VINF_SUCCESS;
    1068 }
    1069 
    1070 void vboxPciOsDeinitVm(PVBOXRAWPCIDRVVM pThis, PVM pVM)
     1107            rc = VERR_NO_MEMORY;
     1108        }
     1109        else
     1110        {
     1111            pVmData->pfnContigMemInfo = vboxPciOsContigMemInfo;
     1112
     1113            vbpci_printk(KERN_DEBUG, NULL, "created IOMMU domain %p\n",
     1114                         pThis->pIommuDomain);
     1115        }
     1116    }
     1117
     1118    IPRT_LINUX_RESTORE_EFL_AC();
     1119#endif
     1120    return rc;
     1121}
     1122
     1123DECLHIDDEN(void) vboxPciOsDeinitVm(PVBOXRAWPCIDRVVM pThis, PVM pVM)
    10711124{
    10721125#ifdef VBOX_WITH_IOMMU
     1126    IPRT_LINUX_SAVE_EFL_AC();
     1127
    10731128    if (pThis->pIommuDomain)
    10741129    {
    … …  
    10781133        pThis->pIommuDomain = NULL;
    10791134    }
    1080 #endif
    1081 }
     1135
     1136    IPRT_LINUX_RESTORE_EFL_AC();
     1137#endif
     1138}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette