← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/virtualbox-ose/gutsy

« back to all changes in this revision

Viewing changes to src/VBox/VMM/PATM/VMMAll/CSAMAll.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-09-08 16:44:58 UTC
  • Revision ID: james.westby@ubuntu.com-20070908164458-wao29470vqtr8ksy
Tags: upstream-1.5.0-dfsg2
Import upstream version 1.5.0-dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/VMM/PATM/VMMAll/CSAMAll.cpp
 
1
/* $Id: CSAMAll.cpp 4071 2007-08-07 17:07:59Z vboxsync $ */
 
2
/** @file
 
3
 * CSAM - Guest OS Code Scanning and Analysis Manager - Any Context
 
4
 */
 
5
 
 
6
/*
 
7
 * Copyright (C) 2006-2007 innotek GmbH
 
8
 *
 
9
 * This file is part of VirtualBox Open Source Edition (OSE), as
 
10
 * available from http://www.virtualbox.org. This file is free software;
 
11
 * you can redistribute it and/or modify it under the terms of the GNU
 
12
 * General Public License as published by the Free Software Foundation,
 
13
 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
 
14
 * distribution. VirtualBox OSE is distributed in the hope that it will
 
15
 * be useful, but WITHOUT ANY WARRANTY of any kind.
 
16
 */
 
17
 
 
18
 
 
19
/*******************************************************************************
 
20
*   Header Files                                                               *
 
21
*******************************************************************************/
 
22
#define LOG_GROUP LOG_GROUP_CSAM
 
23
#include <VBox/cpum.h>
 
24
#include <VBox/stam.h>
 
25
#include <VBox/patm.h>
 
26
#include <VBox/csam.h>
 
27
#include <VBox/pgm.h>
 
28
#include <VBox/mm.h>
 
29
#include <VBox/sup.h>
 
30
#include <VBox/mm.h>
 
31
#include <VBox/param.h>
 
32
#include <iprt/avl.h>
 
33
#include "CSAMInternal.h"
 
34
#include <VBox/vm.h>
 
35
#include <VBox/dbg.h>
 
36
#include <VBox/err.h>
 
37
#include <VBox/log.h>
 
38
#include <iprt/assert.h>
 
39
#include <VBox/dis.h>
 
40
#include <VBox/disopcode.h>
 
41
#include <iprt/string.h>
 
42
#include <iprt/asm.h>
 
43
 
 
44
/**
 
45
 * Check if this page needs to be analysed by CSAM
 
46
 *
 
47
 * @returns VBox status code
 
48
 * @param   pVM         The VM to operate on.
 
49
 * @param   pvFault     Fault address
 
50
 */
 
51
CSAMDECL(int) CSAMExecFault(PVM pVM, RTGCPTR pvFault)
 
52
{
 
53
    if(!CSAMIsEnabled(pVM))
 
54
        return VINF_SUCCESS;
 
55
 
 
56
    LogFlow(("CSAMGCExecFault: for page %08X scanned=%d\n", pvFault, CSAMIsPageScanned(pVM, pvFault)));
 
57
 
 
58
    if(CSAMIsPageScanned(pVM, pvFault))
 
59
    {
 
60
        // Already checked!
 
61
        STAM_COUNTER_ADD(&pVM->csam.s.StatNrKnownPagesGC, 1);
 
62
        return VINF_SUCCESS;
 
63
    }
 
64
 
 
65
    STAM_COUNTER_ADD(&pVM->csam.s.StatNrTraps, 1);
 
66
    VM_FF_SET(pVM, VM_FF_CSAM_SCAN_PAGE);
 
67
    return VINF_CSAM_PENDING_ACTION;
 
68
}
 
69
 
 
70
 
 
71
/**
 
72
 * Check if this page was previously scanned by CSAM
 
73
 *
 
74
 * @returns true -> scanned, false -> not scanned
 
75
 * @param   pVM         The VM to operate on.
 
76
 * @param   pPage       GC page address
 
77
 */
 
78
CSAMDECL(bool) CSAMIsPageScanned(PVM pVM, RTGCPTR pPage)
 
