include/xen/interface/event_channel.h

   1 /******************************************************************************
   2  * event_channel.h
   3  *
   4  * Event channels between domains.
   5  *
   6  * Copyright (c) 2003-2004, K A Fraser.
   7  */
   8
   9 #ifndef __XEN_PUBLIC_EVENT_CHANNEL_H__
  10 #define __XEN_PUBLIC_EVENT_CHANNEL_H__
  11
  12 typedef uint32_t evtchn_port_t;
  13 DEFINE_GUEST_HANDLE(evtchn_port_t);
  14
  15 /*
  16  * EVTCHNOP_alloc_unbound: Allocate a port in domain <dom> and mark as
  17  * accepting interdomain bindings from domain <remote_dom>. A fresh port
  18  * is allocated in <dom> and returned as <port>.
  19  * NOTES:
  20  *  1. If the caller is unprivileged then <dom> must be DOMID_SELF.
  21  *  2. <rdom> may be DOMID_SELF, allowing loopback connections.
  22  */
  23 #define EVTCHNOP_alloc_unbound    6
  24 struct evtchn_alloc_unbound {
  25         /* IN parameters */
  26         domid_t dom, remote_dom;
  27         /* OUT parameters */
  28         evtchn_port_t port;
  29 };
  30
  31 /*
  32  * EVTCHNOP_bind_interdomain: Construct an interdomain event channel between
  33  * the calling domain and <remote_dom>. <remote_dom,remote_port> must identify
  34  * a port that is unbound and marked as accepting bindings from the calling
  35  * domain. A fresh port is allocated in the calling domain and returned as
  36  * <local_port>.
  37  * NOTES:
  38  *  2. <remote_dom> may be DOMID_SELF, allowing loopback connections.
  39  */
  40 #define EVTCHNOP_bind_interdomain 0
  41 struct evtchn_bind_interdomain {
  42         /* IN parameters. */
  43         domid_t remote_dom;
  44         evtchn_port_t remote_port;
  45         /* OUT parameters. */
  46         evtchn_port_t local_port;
  47 };
  48
  49 /*
  50  * EVTCHNOP_bind_virq: Bind a local event channel to VIRQ <irq> on specified
  51  * vcpu.
  52  * NOTES:
  53  *  1. A virtual IRQ may be bound to at most one event channel per vcpu.
  54  *  2. The allocated event channel is bound to the specified vcpu. The binding
  55  *     may not be changed.
  56  */
  57 #define EVTCHNOP_bind_virq        1
  58 struct evtchn_bind_virq {
  59         /* IN parameters. */
  60         uint32_t virq;
  61         uint32_t vcpu;
  62         /* OUT parameters. */
  63         evtchn_port_t port;
  64 };
  65
  66 /*
  67  * EVTCHNOP_bind_pirq: Bind a local event channel to PIRQ <irq>.
  68  * NOTES:
  69  *  1. A physical IRQ may be bound to at most one event channel per domain.
  70  *  2. Only a sufficiently-privileged domain may bind to a physical IRQ.
  71  */
  72 #define EVTCHNOP_bind_pirq        2
  73 struct evtchn_bind_pirq {
  74         /* IN parameters. */
  75         uint32_t pirq;
  76 #define BIND_PIRQ__WILL_SHARE 1
  77         uint32_t flags; /* BIND_PIRQ__* */
  78         /* OUT parameters. */
  79         evtchn_port_t port;
  80 };
  81
  82 /*
  83  * EVTCHNOP_bind_ipi: Bind a local event channel to receive events.
  84  * NOTES:
  85  *  1. The allocated event channel is bound to the specified vcpu. The binding
  86  *     may not be changed.
  87  */
  88 #define EVTCHNOP_bind_ipi         7
  89 struct evtchn_bind_ipi {
  90         uint32_t vcpu;
  91         /* OUT parameters. */
  92         evtchn_port_t port;
  93 };
  94
  95 /*
  96  * EVTCHNOP_close: Close a local event channel <port>. If the channel is
  97  * interdomain then the remote end is placed in the unbound state
  98  * (EVTCHNSTAT_unbound), awaiting a new connection.
  99  */
 100 #define EVTCHNOP_close            3
 101 struct evtchn_close {
 102         /* IN parameters. */
 103         evtchn_port_t port;
 104 };
 105
 106 /*
 107  * EVTCHNOP_send: Send an event to the remote end of the channel whose local
 108  * endpoint is <port>.
 109  */
 110 #define EVTCHNOP_send             4
 111 struct evtchn_send {
 112         /* IN parameters. */
 113         evtchn_port_t port;
 114 };
 115
 116 /*
 117  * EVTCHNOP_status: Get the current status of the communication channel which
 118  * has an endpoint at <dom, port>.
 119  * NOTES:
 120  *  1. <dom> may be specified as DOMID_SELF.
 121  *  2. Only a sufficiently-privileged domain may obtain the status of an event
 122  *     channel for which <dom> is not DOMID_SELF.
 123  */
 124 #define EVTCHNOP_status           5
 125 struct evtchn_status {
 126         /* IN parameters */
 127         domid_t  dom;
 128         evtchn_port_t port;
 129         /* OUT parameters */
 130 #define EVTCHNSTAT_closed       0  /* Channel is not in use.                 */
 131 #define EVTCHNSTAT_unbound      1  /* Channel is waiting interdom connection.*/
 132 #define EVTCHNSTAT_interdomain  2  /* Channel is connected to remote domain. */
 133 #define EVTCHNSTAT_pirq         3  /* Channel is bound to a phys IRQ line.   */
 134 #define EVTCHNSTAT_virq         4  /* Channel is bound to a virtual IRQ line */
 135 #define EVTCHNSTAT_ipi          5  /* Channel is bound to a virtual IPI line */
 136         uint32_t status;
 137         uint32_t vcpu;             /* VCPU to which this channel is bound.   */
 138         union {
 139                 struct {
 140                         domid_t dom;
 141                 } unbound; /* EVTCHNSTAT_unbound */
 142                 struct {
 143                         domid_t dom;
 144                         evtchn_port_t port;
 145                 } interdomain; /* EVTCHNSTAT_interdomain */
 146                 uint32_t pirq;      /* EVTCHNSTAT_pirq        */
 147                 uint32_t virq;      /* EVTCHNSTAT_virq        */
 148         } u;
 149 };
 150
 151 /*
 152  * EVTCHNOP_bind_vcpu: Specify which vcpu a channel should notify when an
 153  * event is pending.
 154  * NOTES:
 155  *  1. IPI- and VIRQ-bound channels always notify the vcpu that initialised
 156  *     the binding. This binding cannot be changed.
 157  *  2. All other channels notify vcpu0 by default. This default is set when
 158  *     the channel is allocated (a port that is freed and subsequently reused
 159  *     has its binding reset to vcpu0).
 160  */
 161 #define EVTCHNOP_bind_vcpu        8
 162 struct evtchn_bind_vcpu {
 163         /* IN parameters. */
 164         evtchn_port_t port;
 165         uint32_t vcpu;
 166 };
 167
 168 /*
 169  * EVTCHNOP_unmask: Unmask the specified local event-channel port and deliver
 170  * a notification to the appropriate VCPU if an event is pending.
 171  */
 172 #define EVTCHNOP_unmask           9
 173 struct evtchn_unmask {
 174         /* IN parameters. */
 175         evtchn_port_t port;
 176 };
 177
 178 struct evtchn_op {
 179         uint32_t cmd; /* EVTCHNOP_* */
 180         union {
 181                 struct evtchn_alloc_unbound    alloc_unbound;
 182                 struct evtchn_bind_interdomain bind_interdomain;
 183                 struct evtchn_bind_virq        bind_virq;
 184                 struct evtchn_bind_pirq        bind_pirq;
 185                 struct evtchn_bind_ipi         bind_ipi;
 186                 struct evtchn_close            close;
 187                 struct evtchn_send             send;
 188                 struct evtchn_status           status;
 189                 struct evtchn_bind_vcpu        bind_vcpu;
 190                 struct evtchn_unmask           unmask;
 191         } u;
 192 };
 193 DEFINE_GUEST_HANDLE_STRUCT(evtchn_op);
 194
 195 #endif /* __XEN_PUBLIC_EVENT_CHANNEL_H__ */