kvm-guest-drivers-windows

1
#include "speed-test.h"
2

3
#ifndef linux
4

5
#include "device.h"
6
#include "assert.h"
7

8

9
#pragma warning(default:4201)
10

11
static ULONG write_buffer_size = 4096;
12
static BOOL  write_send_auto = FALSE;
13

14
BOOL
15
GetInfoTest(
16
    __in CDevice *pDev
17
    )
18
{
19
    PVOID   buf = NULL;
20
    PVIRTIO_PORT_INFO inf = NULL;
21
    size_t  len;
22

23
    if (!pDev) return FALSE;
24

25
    len = sizeof(VIRTIO_PORT_INFO);
26
    buf = GlobalAlloc(0, len);
27
    if (!buf) return FALSE;
28
    if (!pDev->GetInfo(buf, &len))
29
    {
30
        GlobalFree(buf);
31
        buf = GlobalAlloc(0, len);
32
        if (!buf) return FALSE;
33
        if (!pDev->GetInfo(buf, &len))
34
        {
35
           GlobalFree(buf);
36
           return FALSE;
37
        }
38
    }
39

40
    inf = (PVIRTIO_PORT_INFO)buf;
41
    printf("Id = %d\n", inf->Id);
42
    printf("OutVqFull = %d\n", inf->OutVqFull);
43
    printf("HostConnected = %d\n", inf->HostConnected);
44
    printf("GuestConnected = %d\n", inf->GuestConnected);
45
    if (len > sizeof(VIRTIO_PORT_INFO) && inf->Name[0])
46
    {
47
        printf("Id = %s\n", inf->Name);
48
    }
49
    GlobalFree(buf);
50
    return TRUE;
51
}
52

53
BOOL
54
WriteTest(
55
    __in CDevice *pDev,
56
    __in BOOLEAN ovrl
57
    )
58
{
59
    PUCHAR  buf = NULL;
60
    BOOLEAN res = TRUE;
61
    int     i;
62
    size_t  size = write_buffer_size;
63

64
    if (!pDev) return FALSE;
65

66
    printf("%s.\n", __FUNCTION__);
67

68

69
    buf = (PUCHAR)GlobalAlloc(0, size);
70

71
    if( buf == NULL )
72
    {
73
        printf("%s: Could not allocate %zd "
74
               "bytes buf\n", __FUNCTION__, size);
75

76
        return FALSE;
77
    }
78

79
    for(i = 0 ;i < (int)size; i++)
80
    {
81
        if (!write_send_auto)
82
        {
83
            int ch = getchar();
84

85
            buf[i] = (char)ch;
86
            if (ch == '\n') break;
87
        }
88
        else
89
        {
90
            buf[i] = 'a' + i % 20;
91
            if (i == (size - 1))
92
            {
93
                buf[i] = '\n';
94
            }
95
        }
96
    }
97
    size = i;
98
    res =  ovrl ? pDev->WriteEx(buf, &size) : pDev->Write(buf, &size);
99

100
    if (!res)
101
    {
102
        printf ("%s: WriteFile failed: "
103
                "Error %d\n", __FUNCTION__, GetLastError());
104
    }
105
    else
106
    {
107
        printf ("%s: WriteFile OK: "
108
                "snd %zd bytes\n\n", __FUNCTION__, size);
109
        if (!write_send_auto) {
110
            printf("%s\n", buf);
111
        }
112
    }
113

114
    GlobalFree(buf);
115

116
    return res;
117
}
118

119
BOOL
120
WriteTestCycl(
121
    __in CDevice *pDev,
122
    __in BOOLEAN ovrl
123
    )
124
{
125
    int ch;
126
    for (;;)
127
    {
128
        if(!WriteTest(pDev, ovrl)) return FALSE;
129
        ch = getchar();
130
        if(ch == EOF) break;
131
        putchar(ch);
132
    }
133
    return TRUE;
134
}
135

136
BOOL
137
ReadTest(
138
    __in CDevice *pDev,
139
    __in BOOLEAN ovrl
140
    )
