hybrid: the GPU driver now runs in userspace
docs/plan/hybrid.md's first eviction. cmd/vgpud is the virtio-gpu driver as a
process: it finds the device by vendor and device id, asks the kernel for it,
and does the whole virtio 1.0 bring-up from outside -- reset, feature
negotiation, a virtqueue in DMA memory, GET_DISPLAY_INFO, RESOURCE_CREATE_2D,
ATTACH_BACKING, SET_SCANOUT, TRANSFER and FLUSH.
vgpud: virtio-gpu at 00:03.0, currently held by virtio-gpu
virtio-gpu: released to userspace; screen is the VBE framebuffer
vgpud: claimed
vgpud: display is 1280x800
vgpud: scanout is ours, framebuffer at physical 0x3eceb000
vgpud: drew a test pattern from userspace
Verified by screendumping the virtio-gpu head: the pattern is there, with a
checkerboard that would shear if the stride were wrong. The console carries on
in VBE on the other head at the same time, which is the fallback rule from the
plan working rather than being described.
No syscall knows this is a GPU. The kernel handed over a PCI device and the
process decided what it was -- which is the property that makes this a general
mechanism, and the reason the evictions come before anything foreign.
Four things the first real driver needed that the test program had not:
- PCI config space (PCIIOC_CFG). A virtio device says where its registers
are in vendor capabilities, which live in config space, so a driver that
cannot read it cannot find its own registers.
- a way for the incumbent to let go: struct pci_driver gained a release
hook. A driver without one keeps its device, which is always safe and for
anything on the path to a shell is also correct.
- the outgoing driver freeing its DMA. Releasing the device but keeping its
4 MB framebuffer is half a handover -- the incoming driver asks for one and
is told there is no room.
- a 16 MB DMA arena. 4 MB was exactly one framebuffer at this resolution,
and either side of a handover there are two.
And one bug it reproduced on its first working run: vgpud polls the used ring,
so it registered no interrupt handler, and a virtio device interrupts on every
completion. The storm detector said so immediately --
irq 11: 77780 interrupts/second -- a device on this line is not
acknowledging it. handler 'e1000' is attached
-- naming the line, the rate and the neighbour it was drowning. One line fixes
it (VRING_AVAIL_F_NO_INTERRUPT before the queue is enabled), and that detector
was worth every minute it cost.
include/virtio.h moved out of the driver directory. Its own comment said it
should when a second reader appeared; one has.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VQ7Qx8E1q1M1bbCq8QLHS2
This commit is contained in:
Nexoniarz
parent
72074a960e
commit
ea68ef4b54
12 changed files with 799 additions and 9 deletions
|
|
@ -214,3 +214,31 @@ const struct display_ops vga_display_ops = {
|
|||
.present = vga_disp_present,
|
||||
.wait_vblank = vga_disp_wait_vblank,
|
||||
};
|
||||
|
||||
// Put the VBE framebuffer back on screen.
|
||||
//
|
||||
// Called when a better display driver lets go of the hardware -- see
|
||||
// virtio-gpu's release hook. gfx holds one scanout, last writer wins, so the
|
||||
// driver that leaves has to name its replacement rather than simply detaching;
|
||||
// detaching alone leaves gfx pointing at a device nobody is driving.
|
||||
//
|
||||
// This is the fallback rule from docs/plan/hybrid.md made real: the kernel
|
||||
// keeps a minimal driver for everything on the path to a shell, so a fancy
|
||||
// driver leaving degrades to a working screen instead of to no screen.
|
||||
void
|
||||
vga_fb_restore(void)
|
||||
{
|
||||
struct fb_info info;
|
||||
|
||||
if (!fb || !fb_width || !fb_height)
|
||||
return; // nothing was ever set up; nothing to go back to
|
||||
|
||||
info.ptr = fb;
|
||||
info.phys = fb_phys;
|
||||
info.size = vga_fb_size();
|
||||
info.stride = fb_stride;
|
||||
info.bpp = fb_bpp;
|
||||
info.width = fb_width;
|
||||
info.height = fb_height;
|
||||
gfx_attach_scanout(&info);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,180 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
// virtio 1.0 over PCI — the transport, and virtio-gpu's 2D protocol.
|
||||
//
|
||||
// Next to the driver rather than in include/, because exactly one driver reads
|
||||
// it. When a second virtio device arrives -- virtio-net and virtio-blk are the
|
||||
// obvious ones -- the *transport* half of this belongs in a shared place and
|
||||
// the 2D protocol stays here; splitting it before there is a second caller
|
||||
// would be guessing at where the seam goes.
|
||||
//
|
||||
// Written from the OASIS specification (virtio 1.1, chapters 2, 4.1 and 5.7),
|
||||
// which is a public document with no licence on what you write from it. Same
|
||||
// reasoning as kernel/drivers/xhci.c.
|
||||
//
|
||||
// Why virtio-gpu at all, when there is already a framebuffer: the VBE
|
||||
// framebuffer is a flat block of memory the loader happened to be told about.
|
||||
// It has no mode setting, no notion of a frame being complete, and no way to
|
||||
// ask the host to present anything -- so a compositor drawing into it is
|
||||
// racing the scanout with no way to synchronise. virtio-gpu has resources,
|
||||
// explicit transfer and an explicit flush, which is the model every real GPU
|
||||
// driver has. It is the smallest device that teaches the right shape.
|
||||
|
||||
// --- PCI transport ---------------------------------------------------------
|
||||
|
||||
#define VIRTIO_VENDOR 0x1AF4
|
||||
// Modern (1.0) device IDs are 0x1040 + the virtio device type. GPU is type 16.
|
||||
#define VIRTIO_DEV_GPU 0x1050
|
||||
|
||||
// Vendor-specific PCI capability, which is how a virtio device says where in
|
||||
// its BARs each configuration structure lives.
|
||||
#define PCI_CAP_ID_VNDR 0x09
|
||||
|
||||
#define VIRTIO_PCI_CAP_COMMON_CFG 1
|
||||
#define VIRTIO_PCI_CAP_NOTIFY_CFG 2
|
||||
#define VIRTIO_PCI_CAP_ISR_CFG 3
|
||||
#define VIRTIO_PCI_CAP_DEVICE_CFG 4
|
||||
|
||||
// Offsets within the common configuration structure. Written out rather than
|
||||
// declared as a struct: the fields are little-endian by specification and of
|
||||
// mixed width, and a struct invites the compiler to pad or a caller to forget
|
||||
// that these are MMIO and must be accessed at exactly the stated width.
|
||||
#define VCOMMON_DFEAT_SEL 0x00 // le32
|
||||
#define VCOMMON_DFEAT 0x04 // le32
|
||||
#define VCOMMON_GFEAT_SEL 0x08 // le32
|
||||
#define VCOMMON_GFEAT 0x0C // le32
|
||||
#define VCOMMON_MSIX_CFG 0x10 // le16
|
||||
#define VCOMMON_NUM_QUEUES 0x12 // le16
|
||||
#define VCOMMON_STATUS 0x14 // u8
|
||||
#define VCOMMON_CFG_GEN 0x15 // u8
|
||||
#define VCOMMON_Q_SELECT 0x16 // le16
|
||||
#define VCOMMON_Q_SIZE 0x18 // le16
|
||||
#define VCOMMON_Q_MSIX 0x1A // le16
|
||||
#define VCOMMON_Q_ENABLE 0x1C // le16
|
||||
#define VCOMMON_Q_NOTIFY_OFF 0x1E // le16
|
||||
#define VCOMMON_Q_DESC 0x20 // le64
|
||||
#define VCOMMON_Q_DRIVER 0x28 // le64
|
||||
#define VCOMMON_Q_DEVICE 0x30 // le64
|
||||
|
||||
// device_status bits, set in this order during bring-up.
|
||||
#define VSTATUS_ACK 1
|
||||
#define VSTATUS_DRIVER 2
|
||||
#define VSTATUS_DRIVER_OK 4
|
||||
#define VSTATUS_FEATURES_OK 8
|
||||
#define VSTATUS_FAILED 0x80
|
||||
|
||||
#define VIRTIO_F_VERSION_1 32 // feature bit: this is a 1.0 device
|
||||
|
||||
// --- split virtqueue -------------------------------------------------------
|
||||
|
||||
#define VRING_DESC_F_NEXT 1
|
||||
#define VRING_DESC_F_WRITE 2 // device writes it; i.e. this is our buffer
|
||||
|
||||
struct vring_desc {
|
||||
uint64 addr;
|
||||
uint32 len;
|
||||
uint16 flags;
|
||||
uint16 next;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_avail {
|
||||
uint16 flags;
|
||||
uint16 idx;
|
||||
uint16 ring[];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_used_elem {
|
||||
uint32 id;
|
||||
uint32 len;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct vring_used {
|
||||
uint16 flags;
|
||||
uint16 idx;
|
||||
struct vring_used_elem ring[];
|
||||
} __attribute__((packed));
|
||||
|
||||
// --- virtio-gpu, 2D --------------------------------------------------------
|
||||
|
||||
#define VIRTIO_GPU_CMD_GET_DISPLAY_INFO 0x0100
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_CREATE_2D 0x0101
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_UNREF 0x0102
|
||||
#define VIRTIO_GPU_CMD_SET_SCANOUT 0x0103
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_FLUSH 0x0104
|
||||
#define VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D 0x0105
|
||||
#define VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING 0x0106
|
||||
|
||||
#define VIRTIO_GPU_RESP_OK_NODATA 0x1100
|
||||
#define VIRTIO_GPU_RESP_OK_DISPLAY_INFO 0x1101
|
||||
|
||||
#define VIRTIO_GPU_MAX_SCANOUTS 16
|
||||
|
||||
// B8G8R8X8, which is what a 32-bit little-endian 0x00RRGGBB word looks like in
|
||||
// memory -- the same layout vga.c already draws into, so a framebuffer can be
|
||||
// handed over without a conversion pass.
|
||||
#define VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM 2
|
||||
|
||||
struct virtio_gpu_ctrl_hdr {
|
||||
uint32 type;
|
||||
uint32 flags;
|
||||
uint64 fence_id;
|
||||
uint32 ctx_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_rect {
|
||||
uint32 x, y, width, height;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_display_one {
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 enabled;
|
||||
uint32 flags;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resp_display_info {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_display_one pmodes[VIRTIO_GPU_MAX_SCANOUTS];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_create_2d {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
uint32 resource_id;
|
||||
uint32 format;
|
||||
uint32 width;
|
||||
uint32 height;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_mem_entry {
|
||||
uint64 addr;
|
||||
uint32 length;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_attach_backing {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
uint32 resource_id;
|
||||
uint32 nr_entries;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_set_scanout {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 scanout_id;
|
||||
uint32 resource_id;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_transfer_to_host_2d {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint64 offset;
|
||||
uint32 resource_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct virtio_gpu_resource_flush {
|
||||
struct virtio_gpu_ctrl_hdr hdr;
|
||||
struct virtio_gpu_rect r;
|
||||
uint32 resource_id;
|
||||
uint32 padding;
|
||||
} __attribute__((packed));
|
||||
|
|
@ -58,6 +58,7 @@ struct vgpu {
|
|||
// command queue with one entry is not the bottleneck in a 2D compositor.
|
||||
void *cmd;
|
||||
void *resp;
|
||||
void *ring; // the three vrings, one block, for dma_free
|
||||
|
||||
int width, height;
|
||||
void *fb; // the framebuffer we scan out from
|
||||
|
|
@ -179,6 +180,7 @@ queue_setup(struct vgpu *g)
|
|||
uint32 used_sz = 6 + 8 * qsize;
|
||||
|
||||
uint8 *mem = dma_alloc(4096 * 3, 4096);
|
||||
g->ring = mem;
|
||||
if (!mem)
|
||||
return -1;
|
||||
memset(mem, 0, 4096 * 3);
|
||||
|
|
@ -510,6 +512,62 @@ vgpu_probe(struct pci_dev *d)
|
|||
return 0;
|
||||
}
|
||||
|
||||
// Hand the device to a userspace driver.
|
||||
//
|
||||
// docs/plan/hybrid.md's first eviction, and the reason it is this device: the
|
||||
// boundary already exists (struct display_ops), it has exactly one consumer,
|
||||
// and there is a working fallback underneath. So letting go is safe in a way
|
||||
// it would not be for the disk the root filesystem is on.
|
||||
//
|
||||
// What "letting go" has to mean, in order:
|
||||
//
|
||||
// 1. stop drawing -- put the VBE framebuffer back on screen *first*, so
|
||||
// there is never a moment where gfx points at hardware nobody drives
|
||||
// 2. reset the device, so the next driver starts from a known state rather
|
||||
// than inheriting a configured queue it did not set up
|
||||
// 3. forget the instance, so a later probe or a second claim cannot find
|
||||
// half-initialised state
|
||||
static int
|
||||
vgpu_release(struct pci_dev *d)
|
||||
{
|
||||
struct vgpu *g = 0;
|
||||
|
||||
for (int i = 0; i < VGPU_MAX; i++)
|
||||
if (gpus[i].ready && gpus[i].pdev == d) { g = &gpus[i]; break; }
|
||||
if (!g)
|
||||
return -1;
|
||||
|
||||
vga_fb_restore();
|
||||
|
||||
// Status 0 is the virtio reset. The spec requires a driver to wait for the
|
||||
// device to acknowledge by reading the register back as zero.
|
||||
if (g->common) {
|
||||
w8(g->common, VCOMMON_STATUS, 0);
|
||||
for (int spin = 0; spin < 1000000 && r8(g->common, VCOMMON_STATUS); spin++)
|
||||
;
|
||||
}
|
||||
|
||||
if (g->isr)
|
||||
irq_unregister(d->irq, vgpu_intr, g);
|
||||
|
||||
// Give the arena its memory back.
|
||||
//
|
||||
// Releasing the *device* without releasing its memory is half a handover:
|
||||
// the DMA arena is 16 MB and contiguous, a framebuffer at this resolution is
|
||||
// 4 MB of it, and the process taking over needs one of its own. Keeping ours
|
||||
// means the new driver asks for a framebuffer and is told there is no room,
|
||||
// which is what happened the first time this was tried.
|
||||
if (g->fb) { dma_free(g->fb, g->fb_bytes); g->fb = 0; }
|
||||
if (g->ring) { dma_free(g->ring, 4096 * 3); g->ring = 0; }
|
||||
if (g->cmd) { dma_free(g->cmd, 4096); g->cmd = 0; }
|
||||
if (g->resp) { dma_free(g->resp, 4096); g->resp = 0; }
|
||||
|
||||
g->ready = 0;
|
||||
g->pdev = 0;
|
||||
cprintf("virtio-gpu: released to userspace; screen is the VBE framebuffer\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct pci_match virtio_gpu_match[] = {
|
||||
{ VIRTIO_VENDOR, VIRTIO_DEV_GPU, 0, 0 },
|
||||
{ 0, 0, 0, 0 },
|
||||
|
|
@ -534,4 +592,5 @@ const struct pci_driver virtio_gpu_driver = {
|
|||
.ops = &virtio_gpu_display_ops,
|
||||
.probe = vgpu_probe,
|
||||
.attached = vgpu_attached,
|
||||
.release = vgpu_release,
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in a new issue