Changeset 890 in vbox for trunk/src

Timestamp:

Feb 14, 2007 9:35:02 AM (18 years ago)

Author:

vboxsync

Message:

RTRand API (feel free to improve the fallback code).

Location:

trunk/src/VBox/Runtime

Files:

• generic/rand-stubs-generic.cpp (copied) (copied from trunk/src/VBox/Runtime/generic/fs-stubs-generic.cpp ) (2 diffs)
• include/internal/rand.h (copied) (copied from trunk/src/VBox/Runtime/include/internal/time.h ) (3 diffs)
• misc/rand.cpp (modified) (15 diffs)

trunk/src/VBox/Runtime/generic/rand-stubs-generic.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * InnoTek Portable Runtime - File System, Generic Stubs.
+ * InnoTek Portable Runtime - Random Numbers and Byte Streams, Generic Stubs.
  */
 
@@ -24 +24 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#define LOG_GROUP RTLOGGROUP_FS
-
-#include <iprt/fs.h>
+#include <iprt/rand.h>
 #include <iprt/err.h>
-#include <iprt/log.h>
-#include <iprt/assert.h>
-#include "internal/fs.h"
+#include "internal/rand.h"
 
 
-
-RTR3DECL(int) RTFsQuerySizes(const char *pszFsPath, RTFOFF *pcbTotal, RTFOFF *pcbFree,
-                             uint32_t *pcbBlock, uint32_t *pcbSector)
+void rtRandLazyInitNative(void)
 {
-    if (pcbTotal)
-        *pcbTotal = _2G;
-    if (pcbFree)
-        *pcbFree = _1G;
-    if (pcbBlock)
-        *pcbBlock = _4K;
-    if (pcbSector)
-        *pcbSector = 512;
-    LogFlow(("RTFsQuerySizes: success stub!\n"));
-    return VINF_SUCCESS;
 }
 
 
-RTR3DECL(int) RTFsQuerySerial(const char *pszFsPath, uint32_t *pu32Serial)
+int rtRandGenBytesNative(void *pv, size_t cb)
 {
-    if (pu32Serial)
-        *pu32Serial = 0xc0ffee;
-    LogFlow(("RTFsQuerySerial: success stub!\n"));
-    return VINF_SUCCESS;
+    NOREF(pv);
+    NOREF(cb);
+    return VERR_NOT_SUPPORTED;
 }
-
-
-RTR3DECL(int) RTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties)
-{
-    pProperties->cbMaxComponent = 255;
-    pProperties->fCaseSensitive = true;
-    pProperties->fCompressed = false;
-    pProperties->fFileCompression = false;
-    pProperties->fReadOnly = false;
-    pProperties->fRemote = false;
-    pProperties->fSupportsUnicode = true;
-    LogFlow(("RTFsQueryProperties: success stub!\n"));
-    return VINF_SUCCESS;
-}
-
+                   

trunk/src/VBox/Runtime/include/internal/rand.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * InnoTek Portable Runtime - Internal RTTime header
+ * InnoTek Portable Runtime - Internal RTRand header
  */
 
@@ -20 +20 @@
  */
 
-#ifndef __internal_time_h__
-#define __internal_time_h__
+#ifndef __internal_rand_h__
+#define __internal_rand_h__
 
 #include <iprt/types.h>
@@ -27 +27 @@
 __BEGIN_DECLS
 
-#ifdef IN_RING3
+/**
+ * Initialize OS facilities for generating random bytes.
+ */
+void rtRandLazyInitNative(void);
 
-extern uint64_t g_u64ProgramStartNanoTS;
-extern uint64_t g_u64ProgramStartMilliTS;
+/**
+ * Generate random bytes using OS facilities.
+ * 
+ * @returns VINF_SUCCESS on success, some error status code on failure.
+ * @param   pv      Where to store the random bytes.
+ * @param   cb      How many random bytes to store.
+ */
+int rtRandGenBytesNative(void *pv, size_t cb);
 
-#endif
+void rtRandGenBytesFallback(void *pv, size_t cb);
 
 __END_DECLS

trunk/src/VBox/Runtime/misc/rand.cpp

@@ -28 +28 @@
 #include <iprt/asm.h>
 #include <iprt/err.h>
+#include <iprt/assert.h>
+#include <iprt/thread.h>
 #include "internal/rand.h"
