Changeset 71351 in vbox

Timestamp:

Mar 15, 2018 1:26:21 PM (7 years ago)

Author:

vboxsync

Message:

PS2K: Throttle keyboard input to satisfy questionable software (see bugref:4118:51).

Location:

trunk/src/VBox/Devices

Files:

• Input/DevPS2.cpp (modified) (2 diffs)
• Input/PS2Dev.h (modified) (1 diff)
• Input/PS2K.cpp (modified) (13 diffs)
• testcase/tstDeviceStructSizeRC.cpp (modified) (2 diffs)

trunk/src/VBox/Devices/Input/DevPS2.cpp

@@ -963 +963 @@
      * Validate and read the configuration.
      */
-    if (!CFGMR3AreValuesValid(pCfg, "GCEnabled\0R0Enabled\0"))
+    if (!CFGMR3AreValuesValid(pCfg, "GCEnabled\0R0Enabled\0KbdThrottleEnabled\0"))
         return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
     rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &fGCEnabled, true);
@@ -981 +981 @@
     pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
 
-    rc = PS2KConstruct(&pThis->Kbd, pDevIns, pThis, iInstance);
+    rc = PS2KConstruct(&pThis->Kbd, pDevIns, pThis, iInstance, pCfg);
     if (RT_FAILURE(rc))
         return rc;

trunk/src/VBox/Devices/Input/PS2Dev.h

@@ -46 +46 @@
 int  PS2KByteFromKbd(PPS2K pThis, uint8_t *pVal);
 
-int  PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance);
+int  PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance, PCFGMNODE pCfg);
 int  PS2KAttach(PPS2K pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags);
 void PS2KReset(PPS2K pThis);

trunk/src/VBox/Devices/Input/PS2K.cpp

@@ -30 +30 @@
  *    However, Num Lock is not and the keyboard internally tracks its state.
  *  - The way Print Screen works in scan set 1/2 is totally insane.
+ *  - A PS/2 keyboard can send at most 1,000 to 1,500 bytes per second. There is
+ *    software which relies on that fact and assumes that a scan code can be
+ *    read twice before the next scan code comes in.
  */
 
@@ -112 +115 @@
 #define KBD_DFL_RATE_DELAY  0x2B
 
+/* Input throttling delay in milliseconds. */
+#define KBD_THROTTLE_DELAY  1
+
 /** Define a simple PS/2 input device queue. */
 #define DEF_PS2Q_TYPE(name, size)   \
@@ -132 +138 @@
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
-
-/** Scancode translator state.  */
-typedef enum {
-    SS_IDLE,    /**< Starting state. */
-    SS_EXT,     /**< E0 byte was received. */
-    SS_EXT1     /**< E1 byte was received. */
-} scan_state_t;
 
 /** Typematic state. */
@@ -188 +187 @@
     /** Typematic repeat period in milliseconds. */
     unsigned            uTypematicRepeat;
-#if HC_ARCH_BITS == 32
-    uint32_t            Alignment0;
-#endif
+    /** Set if the throttle delay is currently active. */
+    bool                fThrottleActive;
+    /** Set if the input rate should be throttled. */
+    bool                fThrottleEnabled;
+
+    uint8_t             Alignment0[2];
 
     /** Command delay timer - RC Ptr. */
@@ -196 +198 @@
     /** Typematic timer - RC Ptr. */
     PTMTIMERRC          pKbdTypematicTimerRC;
+    /** Input throttle timer - RC Ptr. */
+    PTMTIMERRC          pThrottleTimerRC;
 
     /** The device critical section protecting everything - R3 Ptr */
     R3PTRTYPE(PPDMCRITSECT) pCritSectR3;
+
     /** Command delay timer - R3 Ptr. */
     PTMTIMERR3          pKbdDelayTimerR3;
     /** Typematic timer - R3 Ptr. */
     PTMTIMERR3          pKbdTypematicTimerR3;
-    RTR3PTR             Alignment2;
+    /** Input throttle timer - R3 Ptr. */
+    PTMTIMERR3          pThrottleTimerR3;
 
     /** Command delay timer - R0 Ptr. */
@@ -209 +215 @@
     /** Typematic timer - R0 Ptr. */
     PTMTIMERR0          pKbdTypematicTimerR0;
-
-    scan_state_t        XlatState;      /// @todo temporary
-    uint32_t            Alignment1;
+    /** Input throttle timer - R0 Ptr. */
+    PTMTIMERR0          pThrottleTimerR0;
 
     /**
@@ -576 +581 @@
 
 }
+
+/**
+ * Query the number of items currently in a queue.
+ *
+ * @param   pQ                  Pointer to the queue.
+ *
+ * @return  uint32_t            Number of items in queue.
+ */
+static uint32_t ps2kInQueue(GeneriQ *pQ)
+{
+    return pQ->cUsed;
+}
+
 #endif /* IN_RING3 */
 