79
{
 
80
    int pgdir, bit;
 
81
    uintptr_t page;
 
82
 
 
83
    page  = (uintptr_t)pPage;
 
84
    pgdir = page >> X86_PAGE_4M_SHIFT;
 
85
    bit   = (page & X86_PAGE_4M_OFFSET_MASK) >> X86_PAGE_4K_SHIFT;
 
86
 
 
87
    Assert(pgdir < CSAM_PGDIRBMP_CHUNKS);
 
88
    Assert(bit < PAGE_SIZE);
 
89
 
 
90
    return pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir] && ASMBitTest(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
 
91
}
 
92
 
 
93
 
 
94
 
 
95
/**
 
96
 * Mark a page as scanned/not scanned
 
97
 *
 
98
 * @note: we always mark it as scanned, even if we haven't completely done so
 
99
 *
 
100
 * @returns VBox status code.
 
101
 * @param   pVM         The VM to operate on.
 
102
 * @param   pPage       GC page address (not necessarily aligned)
 
103
 * @param   fScanned    Mark as scanned or not scanned
 
104
 *
 
105
 */
 
106
CSAMDECL(int) CSAMMarkPage(PVM pVM, RTGCPTR pPage, bool fScanned)
 
107
{
 
108
    int pgdir, bit;
 
109
    uintptr_t page;
 
110
 
 
111
#ifdef LOG_ENABLED
 
112
    if (fScanned && !CSAMIsPageScanned(pVM, pPage))
 
113
       Log(("CSAMMarkPage %VGv\n", pPage));
 
114
#endif
 
115
 
 
116
    if(!CSAMIsEnabled(pVM))
 
117
        return VINF_SUCCESS;
 
118
 
 
119
    page  = (uintptr_t)pPage;
 
120
    pgdir = page >> X86_PAGE_4M_SHIFT;
 
121
    bit   = (page & X86_PAGE_4M_OFFSET_MASK) >> X86_PAGE_4K_SHIFT;
 
122
 
 
123
    Assert(pgdir < CSAM_PGDIRBMP_CHUNKS);
 
124
    Assert(bit < PAGE_SIZE);
 
125
 
 
126
    if(!CTXSUFF(pVM->csam.s.pPDBitmap)[pgdir])
 
127
    {
 
128
        STAM_COUNTER_INC(&pVM->csam.s.StatBitmapAlloc);
 
129
        int rc = MMHyperAlloc(pVM, CSAM_PAGE_BITMAP_SIZE, 0, MM_TAG_CSAM, (void **)&pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir]);
 
130
        if (VBOX_FAILURE(rc))
 
131
        {
 
132
            Log(("MMR3HyperAlloc failed with %d\n", rc));
 
133
            return rc;
 
134
        }
 
135
#ifdef IN_GC
 
136
        pVM->csam.s.pPDHCBitmapGC[pgdir] = MMHyperGC2HC(pVM, pVM->csam.s.pPDBitmapGC[pgdir]);
 
137
        if (!pVM->csam.s.pPDHCBitmapGC[pgdir])
 
138
        {
 
139
            Log(("MMHyperHC2GC failed for %VGv\n", pVM->csam.s.pPDBitmapGC[pgdir]));
 
140
            return rc;
 
141
        }
 
142
#else
 
143
        pVM->csam.s.pPDGCBitmapHC[pgdir] = MMHyperHC2GC(pVM, pVM->csam.s.pPDBitmapHC[pgdir]);
 
144
        if (!pVM->csam.s.pPDGCBitmapHC[pgdir])
 
145
        {
 
146
            Log(("MMHyperHC2GC failed for %VHv\n", pVM->csam.s.pPDBitmapHC[pgdir]));
 
147
            return rc;
 
148
        }
 
149
#endif
 
150
    }
 
151
    if(fScanned)
 