-
 
 
@@ -36 +37 @@
 *******************************************************************************/
 /** Lazy init. */
-static volatile bool g_fInitialized = false;
-
-
+static volatile bool    g_fInitialized = false;
+/** The context variable for the fallback path. */
+static uint32_t         g_u32Ctx;
+
+
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+static uint32_t rtRandGenBytesFallbackU31(uint32_t *pCtx);
+
+
+/**
+ * Lazy initialization of the native and fallback random byte sources.
+ * 
+ */
 static void rtRandLazyInit(void)
 {
+    /*
+     * Seed the fallback random code.
+     */
+    g_u32Ctx = (uint32_t)(ASMReadTSC() >> 8);
+
     /*
      * Call host specific init.
      */
-
-    /*
-     * Seed the fallback random code.
-     */
+    rtRandLazyInitNative();
+    g_fInitialized = true;
 }
 
@@ -59 +75 @@
 static void rtRandGenBytes(void *pv, size_t cb)
 {
+    Assert(cb);
     if (RT_UNLIKELY(!g_fInitialized))
         rtRandLazyInit();
@@ -64 +81 @@
     int rc = rtRandGenBytesNative(pv, cb);
     if (RT_FAILURE(rc))
-    {
-        /* fallback */
-    }
-}
-
-
-RTDECL(int32_t) RTRandS32Ex(uint32_t i32First, int32_t i32Last)
+        rtRandGenBytesFallback(pv, cb);
+}
+
+
+/**
+ * Fills a buffer with random bytes.
+ *
+ * @param   pv  Where to store the random bytes.
+ * @param   cb  Number of bytes to generate.
+ */
+RTDECL(void) RTRandBytes(void *pv, size_t cb)
+{
+    if (cb)
+        rtRandGenBytes(pv, cb);
+}
+
+
+/**
+ * Generate a 32-bit signed random number in the set [i32First..i32Last].
+ * 
+ * @returns The random number.
+ * @param   i32First    First number in the set.
+ * @param   i32Last     Last number in the set.
+ */
+RTDECL(int32_t) RTRandS32Ex(int32_t i32First, int32_t i32Last)
 {
     /* get 4 random bytes. */
@@ -83 +118 @@
     /* squeeze it into the requested range. */
     uint32_t offLast = i32Last - i32First;
-    if (u.off > offLasts)
+    if (u.off > offLast)
     {
         do
         {
             u.off >>= 1;
-        } while (u.off > offLasts);
+        } while (u.off > offLast);
     }
     return i32First + u.off;