@@ -785 +803 @@
     rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
     if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && pThis->fScanning)
-        rc = ps2kRemoveQueue((GeneriQ *)&pThis->keyQ, pb);
+        if (!pThis->fThrottleActive)
+        {
+            rc = ps2kRemoveQueue((GeneriQ *)&pThis->keyQ, pb);
+            if (pThis->fThrottleEnabled) {
+                pThis->fThrottleActive = true;
+                TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), KBD_THROTTLE_DELAY);
+            }
+        }
 
     LogFlowFunc(("keyboard sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
@@ -1007 +1032 @@
 }
 
+/* Throttling timer to emulate the finite keyboard communication speed. A PS/2 keyboard is
+ * limited by the serial link speed and cannot send much more than 1,000 bytes per second.
+ * Some software (notably Borland Pascal and programs built with its run-time) relies on
+ * being able to read an incoming scan-code twice. Throttling the data rate enables such
+ * software to function, while human typists cannot tell any difference.
+ *
+ * Note: The throttling is currently only done for keyboard data, not command responses.
+ * The throttling could and perhaps should be done for any data (including command
+ * response) scoming from PS/2 devices, both keyboard and auxiliary. That is not currently
+ * done because it would needlessly slow things down.
+ */
+static DECLCALLBACK(void) ps2kThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+{
+    RT_NOREF2(pDevIns, pTimer);
+    PPS2K       pThis = (PS2K *)pvUser;
+    unsigned    uHaveData;
+
+    /* Grab the lock to avoid races with event delivery or EMTs. */
+    int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
+    AssertReleaseRC(rc);
+
+    /* If data is available, poke the KBC. Once the data
+     * is actually read, the timer may be re-triggered.
+     */
+    pThis->fThrottleActive = false;
+    uHaveData = ps2kInQueue((GeneriQ *)&pThis->keyQ);
+    LogFlowFunc(("Have%s bytes\n", uHaveData ? "" : " no"));
+    if (uHaveData)
+        KBCUpdateInterrupts(pThis->pParent);
+
+    PDMCritSectLeave(pThis->pCritSectR3);
+}
+
 /* Timer handler for emulating typematic keys. Note that only the last key
  * held down repeats (if typematic).
@@ -1365 +1423 @@
 
     pThis->fScanning         = true;
+    pThis->fThrottleActive   = false;
     pThis->u8ScanSet         = 2;
     pThis->u8CurrCmd         = 0;
@@ -1390 +1449 @@
 }
 
-int PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance)
+int PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance, PCFGMNODE pCfg)
 {
     RT_NOREF2(pDevIns, iInstance);
@@ -1396 +1455 @@
 
     pThis->pParent = pParent;
+
+    bool fThrottleEnabled;
+    int rc = CFGMR3QueryBoolDef(pCfg, "KbdThrottleEnabled", &fThrottleEnabled, true);
+    if (RT_FAILURE(rc))
+        return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"KbdThrottleEnabled\" from the config"));
+    Log(("KbdThrottleEnabled=%u\n", fThrottleEnabled));
+    pThis->fThrottleEnabled = fThrottleEnabled;
 
     /* Initialize the queues. */
@@ -1410 +1476 @@
 
     /*
+     * Create the input rate throttling timer. Does not use virtual time!
+     */
+    PTMTIMER pTimer;
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kThrottleTimer, pThis,
+                                    TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Throttle Timer", &pTimer);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    pThis->pThrottleTimerR3 = pTimer;
+    pThis->pThrottleTimerR0 = TMTimerR0Ptr(pTimer);
+    pThis->pThrottleTimerRC = TMTimerRCPtr(pTimer);
+
+    /*
      * Create the typematic delay/repeat timer. Does not use virtual time!
      */
-    PTMTIMER pTimer;
-    int rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kTypematicTimer, pThis,
-                                    TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pTimer);
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kTypematicTimer, pThis,
+                                TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pTimer);
     if (RT_FAILURE(rc))
         return rc;

trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

@@ -439 +439 @@
     GEN_CHECK_OFF(PS2K, cmdQ);
     GEN_CHECK_OFF(PS2K, uTypematicDelay);
+    GEN_CHECK_OFF(PS2K, fThrottleActive);
     GEN_CHECK_OFF(PS2K, pKbdDelayTimerRC);
     GEN_CHECK_OFF(PS2K, pKbdDelayTimerR3);
@@ -445 +446 @@
     GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR3);
     GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR0);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerRC);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerR3);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerR0);
     GEN_CHECK_OFF(PS2K, pCritSectR3);
     GEN_CHECK_OFF(PS2K, Keyboard.IBase);