141
{
142
    PUCHAR buf = NULL;
143
    BOOLEAN res = TRUE;
144

145
    size_t size = 4096;
146

147
    if (!pDev) return FALSE;
148

149
    printf("%s.\n", __FUNCTION__);
150

151

152
    buf = (PUCHAR)GlobalAlloc(0, size);
153

154
    if( buf == NULL )
155
    {
156
        printf("%s: Could not allocate %zd "
157
               "bytes buf\n", __FUNCTION__, size);
158

159
        return FALSE;
160
    }
161

162
    res =  ovrl ? pDev->ReadEx(buf, &size) : pDev->Read(buf, &size);
163

164
    if (!res)
165
    {
166
        printf ("%s: ReadFile failed: "
167
                "Error %d\n", __FUNCTION__, GetLastError());
168
    }
169
    else
170
    {
171
        printf ("%s: ReadFile OK: "
172
                "rcv %zd bytes\n\n", __FUNCTION__, size);
173
        printf ("%s\n", buf);
174
    }
175

176
    GlobalFree(buf);
177

178
    return res;
179
}
180

181
BOOL
182
ReadTestCycl(
183
    __in CDevice *pDev,
184
    __in BOOLEAN ovrl
185
    )
186
{
187
    int ch;
188
    for (;;)
189
    {
190
        if(!ReadTest(pDev, ovrl)) return FALSE;
191
        if(_kbhit())
192
        {
193
           ch = getchar();
194
           if(ch == EOF) break;
195
           putchar(ch);
196
        }
197
    }
198
    return TRUE;
199
}
200

201
ULONG
202
_cdecl
203
wmain(
204
    __in              ULONG argc,
205
    __in_ecount(argc) PWCHAR argv[]
206
    )
207
{
208
    int ch;
209
    CDevice *m_pDev;
210
    BOOLEAN stoptest = FALSE;
211
    BOOLEAN ovrl = TRUE;
212
    UINT ifIndex = 0;
213
    int speedTest = 0;
214

215
    if(argc == 2)
216
    {
217
        if (_wcsicmp(L"-sp", argv[1]) == 0) {
218
            speedTest = 1;
219
        }
220
        else if (_wcsicmp(L"-n", argv[1]) == 0) {
221
           ovrl = FALSE;
222
        }
223
    }
224

225
    if (speedTest)
226
    {
227
        speed_test(true);
228
        return 0;
229
    }
230

231
    if (ovrl)
232
    {
233
        printf("Running in non-blocking mode.\n");
234
    }
235
    else
236
    {
237
        printf("Running in blocking mode.\n");
238
    }
239

240
    m_pDev = new CDevice;
241
    if (!m_pDev)
242
    {
243
        return 1;
244
    }
245
    while (!m_pDev->Init(ovrl, ifIndex))
246
    {
247
        ifIndex++;
248
        if (ifIndex >= 4)
249
        {
250
            delete m_pDev;
251
            return 2;
252
        }
253
    }
254

255
    while (!stoptest)
256
    {
257
        ch = getchar();
258
        while(getchar()!='\n');
259
        switch (ch)
260
        {
261
           case 'i':
262
           case 'I':
263
              GetInfoTest(m_pDev);
264
              break;
265
           case '+':
266
               write_buffer_size = write_buffer_size * 2;
267
               printf("write_buffer_size = %d\n", write_buffer_size);
268
               break;
269
           case '-':
270
               if (write_buffer_size > 16) {
271
                   write_buffer_size = write_buffer_size / 2;
272
               }
273
               printf("write_buffer_size = %d\n", write_buffer_size);
274
               break;
275
           case '!':
276
               write_send_auto = !write_send_auto;
277
               printf("write_send_auto = %d\n", write_send_auto);
278
               break;
279
           case 'r':
280
           case 'R':
281
              ReadTest(m_pDev, ovrl);
282
              break;
283
           case 'f':
284
           case 'F':
285
              ReadTestCycl(m_pDev, ovrl);
286
              break;
287
           case 'w':
288
           case 'W':
289
              WriteTest(m_pDev, ovrl);
290
              break;
291
           case 's':
292
           case 'S':
293
              WriteTestCycl(m_pDev, ovrl);
294
              break;
295
           case 'q':
296
           case 'Q':
297
              stoptest = TRUE;
298
              break;
299
        }
300
    }
301

302
    delete m_pDev;
303
    return 0;
304
}
305

306
#else
307

308
int main()
309
{
310
    speed_test(false);
311
    return 0;
312
}
313

314
#endif
315