@@ -94 +129 @@
 
 
+/**
+ * Generate a 32-bit signed random number.
+ * 
+ * @returns The random number.
+ */
 RTDECL(int32_t) RTRandS32(void)
 {
@@ -100 +140 @@
 
 
+/**
+ * Generate a 32-bit unsigned random number in the set [u32First..u32Last].
+ * 
+ * @returns The random number.
+ * @param   u32First    First number in the set.
+ * @param   u32Last     Last number in the set.
+ */
 RTDECL(uint32_t) RTRandU32Ex(uint32_t u32First, uint32_t u32Last)
 {
@@ -113 +160 @@
     /* squeeze it into the requested range. */
     const uint32_t offLast = u32Last - u32First;
-    if (u.off > offLasts)
+    if (u.off > offLast)
     {
         do
         {
             u.off >>= 1;
-        } while (u.off > offLasts);
+        } while (u.off > offLast);
     }
     return u32First + u.off;
@@ -124 +171 @@
 
 
+/**
+ * Generate a 32-bit unsigned random number.
+ * 
+ * @returns The random number.
+ */
 RTDECL(uint32_t) RTRandU32(void)
 {
@@ -130 +182 @@
 
 
-RTDECL(int64_t) RTRandS64Ex(uint32_t i64First, int64_t i64Last)
+/**
+ * Generate a 32-bit signed random number in the set [i32First..i32Last].
+ * 
+ * @returns The random number.
+ * @param   i32First    First number in the set.
+ * @param   i32Last     Last number in the set.
+ */
+RTDECL(int64_t) RTRandS64Ex(int64_t i64First, int64_t i64Last)
 {
     /* get 8 random bytes. */
@@ -136 +195 @@
     {
         uint64_t    off;
-        uint8_t     ab[4];
+        uint8_t     ab[8];
     } u;
     rtRandGenBytes(&u.ab, sizeof(u));
 
-
     /* squeeze it into the requested range. */
     uint64_t offLast = i64Last - i64First;
-    if (u.off > offLasts)
+    if (u.off > offLast)
     {
         do
         {
             u.off >>= 1;
-        } while (u.off > offLasts);
+        } while (u.off > offLast);
     }
     return i64First + u.off;
@@ -154 +212 @@
 
 
+/**
+ * Generate a 64-bit signed random number.
+ * 
+ * @returns The random number.
+ */
 RTDECL(int64_t) RTRandS64(void)
 {
@@ -160 +223 @@
 
 
+/**
+ * Generate a 64-bit unsigned random number in the set [u64First..u64Last].
+ * 
+ * @returns The random number.
+ * @param   u64First    First number in the set.
+ * @param   u64Last     Last number in the set.
+ */
 RTDECL(uint64_t) RTRandU64Ex(uint64_t u64First, uint64_t u64Last)
 {
-    /* get 4 random bytes. */
+    /* get 8 random bytes. */
     union
     {
         uint64_t    off;
-        uint8_t     ab[4];
+        uint8_t     ab[8];
     } u;
     rtRandGenBytes(&u.ab, sizeof(u));
 
-
     /* squeeze it into the requested range. */
     const uint64_t offLast = u64Last - u64First;
-    if (u.off > offLasts)
+    if (u.off > offLast)
     {
         do
         {
             u.off >>= 1;
-        } while (u.off > offLasts);
+        } while (u.off > offLast);
     }
     return u64First + u.off;
@@ -184 +253 @@
 
 
+/**
+ * Generate a 64-bit unsigned random number.
+ * 
+ * @returns The random number.
+ */
 RTDECL(uint64_t) RTRandU64(void)
 {
@@ -190 +264 @@
 
 
+/**
+ * Fallback random byte source.
+ *
+ * @param   pv  Where to store the random bytes.
+ * @param   cb  Number of bytes to generate.
+ */
+void rtRandGenBytesFallback(void *pv, size_t cb)
+{
+    uint8_t *pb = (uint8_t *)pv;
+    for (unsigned i = 0;; i++)
+    {
+        uint32_t u32 = rtRandGenBytesFallbackU31(&g_u32Ctx);
+
+        *pb++ = (uint8_t)u32;
+        if (!--cb)
+            break;
+
+        u32 >>= 8;
+        *pb++ = (uint8_t)u32;
+        if (!--cb)
+            break;
+
+        u32 >>= 8;
+        *pb++ = (uint8_t)u32;
+        if (!--cb)
+            break;
+
+        /* Is this really a good idea? */
+        if (!(i % 3))
+        {
+            if (i)
+                RTThreadYield();
+            *pb++ = (uint8_t)ASMReadTSC();
+            if (!--cb)
+                break;
+        }
+    }
+
+}
+
+
+/*-
+ * Copyright (c) 1990, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* The core of:
+__FBSDID("$FreeBSD: /repoman/r/ncvs/src/lib/libc/stdlib/rand.c,v 1.16 2007/01/09 00:28:10 imp Exp $");
+*/
+
+/**
+ * Generates an unsigned 31 bit pseudo random number.
+ * 
+ * @returns pseudo random number.
+ * @param   pCtx    The context.
+ */
+static uint32_t rtRandGenBytesFallbackU31(uint32_t *pCtx)
+{
+    /*
+     * Compute x = (7^5 * x) mod (2^31 - 1)
+     * without overflowing 31 bits:
+     *      (2^31 - 1) = 127773 * (7^5) + 2836
+     *
+     * From "Random number generators: good ones are hard to find",  Park and 
+     * Miller, Communications of the ACM, vol. 31, no. 10, October 1988, p. 1195.
+     */
+    uint32_t Ctx = *pCtx;
+    if (!Ctx) /* must not be zero. */
+        Ctx = 0x20070212;
+    uint32_t Hi = Ctx / 127773;
+    uint32_t Lo = Ctx % 127773;
+    int32_t x = 16807 * Lo  -  2836 * Hi;
+    if (x < 0)
+        x += INT32_MAX;
+    *pCtx = x;
+    return x % INT32_MAX;
+}
+