VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/BusAssignmentManager.cpp@ 59090

Last change on this file since 59090 was 57809, checked in by vboxsync, 9 years ago

Reverted bad commit r102754.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.0 KB
Line 
1/* $Id: BusAssignmentManager.cpp 57809 2015-09-17 16:12:55Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox bus slots assignment manager
6 */
7
8/*
9 * Copyright (C) 2010-2014 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19#include "BusAssignmentManager.h"
20
21#include <iprt/asm.h>
22#include <iprt/string.h>
23
24#include <VBox/vmm/cfgm.h>
25#include <VBox/com/array.h>
26
27
28#include "PCIDeviceAttachmentImpl.h"
29
30#include <map>
31#include <vector>
32#include <algorithm>
33
34struct DeviceAssignmentRule
35{
36 const char* pszName;
37 int iBus;
38 int iDevice;
39 int iFn;
40 int iPriority;
41};
42
43struct DeviceAliasRule
44{
45 const char* pszDevName;
46 const char* pszDevAlias;
47};
48
49/* Those rules define PCI slots assignment */
50
51/* Device Bus Device Function Priority */
52
53/* Generic rules */
54static const DeviceAssignmentRule aGenericRules[] =
55{
56 /* VGA controller */
57 {"vga", 0, 2, 0, 0},
58
59 /* VMM device */
60 {"VMMDev", 0, 4, 0, 0},
61
62 /* Audio controllers */
63 {"ichac97", 0, 5, 0, 0},
64 {"hda", 0, 5, 0, 0},
65
66 /* Storage controllers */
67 {"lsilogic", 0, 20, 0, 1},
68 {"buslogic", 0, 21, 0, 1},
69 {"lsilogicsas", 0, 22, 0, 1},
70 {"nvme", 0, 14, 0, 1},
71
72 /* USB controllers */
73 {"usb-ohci", 0, 6, 0, 0},
74 {"usb-ehci", 0, 11, 0, 0},
75 {"usb-xhci", 0, 12, 0, 0},
76
77 /* ACPI controller */
78 {"acpi", 0, 7, 0, 0},
79
80 /* Network controllers */
81 /* the first network card gets the PCI ID 3, the next 3 gets 8..10,
82 * next 4 get 16..19. In "VMWare compatibility" mode the IDs 3 and 17
83 * swap places, i.e. the first card goes to ID 17=0x11. */
84 {"nic", 0, 3, 0, 1},
85 {"nic", 0, 8, 0, 1},
86 {"nic", 0, 9, 0, 1},
87 {"nic", 0, 10, 0, 1},
88 {"nic", 0, 16, 0, 1},
89 {"nic", 0, 17, 0, 1},
90 {"nic", 0, 18, 0, 1},
91 {"nic", 0, 19, 0, 1},
92
93 /* ISA/LPC controller */
94 {"lpc", 0, 31, 0, 0},
95
96 { NULL, -1, -1, -1, 0}
97};
98
99/* PIIX3 chipset rules */
100static const DeviceAssignmentRule aPiix3Rules[] =
101{
102 {"piix3ide", 0, 1, 1, 0},
103 {"ahci", 0, 13, 0, 1},
104 {"pcibridge", 0, 24, 0, 0},
105 {"pcibridge", 0, 25, 0, 0},
106 { NULL, -1, -1, -1, 0}
107};
108
109
110/* ICH9 chipset rules */
111static const DeviceAssignmentRule aIch9Rules[] =
112{
113 /* Host Controller */
114 {"i82801", 0, 30, 0, 0},
115
116 /* Those are functions of LPC at 00:1e:00 */
117 /**
118 * Please note, that for devices being functions, like we do here, device 0
119 * must be multifunction, i.e. have header type 0x80. Our LPC device is.
120 * Alternative approach is to assign separate slot to each device.
121 */
122 {"piix3ide", 0, 31, 1, 2},
123 {"ahci", 0, 31, 2, 2},
124 {"smbus", 0, 31, 3, 2},
125 {"usb-ohci", 0, 31, 4, 2},
126 {"usb-ehci", 0, 31, 5, 2},
127 {"thermal", 0, 31, 6, 2},
128
129 /* to make sure rule never used before rules assigning devices on it */
130 {"ich9pcibridge", 0, 24, 0, 10},
131 {"ich9pcibridge", 0, 25, 0, 10},
132 {"ich9pcibridge", 1, 24, 0, 9},
133 {"ich9pcibridge", 1, 25, 0, 9},
134 {"ich9pcibridge", 2, 24, 0, 8},
135 {"ich9pcibridge", 2, 25, 0, 8},
136 {"ich9pcibridge", 3, 24, 0, 7},
137 {"ich9pcibridge", 3, 25, 0, 7},
138 {"ich9pcibridge", 4, 24, 0, 6},
139 {"ich9pcibridge", 4, 25, 0, 6},
140 {"ich9pcibridge", 5, 24, 0, 5},
141 {"ich9pcibridge", 5, 25, 0, 5},
142
143 /* Storage controllers */
144 {"ahci", 1, 0, 0, 0},
145 {"ahci", 1, 1, 0, 0},
146 {"ahci", 1, 2, 0, 0},
147 {"ahci", 1, 3, 0, 0},
148 {"ahci", 1, 4, 0, 0},
149 {"ahci", 1, 5, 0, 0},
150 {"ahci", 1, 6, 0, 0},
151 {"lsilogic", 1, 7, 0, 0},
152 {"lsilogic", 1, 8, 0, 0},
153 {"lsilogic", 1, 9, 0, 0},
154 {"lsilogic", 1, 10, 0, 0},
155 {"lsilogic", 1, 11, 0, 0},
156 {"lsilogic", 1, 12, 0, 0},
157 {"lsilogic", 1, 13, 0, 0},
158 {"buslogic", 1, 14, 0, 0},
159 {"buslogic", 1, 15, 0, 0},
160 {"buslogic", 1, 16, 0, 0},
161 {"buslogic", 1, 17, 0, 0},
162 {"buslogic", 1, 18, 0, 0},
163 {"buslogic", 1, 19, 0, 0},
164 {"buslogic", 1, 20, 0, 0},
165 {"lsilogicsas", 1, 21, 0, 0},
166 {"lsilogicsas", 1, 26, 0, 0},
167 {"lsilogicsas", 1, 27, 0, 0},
168 {"lsilogicsas", 1, 28, 0, 0},
169 {"lsilogicsas", 1, 29, 0, 0},
170 {"lsilogicsas", 1, 30, 0, 0},
171 {"lsilogicsas", 1, 31, 0, 0},
172 {"nvme", 1, 32, 0, 0},
173 {"nvme", 1, 33, 0, 0},
174 {"nvme", 1, 34, 0, 0},
175 {"nvme", 1, 35, 0, 0},
176 {"nvme", 1, 36, 0, 0},
177 {"nvme", 1, 37, 0, 0},
178 {"nvme", 1, 38, 0, 0},
179
180 /* NICs */
181 {"nic", 2, 0, 0, 0},
182 {"nic", 2, 1, 0, 0},
183 {"nic", 2, 2, 0, 0},
184 {"nic", 2, 3, 0, 0},
185 {"nic", 2, 4, 0, 0},
186 {"nic", 2, 5, 0, 0},
187 {"nic", 2, 6, 0, 0},
188 {"nic", 2, 7, 0, 0},
189 {"nic", 2, 8, 0, 0},
190 {"nic", 2, 9, 0, 0},
191 {"nic", 2, 10, 0, 0},
192 {"nic", 2, 11, 0, 0},
193 {"nic", 2, 12, 0, 0},
194 {"nic", 2, 13, 0, 0},
195 {"nic", 2, 14, 0, 0},
196 {"nic", 2, 15, 0, 0},
197 {"nic", 2, 16, 0, 0},
198 {"nic", 2, 17, 0, 0},
199 {"nic", 2, 18, 0, 0},
200 {"nic", 2, 19, 0, 0},
201 {"nic", 2, 20, 0, 0},
202 {"nic", 2, 21, 0, 0},
203 {"nic", 2, 26, 0, 0},
204 {"nic", 2, 27, 0, 0},
205 {"nic", 2, 28, 0, 0},
206 {"nic", 2, 29, 0, 0},
207 {"nic", 2, 30, 0, 0},
208 {"nic", 2, 31, 0, 0},
209
210 { NULL, -1, -1, -1, 0}
211};
212
213/* Aliasing rules */
214static const DeviceAliasRule aDeviceAliases[] =
215{
216 {"e1000", "nic"},
217 {"pcnet", "nic"},
218 {"virtio-net", "nic"},
219 {"ahci", "storage"},
220 {"lsilogic", "storage"},
221 {"buslogic", "storage"},
222 {"lsilogicsas", "storage"},
223 {"nvme", "storage"}
224};
225
226struct BusAssignmentManager::State
227{
228 struct PCIDeviceRecord
229 {
230 char szDevName[32];
231 PCIBusAddress HostAddress;
232
233 PCIDeviceRecord(const char* pszName, PCIBusAddress aHostAddress)
234 {
235 RTStrCopy(this->szDevName, sizeof(szDevName), pszName);
236 this->HostAddress = aHostAddress;
237 }
238
239 PCIDeviceRecord(const char* pszName)
240 {
241 RTStrCopy(this->szDevName, sizeof(szDevName), pszName);
242 }
243
244 bool operator<(const PCIDeviceRecord &a) const
245 {
246 return RTStrNCmp(szDevName, a.szDevName, sizeof(szDevName)) < 0;
247 }
248
249 bool operator==(const PCIDeviceRecord &a) const
250 {
251 return RTStrNCmp(szDevName, a.szDevName, sizeof(szDevName)) == 0;
252 }
253 };
254
255 typedef std::map <PCIBusAddress,PCIDeviceRecord > PCIMap;
256 typedef std::vector<PCIBusAddress> PCIAddrList;
257 typedef std::vector<const DeviceAssignmentRule*> PCIRulesList;
258 typedef std::map <PCIDeviceRecord,PCIAddrList > ReversePCIMap;
259
260 volatile int32_t cRefCnt;
261 ChipsetType_T mChipsetType;
262 PCIMap mPCIMap;
263 ReversePCIMap mReversePCIMap;
264
265 State()
266 : cRefCnt(1), mChipsetType(ChipsetType_Null)
267 {}
268 ~State()
269 {}
270
271 HRESULT init(ChipsetType_T chipsetType);
272
273 HRESULT record(const char* pszName, PCIBusAddress& GuestAddress, PCIBusAddress HostAddress);
274 HRESULT autoAssign(const char* pszName, PCIBusAddress& Address);
275 bool checkAvailable(PCIBusAddress& Address);
276 bool findPCIAddress(const char* pszDevName, int iInstance, PCIBusAddress& Address);
277
278 const char* findAlias(const char* pszName);
279 void addMatchingRules(const char* pszName, PCIRulesList& aList);
280 void listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached);
281};
282
283HRESULT BusAssignmentManager::State::init(ChipsetType_T chipsetType)
284{
285 mChipsetType = chipsetType;
286 return S_OK;
287}
288
289HRESULT BusAssignmentManager::State::record(const char* pszName, PCIBusAddress& Address, PCIBusAddress HostAddress)
290{
291 PCIDeviceRecord devRec(pszName, HostAddress);
292
293 /* Remember address -> device mapping */
294 mPCIMap.insert(PCIMap::value_type(Address, devRec));
295
296 ReversePCIMap::iterator it = mReversePCIMap.find(devRec);
297 if (it == mReversePCIMap.end())
298 {
299 mReversePCIMap.insert(ReversePCIMap::value_type(devRec, PCIAddrList()));
300 it = mReversePCIMap.find(devRec);
301 }
302
303 /* Remember device name -> addresses mapping */
304 it->second.push_back(Address);
305
306 return S_OK;
307}
308
309bool BusAssignmentManager::State::findPCIAddress(const char* pszDevName, int iInstance, PCIBusAddress& Address)
310{
311 PCIDeviceRecord devRec(pszDevName);
312
313 ReversePCIMap::iterator it = mReversePCIMap.find(devRec);
314 if (it == mReversePCIMap.end())
315 return false;
316
317 if (iInstance >= (int)it->second.size())
318 return false;
319
320 Address = it->second[iInstance];
321 return true;
322}
323
324void BusAssignmentManager::State::addMatchingRules(const char* pszName, PCIRulesList& aList)
325{
326 size_t iRuleset, iRule;
327 const DeviceAssignmentRule* aArrays[2] = {aGenericRules, NULL};
328
329 switch (mChipsetType)
330 {
331 case ChipsetType_PIIX3:
332 aArrays[1] = aPiix3Rules;
333 break;
334 case ChipsetType_ICH9:
335 aArrays[1] = aIch9Rules;
336 break;
337 default:
338 Assert(false);
339 break;
340 }
341
342 for (iRuleset = 0; iRuleset < RT_ELEMENTS(aArrays); iRuleset++)
343 {
344 if (aArrays[iRuleset] == NULL)
345 continue;
346
347 for (iRule = 0; aArrays[iRuleset][iRule].pszName != NULL; iRule++)
348 {
349 if (RTStrCmp(pszName, aArrays[iRuleset][iRule].pszName) == 0)
350 aList.push_back(&aArrays[iRuleset][iRule]);
351 }
352 }
353}
354
355const char* BusAssignmentManager::State::findAlias(const char* pszDev)
356{
357 for (size_t iAlias = 0; iAlias < RT_ELEMENTS(aDeviceAliases); iAlias++)
358 {
359 if (strcmp(pszDev, aDeviceAliases[iAlias].pszDevName) == 0)
360 return aDeviceAliases[iAlias].pszDevAlias;
361 }
362 return NULL;
363}
364
365static bool RuleComparator(const DeviceAssignmentRule* r1, const DeviceAssignmentRule* r2)
366{
367 return (r1->iPriority > r2->iPriority);
368}
369
370HRESULT BusAssignmentManager::State::autoAssign(const char* pszName, PCIBusAddress& Address)
371{
372 PCIRulesList matchingRules;
373
374 addMatchingRules(pszName, matchingRules);
375 const char* pszAlias = findAlias(pszName);
376 if (pszAlias)
377 addMatchingRules(pszAlias, matchingRules);
378
379 AssertMsg(matchingRules.size() > 0, ("No rule for %s(%s)\n", pszName, pszAlias));
380
381 stable_sort(matchingRules.begin(), matchingRules.end(), RuleComparator);
382
383 for (size_t iRule = 0; iRule < matchingRules.size(); iRule++)
384 {
385 const DeviceAssignmentRule* rule = matchingRules[iRule];
386
387 Address.miBus = rule->iBus;
388 Address.miDevice = rule->iDevice;
389 Address.miFn = rule->iFn;
390
391 if (checkAvailable(Address))
392 return S_OK;
393 }
394 AssertMsgFailed(("All possible candidate positions for %s exhausted\n", pszName));
395
396 return E_INVALIDARG;
397}
398
399bool BusAssignmentManager::State::checkAvailable(PCIBusAddress& Address)
400{
401 PCIMap::const_iterator it = mPCIMap.find(Address);
402
403 return (it == mPCIMap.end());
404}
405
406void BusAssignmentManager::State::listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached)
407{
408 aAttached.resize(mPCIMap.size());
409
410 size_t i = 0;
411 ComObjPtr<PCIDeviceAttachment> dev;
412 for (PCIMap::const_iterator it = mPCIMap.begin(); it != mPCIMap.end(); ++it, ++i)
413 {
414 dev.createObject();
415 com::Bstr devname(it->second.szDevName);
416 dev->init(NULL, devname,
417 it->second.HostAddress.valid() ? it->second.HostAddress.asLong() : -1,
418 it->first.asLong(), it->second.HostAddress.valid());
419 dev.queryInterfaceTo(aAttached[i].asOutParam());
420 }
421}
422
423BusAssignmentManager::BusAssignmentManager()
424 : pState(NULL)
425{
426 pState = new State();
427 Assert(pState);
428}
429
430BusAssignmentManager::~BusAssignmentManager()
431{
432 if (pState)
433 {
434 delete pState;
435 pState = NULL;
436 }
437}
438
439BusAssignmentManager* BusAssignmentManager::createInstance(ChipsetType_T chipsetType)
440{
441 BusAssignmentManager* pInstance = new BusAssignmentManager();
442 pInstance->pState->init(chipsetType);
443 Assert(pInstance);
444 return pInstance;
445}
446
447void BusAssignmentManager::AddRef()
448{
449 ASMAtomicIncS32(&pState->cRefCnt);
450}
451void BusAssignmentManager::Release()
452{
453 if (ASMAtomicDecS32(&pState->cRefCnt) == 0)
454 delete this;
455}
456
457DECLINLINE(HRESULT) InsertConfigInteger(PCFGMNODE pCfg, const char* pszName, uint64_t u64)
458{
459 int vrc = CFGMR3InsertInteger(pCfg, pszName, u64);
460 if (RT_FAILURE(vrc))
461 return E_INVALIDARG;
462
463 return S_OK;
464}
465
466HRESULT BusAssignmentManager::assignPCIDeviceImpl(const char* pszDevName,
467 PCFGMNODE pCfg,
468 PCIBusAddress& GuestAddress,
469 PCIBusAddress HostAddress,
470 bool fGuestAddressRequired)
471{
472 HRESULT rc = S_OK;
473
474 if (!GuestAddress.valid())
475 rc = pState->autoAssign(pszDevName, GuestAddress);
476 else
477 {
478 bool fAvailable = pState->checkAvailable(GuestAddress);
479
480 if (!fAvailable)
481 {
482 if (fGuestAddressRequired)
483 rc = E_ACCESSDENIED;
484 else
485 rc = pState->autoAssign(pszDevName, GuestAddress);
486 }
487 }
488
489 if (FAILED(rc))
490 return rc;
491
492 Assert(GuestAddress.valid() && pState->checkAvailable(GuestAddress));
493
494 rc = pState->record(pszDevName, GuestAddress, HostAddress);
495 if (FAILED(rc))
496 return rc;
497
498 rc = InsertConfigInteger(pCfg, "PCIBusNo", GuestAddress.miBus);
499 if (FAILED(rc))
500 return rc;
501 rc = InsertConfigInteger(pCfg, "PCIDeviceNo", GuestAddress.miDevice);
502 if (FAILED(rc))
503 return rc;
504 rc = InsertConfigInteger(pCfg, "PCIFunctionNo", GuestAddress.miFn);
505 if (FAILED(rc))
506 return rc;
507
508 return S_OK;
509}
510
511
512bool BusAssignmentManager::findPCIAddress(const char* pszDevName, int iInstance, PCIBusAddress& Address)
513{
514 return pState->findPCIAddress(pszDevName, iInstance, Address);
515}
516void BusAssignmentManager::listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached)
517{
518 pState->listAttachedPCIDevices(aAttached);
519}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette