1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
# Legal, Licensing, and Third-Party Material
> What is licensed how, what we may redistribute, and how we stay clean while
> doing adversarial interoperability.
>
> The complete component and license inventory is the SBOM:
> [`../../SBOM.md`](../../SBOM.md) (machine-readable:
> [`../../sbom/open-iov-0.1.0.cdx.json`](../../sbom/open-iov-0.1.0.cdx.json)).
## 1. The project's licenses
| Component | License | Rationale |
|---|---|---|
| `kernel/**` (e.g. `open-iov-vfio.ko`) | **GPL-2.0** (`MODULE_LICENSE("GPL v2")`) | The Linux kernel exports the interfaces we need (VFIO, mdev, IOMMU, DMA) under `EXPORT_SYMBOL_GPL`. GPL-2.0 is the legally correct choice. |
| `userspace/**`, `tools/**`, `scripts/**`, `config/**`, `docs/**` | **BSD-3-Clause** | Maximizes reuse and adoption — the project's mission. |
| Third-party submodules and imported trees | their own licenses | Not relicensed; used under their terms. |
Per-file `SPDX-License-Identifier` headers always govern.
The split is deliberate: the kernel side gets a clean legal footing; everything
vendor-facing, embeddable and reusable stays permissive. Commercial adoption is
welcome and requires no license fee.
## 2. How we learn the interfaces
Open-IOV is built by **reverse engineering and decompilation**: we study the
behaviour of vendor drivers and firmware — in VMs, on hardware, and by
disassembling published firmware images and analysed binaries — and we
reimplement the interfaces we discover. What this project publishes is our
own work: behaviour descriptions, numeric identifiers, layouts, emulation
code, and the evidence behind each observation.
In this repository you will find:
* **GSP firmware images** (`firmware/**/*.fwimage.bin`) — fetched from public
distribution channels (e.g. `linux-firmware`); used to understand and
emulate the firmware interface. They are **not distributed in this
repository**: like all firmware blobs they are gitignored and kept only as
local study material.
* **Decompiled/disassembled artifacts** (`firmware/**/decompiled/`) — our own
analysis output, kept locally for study and cited in the wiki. They are
gitignored and never committed.
* **Reformatted interface tables** — IDs, structures and message layouts that
we derived, published in `wiki/` and in this documentation tree.
**Our rule:** publish *our work product* (facts, layouts, behaviours, code and
evidence). Do not copy third-party source or documentation into this project,
do not point readers at material we cannot redistribute, and do not
redistribute third-party binaries as project content beyond what their terms
allow.
**CUDA-userspace (`libcuda`) analysis rules:**
* Decompiled or disassembled output is never committed; it is gitignored study
material.
* Cite userspace locations as `libcuda+0x...` *file virtual addresses*. Note
the Ghidra image-base caveat: that library is loaded at **`0x100000`**, so a
decompilation produced without translating the offset refers to the wrong
function.
* Tracked docs state facts and evidence; conclusions cite numeric IDs, code
offsets and recorded observations, never source locations.
* Name maps and indexes (`userspace/cuda/*/annotations/`) are our own work
product and may be tracked.
## 3. Adversarial interoperability and the law
We implement the *interface contract* so that unmodified NVIDIA software can
talk to our device. We do not:
* copy NVIDIA driver code into our kernel module,
* patch the guest, runtime or host driver at run time. The only patch series
we carry is build glue for the optional OpenRM submodule (`install.sh`); the
deployment path uses the distribution's NVIDIA driver as shipped,
* defeat licensing for NVIDIA's own products (our device is our device; no
impersonation of a licensed product identity).
Where interoperability requires knowledge of structures and constants, we
obtain them from publicly distributed headers and from observation of the
unmodified guest in a lab, and we document the evidence. This is the same
discipline used by other interoperable implementations of closed interfaces.
If you believe a specific artifact in this repository is improperly included,
open an issue: we would rather over-comply than argue.
## 4. Contributions
* Inbound = outbound: contributions to BSD-3-Clause files are BSD-3-Clause;
contributions to GPL-2.0 files are GPL-2.0.
* By contributing you confirm you have the right to do so and that the
contribution does not contain third-party material under incompatible terms.
* Write original code. Describe behaviour, cite the evidence, and reimplement
interfaces from observation rather than copying anyone's source.
* Do not commit firmware or ISO images: they are local study/deployment
material and are gitignored (see §2).
## 5. Export, safety and platform notes
* GPU firmware and drivers may be subject to export regulations in your
jurisdiction; users are responsible for compliance.
* Security-sensitive deployments should follow the security evaluation doc and
the platform's attestation mechanisms (e.g. TrenchBoot).
* Nothing in this project's licensing changes the licenses of the host
distribution's NVIDIA driver, the guest's driver, or any hypervisor.
|
