Make lguest_launcher.h types userspace-friendly
[linux-2.6.git] / include / linux / lguest_launcher.h
1 #ifndef _ASM_LGUEST_USER
2 #define _ASM_LGUEST_USER
3 /* Everything the "lguest" userspace program needs to know. */
4 #include <linux/types.h>
5 /* They can register up to 32 arrays of lguest_dma. */
6 #define LGUEST_MAX_DMA          32
7 /* At most we can dma 16 lguest_dma in one op. */
8 #define LGUEST_MAX_DMA_SECTIONS 16
9
10 /* How many devices?  Assume each one wants up to two dma arrays per device. */
11 #define LGUEST_MAX_DEVICES (LGUEST_MAX_DMA/2)
12
13 /*D:200
14  * Lguest I/O
15  *
16  * The lguest I/O mechanism is the only way Guests can talk to devices.  There
17  * are two hypercalls involved: SEND_DMA for output and BIND_DMA for input.  In
18  * each case, "struct lguest_dma" describes the buffer: this contains 16
19  * addr/len pairs, and if there are fewer buffer elements the len array is
20  * terminated with a 0.
21  *
22  * I/O is organized by keys: BIND_DMA attaches buffers to a particular key, and
23  * SEND_DMA transfers to buffers bound to particular key.  By convention, keys
24  * correspond to a physical address within the device's page.  This means that
25  * devices will never accidentally end up with the same keys, and allows the
26  * Host use The Futex Trick (as we'll see later in our journey).
27  *
28  * SEND_DMA simply indicates a key to send to, and the physical address of the
29  * "struct lguest_dma" to send.  The Host will write the number of bytes
30  * transferred into the "struct lguest_dma"'s used_len member.
31  *
32  * BIND_DMA indicates a key to bind to, a pointer to an array of "struct
33  * lguest_dma"s ready for receiving, the size of that array, and an interrupt
34  * to trigger when data is received.  The Host will only allow transfers into
35  * buffers with a used_len of zero: it then sets used_len to the number of
36  * bytes transferred and triggers the interrupt for the Guest to process the
37  * new input. */
38 struct lguest_dma
39 {
40         /* 0 if free to be used, filled by the Host. */
41         __u32 used_len;
42         __u16 len[LGUEST_MAX_DMA_SECTIONS];
43         unsigned long addr[LGUEST_MAX_DMA_SECTIONS];
44 };
45 /*:*/
46
47 /*D:460 This is the layout of a block device memory page.  The Launcher sets up
48  * the num_sectors initially to tell the Guest the size of the disk.  The Guest
49  * puts the type, sector and length of the request in the first three fields,
50  * then DMAs to the Host.  The Host processes the request, sets up the result,
51  * then DMAs back to the Guest. */
52 struct lguest_block_page
53 {
54         /* 0 is a read, 1 is a write. */
55         int type;
56         __u32 sector;   /* Offset in device = sector * 512. */
57         __u32 bytes;    /* Length expected to be read/written in bytes */
58         /* 0 = pending, 1 = done, 2 = done, error */
59         int result;
60         __u32 num_sectors; /* Disk length = num_sectors * 512 */
61 };
62
63 /*D:520 The network device is basically a memory page where all the Guests on
64  * the network publish their MAC (ethernet) addresses: it's an array of "struct
65  * lguest_net": */
66 struct lguest_net
67 {
68         /* Simply the mac address (with multicast bit meaning promisc). */
69         unsigned char mac[6];
70 };
71 /*:*/
72
73 /* Where the Host expects the Guest to SEND_DMA console output to. */
74 #define LGUEST_CONSOLE_DMA_KEY 0
75
76 /*D:010
77  * Drivers
78  *
79  * The Guest needs devices to do anything useful.  Since we don't let it touch
80  * real devices (think of the damage it could do!) we provide virtual devices.
81  * We could emulate a PCI bus with various devices on it, but that is a fairly
82  * complex burden for the Host and suboptimal for the Guest, so we have our own
83  * "lguest" bus and simple drivers.
84  *
85  * Devices are described by an array of LGUEST_MAX_DEVICES of these structs,
86  * placed by the Launcher just above the top of physical memory:
87  */
88 struct lguest_device_desc {
89         /* The device type: console, network, disk etc. */
90         __u16 type;
91 #define LGUEST_DEVICE_T_CONSOLE 1
92 #define LGUEST_DEVICE_T_NET     2
93 #define LGUEST_DEVICE_T_BLOCK   3
94
95         /* The specific features of this device: these depends on device type
96          * except for LGUEST_DEVICE_F_RANDOMNESS. */
97         __u16 features;
98 #define LGUEST_NET_F_NOCSUM             0x4000 /* Don't bother checksumming */
99 #define LGUEST_DEVICE_F_RANDOMNESS      0x8000 /* IRQ is fairly random */
100
101         /* This is how the Guest reports status of the device: the Host can set
102          * LGUEST_DEVICE_S_REMOVED to indicate removal, but the rest are only
103          * ever manipulated by the Guest, and only ever set. */
104         __u16 status;
105 /* 256 and above are device specific. */
106 #define LGUEST_DEVICE_S_ACKNOWLEDGE     1 /* We have seen device. */
107 #define LGUEST_DEVICE_S_DRIVER          2 /* We have found a driver */
108 #define LGUEST_DEVICE_S_DRIVER_OK       4 /* Driver says OK! */
109 #define LGUEST_DEVICE_S_REMOVED         8 /* Device has gone away. */
110 #define LGUEST_DEVICE_S_REMOVED_ACK     16 /* Driver has been told. */
111 #define LGUEST_DEVICE_S_FAILED          128 /* Something actually failed */
112
113         /* Each device exists somewhere in Guest physical memory, over some
114          * number of pages. */
115         __u16 num_pages;
116         __u32 pfn;
117 };
118 /*:*/
119
120 /* Write command first word is a request. */
121 enum lguest_req
122 {
123         LHREQ_INITIALIZE, /* + pfnlimit, pgdir, start, pageoffset */
124         LHREQ_GETDMA, /* + addr (returns &lguest_dma, irq in ->used_len) */
125         LHREQ_IRQ, /* + irq */
126         LHREQ_BREAK, /* + on/off flag (on blocks until someone does off) */
127 };
128 #endif /* _ASM_LGUEST_USER */