Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 447 insertions, 0 deletions

diff --git a/src/VBox/Runtime/common/misc/sg.cpp b/src/VBox/Runtime/common/misc/sg.cpp
new file mode 100644
index 00000000..d1fb749f
--- /dev/null
+++ b/src/VBox/Runtime/common/misc/sg.cpp
@@ -0,0 +1,447 @@
+/* $Id: sg.cpp $ */
+/** @file
+ * IPRT - S/G buffer handling.
+ */
+
+/*
+ * Copyright (C) 2010-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/sg.h>
+#include <iprt/string.h>
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+
+
+static void *rtSgBufGet(PRTSGBUF pSgBuf, size_t *pcbData)
+{
+    size_t cbData;
+    void *pvBuf;
+
+    /* Check that the S/G buffer has memory left. */
+    if (RT_UNLIKELY(   pSgBuf->idxSeg == pSgBuf->cSegs
+                    && !pSgBuf->cbSegLeft))
+    {
+        *pcbData = 0;
+        return NULL;
+    }
+
+#ifndef RDESKTOP
+    AssertMsg(      pSgBuf->cbSegLeft <= 128 * _1M
+              &&    (uintptr_t)pSgBuf->pvSegCur                     >= (uintptr_t)pSgBuf->paSegs[pSgBuf->idxSeg].pvSeg
+              &&    (uintptr_t)pSgBuf->pvSegCur + pSgBuf->cbSegLeft <= (uintptr_t)pSgBuf->paSegs[pSgBuf->idxSeg].pvSeg + pSgBuf->paSegs[pSgBuf->idxSeg].cbSeg,
+              ("pSgBuf->idxSeg=%d pSgBuf->cSegs=%d pSgBuf->pvSegCur=%p pSgBuf->cbSegLeft=%zd pSgBuf->paSegs[%d].pvSeg=%p pSgBuf->paSegs[%d].cbSeg=%zd\n",
+               pSgBuf->idxSeg, pSgBuf->cSegs, pSgBuf->pvSegCur, pSgBuf->cbSegLeft, pSgBuf->idxSeg, pSgBuf->paSegs[pSgBuf->idxSeg].pvSeg, pSgBuf->idxSeg,
+               pSgBuf->paSegs[pSgBuf->idxSeg].cbSeg));
+#endif
+
+    cbData = RT_MIN(*pcbData, pSgBuf->cbSegLeft);
+    pvBuf  = pSgBuf->pvSegCur;
+    pSgBuf->cbSegLeft -= cbData;
+
+    /* Advance to the next segment if required. */
+    if (!pSgBuf->cbSegLeft)
+    {
+        pSgBuf->idxSeg++;
+
+        if (pSgBuf->idxSeg < pSgBuf->cSegs)
+        {
+            pSgBuf->pvSegCur  = pSgBuf->paSegs[pSgBuf->idxSeg].pvSeg;
+            pSgBuf->cbSegLeft = pSgBuf->paSegs[pSgBuf->idxSeg].cbSeg;
+        }
+
+        *pcbData = cbData;
+    }
+    else
+        pSgBuf->pvSegCur = (uint8_t *)pSgBuf->pvSegCur + cbData;
+
+    return pvBuf;
+}
+
+
+RTDECL(void) RTSgBufInit(PRTSGBUF pSgBuf, PCRTSGSEG paSegs, size_t cSegs)
+{
+    AssertPtr(pSgBuf);
+    Assert(   (cSegs > 0 && VALID_PTR(paSegs))
+           || (!cSegs && !paSegs));
+    Assert(cSegs < (~(unsigned)0 >> 1));
+
+    pSgBuf->paSegs    = paSegs;
+    pSgBuf->cSegs     = (unsigned)cSegs;
+    pSgBuf->idxSeg    = 0;
+    if (cSegs && paSegs)
+    {
+        pSgBuf->pvSegCur  = paSegs[0].pvSeg;
+        pSgBuf->cbSegLeft = paSegs[0].cbSeg;
+    }
+    else
+    {
+        pSgBuf->pvSegCur  = NULL;
+        pSgBuf->cbSegLeft = 0;
+    }
+}
+
+
+RTDECL(void) RTSgBufReset(PRTSGBUF pSgBuf)
+{
+    AssertPtrReturnVoid(pSgBuf);
+
+    pSgBuf->idxSeg = 0;
+    if (pSgBuf->cSegs)
+    {
+        pSgBuf->pvSegCur  = pSgBuf->paSegs[0].pvSeg;
+        pSgBuf->cbSegLeft = pSgBuf->paSegs[0].cbSeg;
+    }
+    else
+    {
+        pSgBuf->pvSegCur  = NULL;
+        pSgBuf->cbSegLeft = 0;
+    }
+}
+
+
+RTDECL(void) RTSgBufClone(PRTSGBUF pSgBufTo, PCRTSGBUF pSgBufFrom)
+{
+    AssertPtr(pSgBufTo);
+    AssertPtr(pSgBufFrom);
+
+    pSgBufTo->paSegs    = pSgBufFrom->paSegs;
+    pSgBufTo->cSegs     = pSgBufFrom->cSegs;
+    pSgBufTo->idxSeg    = pSgBufFrom->idxSeg;
+    pSgBufTo->pvSegCur  = pSgBufFrom->pvSegCur;
+    pSgBufTo->cbSegLeft = pSgBufFrom->cbSegLeft;
+}
+
+
+RTDECL(void *) RTSgBufGetNextSegment(PRTSGBUF pSgBuf, size_t *pcbSeg)
+{
+    AssertPtrReturn(pSgBuf, NULL);
+    AssertPtrReturn(pcbSeg, NULL);
+
+    if (!*pcbSeg)
+        *pcbSeg = pSgBuf->cbSegLeft;
+
+    return rtSgBufGet(pSgBuf, pcbSeg);
+}
+
+
+RTDECL(size_t) RTSgBufCopy(PRTSGBUF pSgBufDst, PRTSGBUF pSgBufSrc, size_t cbCopy)
+{
+    AssertPtrReturn(pSgBufDst, 0);
+    AssertPtrReturn(pSgBufSrc, 0);
+
+    size_t cbLeft = cbCopy;
+    while (cbLeft)
+    {
+        size_t cbThisCopy = RT_MIN(RT_MIN(pSgBufDst->cbSegLeft, cbLeft), pSgBufSrc->cbSegLeft);
+        if (!cbThisCopy)
+            break;
+
+        size_t cbTmp = cbThisCopy;
+        void *pvBufDst = rtSgBufGet(pSgBufDst, &cbTmp);
+        Assert(cbTmp == cbThisCopy);
+        void *pvBufSrc = rtSgBufGet(pSgBufSrc, &cbTmp);
+        Assert(cbTmp == cbThisCopy);
+
+        memcpy(pvBufDst, pvBufSrc, cbThisCopy);
+
+        cbLeft -= cbThisCopy;
+    }
+
+    return cbCopy - cbLeft;
+}
+
+
+RTDECL(int) RTSgBufCmp(PCRTSGBUF pSgBuf1, PCRTSGBUF pSgBuf2, size_t cbCmp)
+{
+    AssertPtrReturn(pSgBuf1, 0);
+    AssertPtrReturn(pSgBuf2, 0);
+
+    /* Set up the temporary buffers */
+    RTSGBUF SgBuf1;
+    RTSgBufClone(&SgBuf1, pSgBuf1);
+    RTSGBUF SgBuf2;
+    RTSgBufClone(&SgBuf2, pSgBuf2);
+
+    size_t cbLeft = cbCmp;
+    while (cbLeft)
+    {
+        size_t cbThisCmp = RT_MIN(RT_MIN(SgBuf1.cbSegLeft, cbLeft), SgBuf2.cbSegLeft);
+        if (!cbThisCmp)
+            break;
+
+        size_t cbTmp = cbThisCmp;
+        void *pvBuf1 = rtSgBufGet(&SgBuf1, &cbTmp);
+        Assert(cbTmp == cbThisCmp);
+        void *pvBuf2 = rtSgBufGet(&SgBuf2, &cbTmp);
+        Assert(cbTmp == cbThisCmp);
+
+        int rc = memcmp(pvBuf1, pvBuf2, cbThisCmp);
+        if (rc)
+            return rc;
+
+        cbLeft -= cbThisCmp;
+    }
+
+    return 0;
+}
+
+
+RTDECL(int) RTSgBufCmpEx(PRTSGBUF pSgBuf1, PRTSGBUF pSgBuf2, size_t cbCmp, size_t *poffDiff, bool fAdvance)
+{
+    AssertPtrReturn(pSgBuf1, 0);
+    AssertPtrReturn(pSgBuf2, 0);
+
+    RTSGBUF SgBuf1Tmp;
+    RTSGBUF SgBuf2Tmp;
+    PRTSGBUF pSgBuf1Tmp;
+    PRTSGBUF pSgBuf2Tmp;
+
+    if (!fAdvance)
+    {
+        /* Set up the temporary buffers */
+        RTSgBufClone(&SgBuf1Tmp, pSgBuf1);
+        RTSgBufClone(&SgBuf2Tmp, pSgBuf2);
+        pSgBuf1Tmp = &SgBuf1Tmp;
+        pSgBuf2Tmp = &SgBuf2Tmp;
+    }
+    else
+    {
+        pSgBuf1Tmp = pSgBuf1;
+        pSgBuf2Tmp = pSgBuf2;
+    }
+
+    size_t cbLeft = cbCmp;
+    size_t off    = 0;
+    while (cbLeft)
+    {
+        size_t cbThisCmp = RT_MIN(RT_MIN(pSgBuf1Tmp->cbSegLeft, cbLeft), pSgBuf2Tmp->cbSegLeft);
+        if (!cbThisCmp)
+            break;
+
+        size_t cbTmp = cbThisCmp;
+        uint8_t *pbBuf1 = (uint8_t *)rtSgBufGet(pSgBuf1Tmp, &cbTmp);
+        Assert(cbTmp == cbThisCmp);
+        uint8_t *pbBuf2 = (uint8_t *)rtSgBufGet(pSgBuf2Tmp, &cbTmp);
+        Assert(cbTmp == cbThisCmp);
+
+        int iDiff = memcmp(pbBuf1, pbBuf2, cbThisCmp);
+        if (iDiff)
+        {
+            /* Locate the first byte that differs if the caller requested this. */
+            if (poffDiff)
+            {
+                while (   cbThisCmp-- > 0
+                       && *pbBuf1 == *pbBuf2)
+                {
+                    pbBuf1++;
+                    pbBuf2++;
+                    off++;
+                }
+
+                *poffDiff = off;
+            }
+            return iDiff;
+        }
+
+        cbLeft -= cbThisCmp;
+        off    += cbThisCmp;
+    }
+
+    return 0;
+}
+
+
+RTDECL(size_t) RTSgBufSet(PRTSGBUF pSgBuf, uint8_t ubFill, size_t cbSet)
+{
+    AssertPtrReturn(pSgBuf, 0);
+
+    size_t cbLeft = cbSet;
+
+    while (cbLeft)
+    {
+        size_t cbThisSet = cbLeft;
+        void *pvBuf = rtSgBufGet(pSgBuf, &cbThisSet);
+
+        if (!cbThisSet)
+            break;
+
+        memset(pvBuf, ubFill, cbThisSet);
+
+        cbLeft -= cbThisSet;
+    }
+
+    return cbSet - cbLeft;
+}
+
+
+RTDECL(size_t) RTSgBufCopyToBuf(PRTSGBUF pSgBuf, void *pvBuf, size_t cbCopy)
+{
+    AssertPtrReturn(pSgBuf, 0);
+    AssertPtrReturn(pvBuf, 0);
+
+    size_t cbLeft = cbCopy;
+
+    while (cbLeft)
+    {
+        size_t cbThisCopy = cbLeft;
+        void *pvSrc = rtSgBufGet(pSgBuf, &cbThisCopy);
+
+        if (!cbThisCopy)
+            break;
+
+        memcpy(pvBuf, pvSrc, cbThisCopy);
+
+        cbLeft -= cbThisCopy;
+        pvBuf = (void *)((uintptr_t)pvBuf + cbThisCopy);
+    }
+
+    return cbCopy - cbLeft;
+}
+
+
+RTDECL(size_t) RTSgBufCopyFromBuf(PRTSGBUF pSgBuf, const void *pvBuf, size_t cbCopy)
+{
+    AssertPtrReturn(pSgBuf, 0);
+    AssertPtrReturn(pvBuf, 0);
+
+    size_t cbLeft = cbCopy;
+
+    while (cbLeft)
+    {
+        size_t cbThisCopy = cbLeft;
+        void *pvDst = rtSgBufGet(pSgBuf, &cbThisCopy);
+
+        if (!cbThisCopy)
+            break;
+
+        memcpy(pvDst, pvBuf, cbThisCopy);
+
+        cbLeft -= cbThisCopy;
+        pvBuf = (const void *)((uintptr_t)pvBuf + cbThisCopy);
+    }
+
+    return cbCopy - cbLeft;
+}
+
+
+RTDECL(size_t) RTSgBufAdvance(PRTSGBUF pSgBuf, size_t cbAdvance)
+{
+    AssertPtrReturn(pSgBuf, 0);
+
+    size_t cbLeft = cbAdvance;
+    while (cbLeft)
+    {
+        size_t cbThisAdvance = cbLeft;
+        rtSgBufGet(pSgBuf, &cbThisAdvance);
+        if (!cbThisAdvance)
+            break;
+
+        cbLeft -= cbThisAdvance;
+    }
+
+    return cbAdvance - cbLeft;
+}
+
+
+RTDECL(size_t) RTSgBufSegArrayCreate(PRTSGBUF pSgBuf, PRTSGSEG paSeg, unsigned *pcSeg, size_t cbData)
+{
+    AssertPtrReturn(pSgBuf, 0);
+    AssertPtrReturn(pcSeg, 0);
+
+    unsigned cSeg = 0;
+    size_t   cb = 0;
+
+    if (!paSeg)
+    {
+        if (pSgBuf->cbSegLeft > 0)
+        {
+            size_t idx = pSgBuf->idxSeg;
+            cSeg = 1;
+
+            cb     += RT_MIN(pSgBuf->cbSegLeft, cbData);
+            cbData -= RT_MIN(pSgBuf->cbSegLeft, cbData);
+
+            while (   cbData
+                   && idx < pSgBuf->cSegs - 1)
+            {
+                idx++;
+                cSeg++;
+                cb     += RT_MIN(pSgBuf->paSegs[idx].cbSeg, cbData);
+                cbData -= RT_MIN(pSgBuf->paSegs[idx].cbSeg, cbData);
+            }
+        }
+    }
+    else
+    {
+        while (   cbData
+               && cSeg < *pcSeg)
+        {
+            size_t  cbThisSeg = cbData;
+            void *pvSeg = rtSgBufGet(pSgBuf, &cbThisSeg);
+
+            if (!cbThisSeg)
+            {
+                Assert(!pvSeg);
+                break;
+            }
+
+            AssertMsg(cbThisSeg <= cbData, ("Impossible!\n"));
+
+            paSeg[cSeg].cbSeg = cbThisSeg;
+            paSeg[cSeg].pvSeg = pvSeg;
+            cSeg++;
+            cbData -= cbThisSeg;
+            cb     += cbThisSeg;
+        }
+    }
+
+    *pcSeg = cSeg;
+
+    return cb;
+}
+
+
+RTDECL(bool) RTSgBufIsZero(PRTSGBUF pSgBuf, size_t cbCheck)
+{
+    RTSGBUF SgBufTmp;
+    RTSgBufClone(&SgBufTmp, pSgBuf);
+
+    bool   fIsZero = true;
+    size_t cbLeft  = cbCheck;
+    while (cbLeft)
+    {
+        size_t cbThisCheck = cbLeft;
+        void *pvBuf = rtSgBufGet(&SgBufTmp, &cbThisCheck);
+        if (!cbThisCheck)
+            break;
+        fIsZero = ASMMemIsZero(pvBuf, cbThisCheck);
+        if (!fIsZero)
+            break;
+        cbLeft -= cbThisCheck;
+    }
+
+    return fIsZero;
+}
+