152
        ASMBitSet(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
 
153
    else
 
154
        ASMBitClear(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
 
155
 
 
156
    return VINF_SUCCESS;
 
157
}
 
158
 
 
159
/**
 
160
 * Check if this page needs to be analysed by CSAM.
 
161
 *
 
162
 * This function should only be called for supervisor pages and
 
163
 * only when CSAM is enabled. Leaving these selection criteria
 
164
 * to the caller simplifies the interface (PTE passing).
 
165
 *
 
166
 * Note the the page has not yet been synced, so the TLB trick
 
167
 * (which wasn't ever active anyway) cannot be applied.
 
168
 *
 
169
 * @returns true if the page should be marked not present because
 
170
 *          CSAM want need to scan it.
 
171
 * @returns false if the page was already scanned.
 
172
 * @param   pVM         The VM to operate on.
 
173
 * @param   GCPtr       GC pointer of page
 
174
 */
 
175
CSAMDECL(bool) CSAMDoesPageNeedScanning(PVM pVM, RTGCPTR GCPtr)
 
176
{
 
177
    if(!CSAMIsEnabled(pVM))
 
178
        return false;
 
179
 
 
180
    if(CSAMIsPageScanned(pVM, GCPtr))
 
181
    {
 
182
        /* Already checked! */
 
183
        STAM_COUNTER_ADD(&CTXSUFF(pVM->csam.s.StatNrKnownPages), 1);
 
184
        return false;
 
185
    }
 
186
    STAM_COUNTER_ADD(&CTXSUFF(pVM->csam.s.StatNrPageNP), 1);
 
187
    return true;
 
188
}
 
189
 
 
190
 
 
191
/**
 
192
 * Remember a possible code page for later inspection
 
193
 *
 
194
 * @returns VBox status code.
 
195
 * @param   pVM         The VM to operate on.
 
196
 * @param   GCPtr       GC pointer of page
 
197
 */
 
198
CSAMDECL(void) CSAMMarkPossibleCodePage(PVM pVM, RTGCPTR GCPtr)
 
199
{
 
200
    if (pVM->csam.s.cPossibleCodePages < RT_ELEMENTS(pVM->csam.s.pvPossibleCodePage))
 
201
    {
 
202
        pVM->csam.s.pvPossibleCodePage[pVM->csam.s.cPossibleCodePages++] = GCPtr;
 
203
        VM_FF_SET(pVM, VM_FF_CSAM_PENDING_ACTION);
 
204
    }
 
205
    return;
 
206
}
 
207
 
 
208
 
 
209
/**
 
210
 * Turn on code scanning
 
211
 *
 
212
 * @returns VBox status code.
 
213
 * @param   pVM         The VM to operate on.
 
214
 */
 
215
CSAMDECL(int) CSAMEnableScanning(PVM pVM)
 
216
{
 
217
    pVM->fCSAMEnabled = true;
 
218
    return VINF_SUCCESS;
 
219
}
 
220
 
 
221
/**
 
222
 * Turn off code scanning
 
223
 *
 
224
 * @returns VBox status code.
 
225
 * @param   pVM         The VM to operate on.
 
226
 */
 
227
CSAMDECL(int) CSAMDisableScanning(PVM pVM)
 
228
{
 
229
    pVM->fCSAMEnabled = false;
 
230
    return VINF_SUCCESS;
 
231
}
 
232
 
 
233
 
 
234
/**
 
235
 * Check if we've scanned this instruction before. If true, then we can emulate
 
236
 * it instead of returning to ring 3.
 
237
 *
 
238
 * Using a simple array here as there are generally few mov crx instructions and
 
239
 * tree lookup is likely to be more expensive. (as it would also have to be offset based)
 
240
 *
 
241
 * @returns boolean
 
242
 * @param   pVM         The VM to operate on.
 
243
 * @param   GCPtr       GC pointer of page table entry
 
244
 */
 
245
CSAMDECL(bool) CSAMIsKnownDangerousInstr(PVM pVM, RTGCPTR GCPtr)
 
246
{
 
247
    for (uint32_t i=0;i<pVM->csam.s.cDangerousInstr;i++)
 
248
    {
 
249
        if (pVM->csam.s.aDangerousInstr[i] == GCPtr)
 
250
        {
 
251
            STAM_COUNTER_INC(&pVM->csam.s.StatInstrCacheHit);
 
252
            return true;
 
253
        }
 
254
    }
 
255
    /* Record that we're about to process it in ring 3. */
 
256
    pVM->csam.s.aDangerousInstr[pVM->csam.s.iDangerousInstr++] = GCPtr;
 
257
    pVM->csam.s.iDangerousInstr &= CSAM_MAX_DANGR_INSTR_MASK;
 
258
 
 
259
    if (++pVM->csam.s.cDangerousInstr > CSAM_MAX_DANGR_INSTR)
 
260
        pVM->csam.s.cDangerousInstr = CSAM_MAX_DANGR_INSTR;
 
261
 
 
262
    STAM_COUNTER_INC(&pVM->csam.s.StatInstrCacheMiss);
 
263
    return false;
 
264
}