System configuration: the SMBIOS tables
A PC keeps a written description of itself in firmware, in a set of tables defined by an industry specification called SMBIOS and still read, by most of the tools that open them, under the older name DMI. The tables say who made the system, which model it is, what serial the unit carries, which identifier belongs to it, which firmware it runs and when that firmware was released. The maker writes them when the PC is built, the operating system reads them at start, and installed programs ask for them whenever they want to know what they are running on.
What the tables say
The description is a list of entries, one for each part of the PC. One names the firmware: its maker, its version string and the date that version was released. One names the system as a whole: the maker, the product name of the model, a serial for the unit and an identifier meant to be unique to it. One names the main board. One describes the enclosure — a tower, a small desktop, a portable. A company that assembles finished systems fills these in at the factory, and the entries agree with one another: the same company in the system entry and the board entry, a firmware version that company shipped for that model, an enclosure that fits the kind of system the model is. A PC built from parts reads differently and hides nothing by it — the board entry is filled in properly, while the system entry keeps the placeholder the board firmware came with, because nobody sold the finished system as a product.
How websites see it
No web page reads these tables. A browser offers no interface that returns the maker, the model, the serial or the system identifier, and that is deliberate: those fields would name a visitor's PC exactly and keep naming it for the life of the system. What a page sees is what the configuration produced. The browser names the operating system and the platform it runs on; a script that asks for the more detailed hints can learn the processor architecture and, on some platforms, a model name; the graphics interfaces often reveal which adapter and which driver are answering; the count of logical processors is there for the asking, and so is a rounded figure for memory where a browser publishes one. None of that is the configuration, but all of it descends from it, and a profiling script judges the combination: a graphics adapter never sold with the kind of system the other signals imply, a processor count that does not fit the model they suggest. Since the fields themselves cannot be read here, this part of the identity is judged entirely by whether it agrees with the rest.
How installed software sees it
Programs on the system are not limited to what a browser is willing to say. The operating system parses the tables at start and offers them through an interface of its own, so a program can ask for the whole description at once. Reading it calls for no special access to the hardware, though systems differ over the identifying fields: some hand the serial and the identifier to any program that asks, others keep them behind an administrative check. What makes the answer valuable is that it is stable and broad. It sits in firmware, so it outlives the operating system being replaced and the drive being swapped, and a single read covers the whole system — which is why launchers, update components and the security components of online services reach for it when they decide whether they are running on a PC that somebody built.
Why it matters for a virtual machine
A virtual machine has no factory, and no firmware written at one. Its firmware is a program, and the tables that program publishes describe the program: the maker entry names the virtualization product, the model is a stock name shared by every virtual system that product starts, the board entry names the same product again, and the firmware version and date belong to a build of the virtual firmware rather than to anything shipped for a model. The serial is often empty. The identifier is generated when the virtual machine is created and kept in its configuration, so it describes a configuration rather than a system somebody built. Everything inside sees that description, because it is the only one there is, and for a program examining its surroundings it is the shortest path to a verdict: one read, no ambiguity, a maker that sells no PCs. This is why the configuration belongs to the hardware identity the environment in this tour presents as a whole — a maker, a model, a firmware and a board that exist, that fit each other, and that fit the display, the processor and the adapters the same system reports.
What this stop of the tour shows
In this scene the camera moves inside the case and the tables open beside the main board as a readable card: the firmware entry, the system entry, the board entry, the enclosure. The values are a rendering of what a PC built by a maker would report, drawn on the page rather than painted into the video, so they stay legible in every language and can be read with the animation turned off. The next stop is the security chip, which answers a narrower set of questions and signs its answers.
| Field | What it says |
|---|---|
| Manufacturer | The company that assembled the system and sold it as a product. A PC built from parts usually leaves a placeholder here; a virtual machine names the virtualization product. |
| Product name | The model name of the system as its maker sells it. Inside a virtual machine it is a stock name, the same for every system that product starts. |
| System identifier | An identifier meant to be unique to this system, kept in firmware, so it outlives the operating system being replaced. The specification lets a system report that it has none. |
| Serial | The serial of the unit, written by the maker. Some operating systems keep this field behind an administrative check, and a virtual machine commonly leaves it empty. |
| Firmware version and date | The version string of the firmware and the date it was released. Read together with the model, they say whether this firmware was ever shipped for this system. |
| Baseboard | The maker, model and serial of the main board. On a finished product it names the same company as the system entry; on a PC built from parts it names the board maker. |