Xen: FIFO-based event channel ABI
v6 cover Xen: FIFO-based event channel ABI
This is a complete implementation of the hypervisor and xl toolstack parts of the FIFO-based event channel ABI described in this design document:
http://xenbits.xen.org/people/dvrabel/event-channels-F.pdf
The v6 version of the Linux patch series will be posted shortly and can be found in the orochi-v6 branch of:
git://xenbits.xen.org/people/dvrabel/linux.git
Patch 1-4 do some preparatory work for supporting alternate ABIs.
Patch 5 expands the number of evtchn objects a domain may have by changing how they are allocated.
Patch 6 adds the public ABI.
Patch 7 adds the EVTCHNOP_set_priority implementation. This will return -ENOSYS for ABIs that do not support priority.
Patch 8* adds the FIFO-based ABI implementation.
Patch 9-10 adds the DOMCTL_set_max_evtchn implementation and adds a function to libxc. This will also work with the 2-level ABI.
Patch 11 add the max_event_channels configuration option to xl and libxl bits needed for this.
* Reviewed-by pending.
Changes in v6:
- fixed unmap_guest_page().
- fixed flask build.
Changes in v5:
- xl config option renamed to 'max_event_channels'.
- Default set by libxl is 1023.
- Fix flask (I think).
- Use domain_page_map_to_mfn() when unmapping guest pages.
- Coding style (unsigned -> unsigned int throughout, x == NULL -> !x).
Changes in v4:
- Updates for Draft F of the design.
- DOMCTL_set_max_evtchn replaces EVTCHNOP_set_limit.
- Hypervisor defaults to unlimited event channels for for DomU.
- Optimized memory allocation for struct evtchn's when fewer than 128 are required (see patch 5).
- Added event_channels option to the xl domain configuration file and plumbed this through libxl_build_info. Defaults to 127.
Changes in v3:
- Updates for Draft E of the design.
- Store priority in struct evtchn.
- Implement set_priority with generic code + hook.
- Implement set_limit and add libxc function.
- Add ABI specific output to 'e' debug key.
Changes in v2:
- Updates for Draft D of the design.
- 130,000+ event channels are now supported.
- event_port.c -> event_2l.c and only contains 2l functions.
- Addresses various review comments
- int -> unsigned in lots of places
- use write_atomic() to set HEAD
- removed MAX_EVTCHNS
- evtchn_ops are const.
- Pack struct evtchns better to reduce memory needed.
PATCH v6 1/11 debug: remove some event channel info from the 'i' and 'q' debug keys
From: David Vrabel <[email protected]>
The 'i' key would always use VCPU0's selector word when printing the event channel state. Remove the incorrect output as a subsequent change will add the (correct) information to the 'e' key instead.
When dumping domain information, printing the state of the VIRQ_DEBUG port is redundant -- this information is available via the 'e' key.
--- xen/arch/x86/irq.c | 5 +---- xen/common/keyhandler.c | 11 ++--------- 2 files changed, 3 insertions(+), 13 deletions(-)
xen/arch/x86/irq.c +1 -4
@@ -2262,14 +2262,11 @@ static void dump_irqs(unsigned char key) d = action->guest[i]; pirq =domain_irq_to_pirq (d, irq); info =pirq_info (d, pirq); -printk ("%u:%3d(%c%c%c%c)" , +printk ("%u:%3d(%c%c%c)" , d->domain_id, pirq, (test_bit (info->evtchn, &shared_info (d, evtchn_pending)) ?'P' :'-' ), - (test_bit (info->evtchn /BITS_PER_EVTCHN_WORD (d), - &vcpu_info (d->vcpu[0 ], evtchn_pending_sel)) ? -'S' :'-' ), (test_bit (info->evtchn, &shared_info (d, evtchn_mask)) ?'M' :'-' ), (info->masked ?'M' :'-' ));
xen/common/keyhandler.c +2 -9
@@ -310,16 +310,9 @@ static void dump_domains(unsigned char key) { for_each_vcpu ( d, v ) { -printk ("Notifying guest %d:%d (virq %d, port %d, stat %d/%d/%d)\n" , +printk ("Notifying guest %d:%d (virq %d, port %d)\n" , d->domain_id, v->vcpu_id, -VIRQ_DEBUG , v->virq_to_evtchn[VIRQ_DEBUG ], -test_bit (v->virq_to_evtchn[VIRQ_DEBUG ], - &shared_info (d, evtchn_pending)), -test_bit (v->virq_to_evtchn[VIRQ_DEBUG ], - &shared_info (d, evtchn_mask)), -test_bit (v->virq_to_evtchn[VIRQ_DEBUG ] / -BITS_PER_EVTCHN_WORD (d), - &vcpu_info (v, evtchn_pending_sel))); +VIRQ_DEBUG , v->virq_to_evtchn[VIRQ_DEBUG ]);send_guest_vcpu_virq (v,VIRQ_DEBUG ); } }
Signature · 1 line
1.7.2.5
PATCH v6 2/11 evtchn: refactor low-level event channel port ops
In reply to David VrabelFrom: David Vrabel <[email protected]>
Use functions for the low-level event channel port operations (set/clear pending, unmask, is_pending and is_masked).
Group these functions into a struct evtchn_port_op so they can be replaced by alternate implementations (for different ABIs) on a per-domain basis.
--- xen/arch/x86/irq.c | 11 ++--- xen/common/Makefile | 1 + xen/common/event_2l.c | 99 ++++++++++++++++++++++++++++++++++++++++++++ xen/common/event_channel.c | 87 +++++++++++++++------------------------ xen/common/schedule.c | 3 +- xen/include/xen/event.h | 45 ++++++++++++++++++++ xen/include/xen/sched.h | 4 ++ 7 files changed, 189 insertions(+), 61 deletions(-) create mode 100644 xen/common/event_2l.c
xen/arch/x86/irq.c +5 -6
@@ -1474,7 +1474,7 @@ int pirq_guest_unmask(struct domain *d) { pirq = pirqs[i]->pirq;if ( pirqs[i]->masked && - !test_bit (pirqs[i]->evtchn, &shared_info (d, evtchn_mask)) ) + !evtchn_port_is_masked (d,evtchn_from_port (d, pirqs[i]->evtchn)) )pirq_guest_eoi (pirqs[i]); } }while ( ++pirq < d->nr_pirqs && n ==ARRAY_SIZE (pirqs) );
@@ -2222,6 +2222,7 @@ static void dump_irqs(unsigned char key)int i, irq, pirq;struct irq_desc *desc;irq_guest_action_t *action; +struct evtchn *evtchn;struct domain *d;const struct pirq *info;unsigned long flags;
@@ -2262,13 +2263,11 @@ static void dump_irqs(unsigned char key) d = action->guest[i]; pirq =domain_irq_to_pirq (d, irq); info =pirq_info (d, pirq); + evtchn =evtchn_from_port (d, info->evtchn);printk ("%u:%3d(%c%c%c)" , d->domain_id, pirq, - (test_bit (info->evtchn, - &shared_info (d, evtchn_pending)) ? -'P' :'-' ), - (test_bit (info->evtchn, &shared_info (d, evtchn_mask)) ? -'M' :'-' ), + (evtchn_port_is_pending (d, evtchn) ?'P' :'-' ), + (evtchn_port_is_masked (d, evtchn) ?'M' :'-' ), (info->masked ?'M' :'-' ));if ( i != action->nr_guests )printk ("," );
xen/common/Makefile +1 -0
@@ -5,6 +5,7 @@ obj-y += cpupool.o obj-$(HAS_DEVICE_TREE) += device_tree.o obj-y += domctl.o obj-y += domain.o +obj-y += event_2l.o obj-y += event_channel.o obj-y += grant_table.o obj-y += irq.o
xen/common/event_2l.c new file +99 -0
99 lines not on this page · raw message
xen/common/event_channel.c +33 -54
132 lines not on this page · raw message
xen/common/schedule.c +2 -1
@@ -34,6 +34,7 @@#include <xen/multicall.h> #include <xen/cpu.h> #include <xen/preempt.h> +#include <xen/event.h> #include <public/sched.h> #include <xsm/xsm.h>
@@ -750,7 +751,7 @@ static long do_poll(struct sched_poll *sched_poll) goto out; rc =0 ; -if (test_bit (port, &shared_info (d, evtchn_pending)) ) +if (evtchn_port_is_pending (d,evtchn_from_port (d, port)) ) goto out; }
xen/include/xen/event.h +45 -0
49 lines not on this page · raw message
xen/include/xen/sched.h +4 -0
@@ -66,6 +66,7 @@ struct evtchnu8 state;/* ECS_* */ u8 xen_consumer;/* Consumer in Xen, if any? (0 = send to guest) */ u16 notify_vcpu_id;/* VCPU for local delivery notification */ +u32 port; union { struct { domid_t remote_domid;
@@ -238,6 +239,8 @@ struct mem_event_per_domainstruct mem_event_domain access; }; +struct evtchn_port_ops ; +struct domain {domid_t domain_id;
@@ -271,6 +274,7 @@ struct domain/* Event channel information. */ struct evtchn *evtchn[NR_EVTCHN_BUCKETS ];spinlock_t event_lock; +const struct evtchn_port_ops *evtchn_port_ops;struct grant_table *grant_table;
Signature · 1 line
1.7.2.5
PATCH v6 3/11 evtchn: print ABI specific state with the 'e' debug key
In reply to David VrabelFrom: David Vrabel <[email protected]>
In the output of the 'e' debug key, print some ABI specific state in addition to the (p)ending and (m)asked bits.
For the 2-level ABI, print the state of that event's selector bit. e.g.,
(XEN) port [p/m/s]
(XEN) 1 [0/0/1]: s=3 n=0 x=0 d=0 p=74
(XEN) 2 [0/0/1]: s=3 n=0 x=0 d=0 p=75
--- xen/common/event_2l.c | 10 ++++++++++ xen/common/event_channel.c | 8 +++++--- xen/include/xen/event.h | 7 +++++++ 3 files changed, 22 insertions(+), 3 deletions(-)
xen/common/event_2l.c +10 -0
@@ -74,6 +74,15 @@ static bool_t evtchn_2l_is_masked(struct domain *d,return test_bit (evtchn->port, &shared_info (d, evtchn_mask)); } +static void evtchn_2l_print_state (struct domain *d, +const struct evtchn *evtchn) +{ +struct vcpu *v = d->vcpu[evtchn->notify_vcpu_id]; + +printk ("%d" , !!test_bit (evtchn->port /BITS_PER_EVTCHN_WORD (d), + &vcpu_info (v, evtchn_pending_sel))); +} +static const struct evtchn_port_ops evtchn_port_ops_2l = { .set_pending = evtchn_2l_set_pending,
@@ -81,6 +90,7 @@ static const struct evtchn_port_ops evtchn_port_ops_2l = .unmask = evtchn_2l_unmask, .is_pending = evtchn_2l_is_pending, .is_masked = evtchn_2l_is_masked, + .print_state = evtchn_2l_print_state, };void evtchn_2l_init (struct domain *d)
xen/common/event_channel.c +5 -3
@@ -1232,7 +1232,7 @@ static void domain_dump_evtchn_info(struct domain *d) d->poll_mask, d->max_vcpus);printk ("Event channel information for domain %d:\n" "Polling vCPUs: {%s}\n" -" port [p/m]\n" , d->domain_id, keyhandler_scratch); +" port [p/m/s]\n" , d->domain_id, keyhandler_scratch);spin_lock (&d->event_lock);
@@ -1247,10 +1247,12 @@ static void domain_dump_evtchn_info(struct domain *d)if ( chn->state ==ECS_FREE )continue ; -printk (" %4u [%d/%d]: s=%d n=%d x=%d" , +printk (" %4u [%d/%d/" , port, !!evtchn_port_is_pending (d, chn), - !!evtchn_port_is_masked (d, chn), + !!evtchn_port_is_masked (d, chn)); +evtchn_port_print_state (d, chn); +printk ("]: s=%d n=%d x=%d" , chn->state, chn->notify_vcpu_id, chn->xen_consumer); switch ( chn->state )
xen/include/xen/event.h +7 -0
@@ -115,6 +115,7 @@ struct evtchn_port_ops {void (*unmask)(struct domain *d,struct evtchn *evtchn);bool_t (*is_pending)(struct domain *d,const struct evtchn *evtchn);bool_t (*is_masked)(struct domain *d,const struct evtchn *evtchn); +void (*print_state)(struct domain *d,const struct evtchn *evtchn); }; static inline void evtchn_port_set_pending(struct vcpu *v,
@@ -147,4 +148,10 @@ static inline bool_t evtchn_port_is_masked(struct domain *d, return d->evtchn_port_ops->is_masked(d, evtchn); } +static inline void evtchn_port_print_state (struct domain *d, +const struct evtchn *evtchn) +{ + d->evtchn_port_ops->print_state (d, evtchn); +} +#endif /* __XEN_EVENT_H__ */
Signature · 1 line
1.7.2.5
PATCH v6 4/11 evtchn: use a per-domain variable for the max number of event channels
In reply to David VrabelFrom: David Vrabel <[email protected]>
Instead of the MAX_EVTCHNS(d) macro, use d->max_evtchns instead. This avoids having to repeatedly check the ABI type.
--- xen/common/event_2l.c | 1 + xen/common/event_channel.c | 4 ++-- xen/common/schedule.c | 2 +- xen/include/xen/event.h | 2 +- xen/include/xen/sched.h | 2 +- 5 files changed, 6 insertions(+), 5 deletions(-)
xen/common/event_2l.c +1 -0
@@ -96,6 +96,7 @@ static const struct evtchn_port_ops evtchn_port_ops_2l =void evtchn_2l_init (struct domain *d) { d->evtchn_port_ops = &evtchn_port_ops_2l; + d->max_evtchns =BITS_PER_EVTCHN_WORD (d) *BITS_PER_EVTCHN_WORD (d); }/*
xen/common/event_channel.c +2 -2
@@ -134,7 +134,7 @@ static int get_free_port(struct domain *d)if (evtchn_from_port (d, port)->state ==ECS_FREE )return port; -if ( port ==MAX_EVTCHNS (d) ) +if ( port == d->max_evtchns )return -ENOSPC ; chn = xzalloc_array(struct evtchn, EVTCHNS_PER_BUCKET);
@@ -1236,7 +1236,7 @@ static void domain_dump_evtchn_info(struct domain *d)spin_lock (&d->event_lock); -for ( port =1 ; port <MAX_EVTCHNS (d); ++port ) +for ( port =1 ; port < d->max_evtchns; ++port ) {const struct evtchn *chn;char *ssid;
xen/common/schedule.c +1 -1
@@ -747,7 +747,7 @@ static long do_poll(struct sched_poll *sched_poll) goto out; rc = -EINVAL ; -if ( port >=MAX_EVTCHNS (d) ) +if ( port >= d->max_evtchns ) goto out; rc =0 ;
xen/include/xen/event.h +1 -1
@@ -73,7 +73,7 @@ void notify_via_xen_event_channel(struct domain *ld, int lport);#define bucket_from_port (d,p) \ ((d)->evtchn[(p)/EVTCHNS_PER_BUCKET])#define port_is_valid (d,p) \ - (((p) >= 0) && ((p) < MAX_EVTCHNS(d)) && \ + (((p) >= 0) && ((p) < (d)->max_evtchns) && \ (bucket_from_port(d,p) != NULL))#define evtchn_from_port (d,p) \ (&(bucket_from_port(d,p))[(p)&(EVTCHNS_PER_BUCKET-1)])
xen/include/xen/sched.h +1 -1
@@ -50,7 +50,6 @@ extern struct domain *dom0;#else #define BITS_PER_EVTCHN_WORD (d) (has_32bit_shinfo(d) ? 32 : BITS_PER_XEN_ULONG)#endif -#define MAX_EVTCHNS (d) (BITS_PER_EVTCHN_WORD(d) * BITS_PER_EVTCHN_WORD(d))#define EVTCHNS_PER_BUCKET 128#define NR_EVTCHN_BUCKETS (NR_EVENT_CHANNELS / EVTCHNS_PER_BUCKET)
@@ -273,6 +272,7 @@ struct domain/* Event channel information. */ struct evtchn *evtchn[NR_EVTCHN_BUCKETS ]; +unsigned int max_evtchns;spinlock_t event_lock;const struct evtchn_port_ops *evtchn_port_ops;
Signature · 1 line
1.7.2.5
PATCH v6 5/11 evtchn: allow many more evtchn objects to be allocated per domain
In reply to David VrabelFrom: David Vrabel <[email protected]>
Expand the number of event channels that can be supported internally by altering now struct evtchn's are allocated.
The objects are indexed using a two level scheme of groups and buckets (instead of only buckets). Each group is a page of bucket pointers. Each bucket is a page-sized array of struct evtchn's.
The optimal number of evtchns per bucket is calculated at compile time.
If XSM is not enabled, struct evtchn is 16 bytes and each bucket contains 256, requiring only 1 group of 512 pointers for 2^17 (131,072) event channels. With XSM enabled, struct evtchn is 24 bytes, each bucket contains 128 and 2 groups are required.
For the common case of a domain with only a few event channels, instead of requiring an additional allocation for the group page, the first bucket is indexed directly.
As a consequence of this, struct domain shrinks by at least 232 bytes as 32 bucket pointers are replaced with 1 bucket pointer and (at most) 2 group pointers.
[ Based on a patch from Wei Liu with improvements from Malcolm Crossley. ]
--- xen/common/event_channel.c | 82 ++++++++++++++++++++++++++++++++++---------- xen/include/xen/event.h | 40 ++++++++++++++++----- xen/include/xen/sched.h | 21 ++++++++++-- 3 files changed, 113 insertions(+), 30 deletions(-)
xen/common/event_channel.c +64 -18
@@ -121,11 +121,47 @@ static int virq_is_global(uint32_t virq) } +static struct evtchn *alloc_evtchn_bucket (struct domain *d,unsigned int port) +{ +struct evtchn *chn; +unsigned int i; + + chn = xzalloc_array(struct evtchn, EVTCHNS_PER_BUCKET); +if ( !chn ) +return NULL ; + +for ( i =0 ; i <EVTCHNS_PER_BUCKET ; i++ ) + { +if (xsm_alloc_security_evtchn (&chn[i]) ) + { +while ( i-- ) +xsm_free_security_evtchn (&chn[i]); +xfree (chn); +return NULL ; + } + chn[i].port = port + i; + } +return chn; +} + +static void free_evtchn_bucket (struct domain *d,struct evtchn *bucket) +{ +unsigned int i; + +if ( !bucket ) +return ; + +for ( i =0 ; i <EVTCHNS_PER_BUCKET ; i++ ) +xsm_free_security_evtchn (bucket + i); + +xfree (bucket); +} +static int get_free_port (struct domain *d) {struct evtchn *chn; +struct evtchn **grp;int port; -int i, j;if ( d->is_dying )return -EINVAL ;
@@ -137,22 +173,17 @@ static int get_free_port(struct domain *d)if ( port == d->max_evtchns )return -ENOSPC ; - chn = xzalloc_array(struct evtchn, EVTCHNS_PER_BUCKET); -if (unlikely (chn ==NULL ) ) -return -ENOMEM ; - -for ( i =0 ; i <EVTCHNS_PER_BUCKET ; i++ ) +if ( !group_from_port (d, port) ) { -if (xsm_alloc_security_evtchn (&chn[i]) ) - { -for ( j =0 ; j < i; j++ ) -xsm_free_security_evtchn (&chn[j]); -xfree (chn); + grp = xzalloc_array(struct evtchn *, BUCKETS_PER_GROUP); +if ( !grp )return -ENOMEM ; - } - chn[i].port = port + i; +group_from_port (d, port) = grp; } + chn =alloc_evtchn_bucket (d, port); +if ( !chn ) +return -ENOMEM ;bucket_from_port (d, port) = chn;return port;
@@ -1152,15 +1183,25 @@ int evtchn_init(struct domain *d) {evtchn_2l_init (d); + d->evtchn =alloc_evtchn_bucket (d,0 ); +if ( !d->evtchn ) +return -ENOMEM ; +spin_lock_init (&d->event_lock);if (get_free_port (d) !=0 ) + { +free_evtchn_bucket (d, d->evtchn);return -EINVAL ; + }evtchn_from_port (d,0 )->state =ECS_RESERVED ;#if MAX_VIRT_CPUS >BITS_PER_LONG d->poll_mask = xmalloc_array(unsigned long, BITS_TO_LONGS(MAX_VIRT_CPUS));if ( !d->poll_mask ) + { +free_evtchn_bucket (d, d->evtchn);return -ENOMEM ; + }bitmap_zero (d->poll_mask,MAX_VIRT_CPUS );#endif
@@ -1170,7 +1211,7 @@ int evtchn_init(struct domain *d)void evtchn_destroy (struct domain *d) { -int i; +unsigned int i, j;/* After this barrier no new event-channel allocations can occur. */ BUG_ON (!d->is_dying);
@@ -1185,12 +1226,17 @@ void evtchn_destroy(struct domain *d)/* Free all event-channel buckets. */ spin_lock (&d->event_lock); -for ( i =0 ; i <NR_EVTCHN_BUCKETS ; i++ ) +for ( i =0 ; i <NR_EVTCHN_GROUPS ; i++ ) { -xsm_free_security_evtchn (d->evtchn[i]); -xfree (d->evtchn[i]); - d->evtchn[i] =NULL ; +if ( !d->evtchn_group[i] ) +continue ; +for ( j =0 ; j <BUCKETS_PER_GROUP ; j++ ) +free_evtchn_bucket (d, d->evtchn_group[i][j]); +xfree (d->evtchn_group[i]); + d->evtchn_group[i] =NULL ; } +free_evtchn_bucket (d, d->evtchn); + d->evtchn =NULL ;spin_unlock (&d->event_lock);clear_global_virq_handlers (d);
xen/include/xen/event.h +30 -8
@@ -69,15 +69,37 @@ int guest_enabled_event(struct vcpu *v, uint32_t virq);/* Notify remote end of a Xen-attached event channel.*/ void notify_via_xen_event_channel (struct domain *ld,int lport); -/* Internal event channel object accessors */ -#define bucket_from_port (d,p) \ - ((d)->evtchn[(p)/EVTCHNS_PER_BUCKET]) -#define port_is_valid (d,p) \ - (((p) >= 0) && ((p) < (d)->max_evtchns) && \ - (bucket_from_port(d,p) != NULL)) -#define evtchn_from_port (d,p) \ - (&(bucket_from_port(d,p))[(p)&(EVTCHNS_PER_BUCKET-1)]) +/* +* Internal event channel object storage. +* +* The objects (struct evtchn) are indexed using a two level scheme of +* groups and buckets. Each group is a page of bucket pointers. Each +* bucket is a page-sized array of struct evtchn's. +* +* The first bucket is directly accessed via d->evtchn. +*/ +#define group_from_port (d, p) \ + ((d)->evtchn_group[(p) / EVTCHNS_PER_GROUP]) +#define bucket_from_port (d, p) \ + ((group_from_port(d, p))[((p) % EVTCHNS_PER_GROUP) / EVTCHNS_PER_BUCKET]) +static inline bool_t port_is_valid (struct domain *d,unsigned int p) +{ +if ( p >= d->max_evtchns ) +return 0 ; +if ( !d->evtchn ) +return 0 ; +if ( p <EVTCHNS_PER_BUCKET ) +return 1 ; +return group_from_port (d, p) !=NULL &&bucket_from_port (d, p) !=NULL ; +} + +static inline struct evtchn *evtchn_from_port (struct domain *d,unsigned int p) +{ +if ( p <EVTCHNS_PER_BUCKET ) +return &d->evtchn[p]; +return bucket_from_port (d, p) + (p %EVTCHNS_PER_BUCKET ); +}/* Wait on a Xen-attached event channel. */ #define wait_on_xen_event_channel (port, condition) \
xen/include/xen/sched.h +18 -3
@@ -50,8 +50,22 @@ extern struct domain *dom0;#else #define BITS_PER_EVTCHN_WORD (d) (has_32bit_shinfo(d) ? 32 : BITS_PER_XEN_ULONG)#endif -#define EVTCHNS_PER_BUCKET 128 -#define NR_EVTCHN_BUCKETS (NR_EVENT_CHANNELS / EVTCHNS_PER_BUCKET) + +#define BUCKETS_PER_GROUP (PAGE_SIZE/sizeof(struct evtchn *)) +/* Round size of struct evtchn up to power of 2 size */ +#define __RDU2 (x) ( (x) | ( (x) >> 1)) +#define __RDU4 (x) ( __RDU2(x) | ( __RDU2(x) >> 2)) +#define __RDU8 (x) ( __RDU4(x) | ( __RDU4(x) >> 4)) +#define __RDU16 (x) ( __RDU8(x) | ( __RDU8(x) >> 8)) +#define __RDU32 (x) (__RDU16(x) | (__RDU16(x) >>16)) +#define next_power_of_2 (x) (__RDU32((x)-1) + 1) + +/* Maximum number of event channels for any ABI. */ +#define MAX_NR_EVTCHNS NR_EVENT_CHANNELS + +#define EVTCHNS_PER_BUCKET (PAGE_SIZE / next_power_of_2(sizeof(struct evtchn))) +#define EVTCHNS_PER_GROUP (BUCKETS_PER_GROUP * EVTCHNS_PER_BUCKET) +#define NR_EVTCHN_GROUPS DIV_ROUND_UP(MAX_NR_EVTCHNS, EVTCHNS_PER_GROUP)struct evtchn {
@@ -271,7 +285,8 @@ struct domainspinlock_t rangesets_lock;/* Event channel information. */ -struct evtchn *evtchn[NR_EVTCHN_BUCKETS ]; +struct evtchn *evtchn;/* first bucket only */ +struct evtchn **evtchn_group[NR_EVTCHN_GROUPS ];/* all other buckets */ unsigned int max_evtchns;spinlock_t event_lock;const struct evtchn_port_ops *evtchn_port_ops;
Signature · 1 line
1.7.2.5
PATCH v6 6/11 evtchn: add FIFO-based event channel ABI
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add the event channel hypercall sub-ops and the definitions for the shared data structures for the FIFO-based event channel ABI.
The design document for this new ABI is available here:
http://xenbits.xen.org/people/dvrabel/event-channels-F.pdf
In summary, events are reported using a per-domain shared event array of event words. Each event word has PENDING, LINKED and MASKED bits and a LINK field for pointing to the next event in the event queue.
There are 16 event queues (with different priorities) per-VCPU.
Key advantages of this new ABI include:
- Support for over 100,000 events (2^17).
- 16 different event priorities.
- Improved fairness in event latency through the use of FIFOs.
--- xen/include/public/event_channel.h | 75 ++++++++++++++++++++++++++++++++++++ xen/include/public/xen.h | 6 ++- xen/include/xen/sched.h | 2 +- 3 files changed, 80 insertions(+), 3 deletions(-)
xen/include/public/event_channel.h +75 -0
@@ -71,6 +71,9 @@#define EVTCHNOP_bind_vcpu 8#define EVTCHNOP_unmask 9#define EVTCHNOP_reset 10 +#define EVTCHNOP_init_control 11 +#define EVTCHNOP_expand_array 12 +#define EVTCHNOP_set_priority 13/* ` } */ typedef uint32_t evtchn_port_t ;
@@ -258,6 +261,43 @@ struct evtchn_reset {typedef struct evtchn_reset evtchn_reset_t ;/* +* EVTCHNOP_init_control: initialize the control block for the FIFO ABI. +* +* Note: any events that are currently pending will not be resent and +* will be lost. Guests should call this before binding any event to +* avoid losing any events. +*/ +struct evtchn_init_control { +/* IN parameters. */ +uint64_t control_gfn; +uint32_t offset; +uint32_t vcpu; +/* OUT parameters. */ +uint8_t link_bits; +uint8_t _pad[7 ]; +}; +typedef struct evtchn_init_control evtchn_init_control_t ; + +/* +* EVTCHNOP_expand_array: add an additional page to the event array. +*/ +struct evtchn_expand_array { +/* IN parameters. */ +uint64_t array_gfn; +}; +typedef struct evtchn_expand_array evtchn_expand_array_t ; + +/* +* EVTCHNOP_set_priority: set the priority for an event channel. +*/ +struct evtchn_set_priority { +/* IN parameters. */ +uint32_t port; +uint32_t priority; +}; +typedef struct evtchn_set_priority evtchn_set_priority_t ; + +/* * ` enum neg_errnoval * ` HYPERVISOR_event_channel_op_compat(struct evtchn_op *op) * `
@@ -281,6 +321,41 @@ struct evtchn_op {typedef struct evtchn_op evtchn_op_t ;DEFINE_XEN_GUEST_HANDLE (evtchn_op_t); +/* +* 2-level ABI +*/ + +#define EVTCHN_2L_NR_CHANNELS (sizeof(xen_ulong_t) * sizeof(xen_ulong_t) * 64) + +/* +* FIFO ABI +*/ + +/* Events may have priorities from 0 (highest) to 15 (lowest). */ +#define EVTCHN_FIFO_PRIORITY_MAX 0 +#define EVTCHN_FIFO_PRIORITY_DEFAULT 7 +#define EVTCHN_FIFO_PRIORITY_MIN 15 + +#define EVTCHN_FIFO_MAX_QUEUES (EVTCHN_FIFO_PRIORITY_MIN + 1) + +typedef uint32_t event_word_t ; + +#define EVTCHN_FIFO_PENDING 31 +#define EVTCHN_FIFO_MASKED 30 +#define EVTCHN_FIFO_LINKED 29 + +#define EVTCHN_FIFO_LINK_BITS 17 +#define EVTCHN_FIFO_LINK_MASK ((1 << EVTCHN_FIFO_LINK_BITS) - 1) + +#define EVTCHN_FIFO_NR_CHANNELS (1 << EVTCHN_FIFO_LINK_BITS) + +struct evtchn_fifo_control_block { +uint32_t ready; +uint32_t _rsvd; +uint32_t head[EVTCHN_FIFO_MAX_QUEUES ]; +}; +typedef struct evtchn_fifo_control_block evtchn_fifo_control_block_t ; +#endif /* __XEN_PUBLIC_EVENT_CHANNEL_H__ */ /*
xen/include/public/xen.h +4 -2
@@ -552,11 +552,13 @@ struct multicall_entry {typedef struct multicall_entry multicall_entry_t ;DEFINE_XEN_GUEST_HANDLE (multicall_entry_t); +#if __XEN_INTERFACE_VERSION__ <0x00040400 /* -* Event channel endpoints per domain: +* Event channel endpoints per domain (when using the 2-level ABI): * 1024 if a long is 32 bits; 4096 if a long is 64 bits. */ -#define NR_EVENT_CHANNELS (sizeof(xen_ulong_t) * sizeof(xen_ulong_t) * 64) +#define NR_EVENT_CHANNELS EVTCHN_2L_NR_CHANNELS +#endif struct vcpu_time_info {/*
xen/include/xen/sched.h +1 -1
@@ -61,7 +61,7 @@ extern struct domain *dom0;#define next_power_of_2 (x) (__RDU32((x)-1) + 1)/* Maximum number of event channels for any ABI. */ -#define MAX_NR_EVTCHNS NR_EVENT_CHANNELS +#define MAX_NR_EVTCHNS EVTCHN_2L_NR_CHANNELS#define EVTCHNS_PER_BUCKET (PAGE_SIZE / next_power_of_2(sizeof(struct evtchn)))#define EVTCHNS_PER_GROUP (BUCKETS_PER_GROUP * EVTCHNS_PER_BUCKET)
Signature · 1 line
1.7.2.5
PATCH v6 7/11 evtchn: implement EVTCHNOP_set_priority and add the set_priority hook
In reply to David VrabelFrom: David Vrabel <[email protected]>
Implement EVTCHNOP_set_priority. A new set_priority hook added to struct evtchn_port_ops will do the ABI specific validation and setup.
If an ABI does not provide a set_priority hook (as is the case of the 2-level ABI), the sub-op will return -ENOSYS.
--- xen/common/event_channel.c | 29 +++++++++++++++++++++++++++++ xen/include/xen/event.h | 11 +++++++++++ 2 files changed, 40 insertions(+), 0 deletions(-)
xen/common/event_channel.c +29 -0
@@ -955,6 +955,27 @@ out:return rc; } +static long evtchn_set_priority (const struct evtchn_set_priority *set_priority) +{ +struct domain *d = current->domain; +unsigned int port = set_priority->port; +long ret; + +spin_lock (&d->event_lock); + +if ( !port_is_valid (d, port) ) + { +spin_unlock (&d->event_lock); +return -EINVAL ; + } + + ret =evtchn_port_set_priority (d,evtchn_from_port (d, port), + set_priority->priority); + +spin_unlock (&d->event_lock); + +return ret; +}long do_event_channel_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) {
@@ -1064,6 +1085,14 @@ long do_event_channel_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg)break ; } +case EVTCHNOP_set_priority: { +struct evtchn_set_priority set_priority; +if (copy_from_guest (&set_priority, arg,1 ) !=0 ) +return -EFAULT ; + rc =evtchn_set_priority (&set_priority); +break ; + } +default : rc = -ENOSYS ;break ;
xen/include/xen/event.h +11 -0
@@ -137,6 +137,8 @@ struct evtchn_port_ops {void (*unmask)(struct domain *d,struct evtchn *evtchn);bool_t (*is_pending)(struct domain *d,const struct evtchn *evtchn);bool_t (*is_masked)(struct domain *d,const struct evtchn *evtchn); +int (*set_priority)(struct domain *d,struct evtchn *evtchn, +unsigned int priority);void (*print_state)(struct domain *d,const struct evtchn *evtchn); };
@@ -170,6 +172,15 @@ static inline bool_t evtchn_port_is_masked(struct domain *d,return d->evtchn_port_ops->is_masked (d, evtchn); } +static inline int evtchn_port_set_priority (struct domain *d, +struct evtchn *evtchn, +unsigned int priority) +{ +if ( !d->evtchn_port_ops->set_priority ) +return -ENOSYS ; +return d->evtchn_port_ops->set_priority (d, evtchn, priority); +} +static inline void evtchn_port_print_state (struct domain *d,const struct evtchn *evtchn) {
Signature · 1 line
1.7.2.5
PATCH v6 8/11 evtchn: add FIFO-based event channel hypercalls and port ops
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add the implementation for the FIFO-based event channel ABI. The new hypercall sub-ops (EVTCHNOP_init_control, EVTCHNOP_expand_array) and the required evtchn_ops (set_pending, unmask, etc.).
--- xen/common/Makefile | 1 + xen/common/event_channel.c | 21 ++ xen/common/event_fifo.c | 445 ++++++++++++++++++++++++++++++++++++++++++ xen/include/xen/event_fifo.h | 47 +++++ xen/include/xen/sched.h | 6 +- 5 files changed, 519 insertions(+), 1 deletions(-) create mode 100644 xen/common/event_fifo.c create mode 100644 xen/include/xen/event_fifo.h
xen/common/Makefile +1 -0
@@ -7,6 +7,7 @@ obj-y += domctl.o obj-y += domain.o obj-y += event_2l.o obj-y += event_channel.o +obj-y += event_fifo.o obj-y += grant_table.o obj-y += irq.o obj-y += kernel.o
xen/common/event_channel.c +21 -0
@@ -26,6 +26,7 @@#include <xen/compat.h> #include <xen/guest_access.h> #include <xen/keyhandler.h> +#include <xen/event_fifo.h> #include <asm/current.h> #include <public/xen.h>
@@ -1085,6 +1086,24 @@ long do_event_channel_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg)break ; } +case EVTCHNOP_init_control: { +struct evtchn_init_control init_control; +if (copy_from_guest (&init_control, arg,1 ) !=0 ) +return -EFAULT ; + rc =evtchn_fifo_init_control (&init_control); +if ( !rc &&__copy_to_guest (arg, &init_control,1 ) ) + rc = -EFAULT ; +break ; + } + +case EVTCHNOP_expand_array: { +struct evtchn_expand_array expand_array; +if (copy_from_guest (&expand_array, arg,1 ) !=0 ) +return -EFAULT ; + rc =evtchn_fifo_expand_array (&expand_array); +break ; + } +case EVTCHNOP_set_priority: {struct evtchn_set_priority set_priority;if (copy_from_guest (&set_priority, arg,1 ) !=0 )
@@ -1269,6 +1288,8 @@ void evtchn_destroy(struct domain *d)spin_unlock (&d->event_lock);clear_global_virq_handlers (d); + +evtchn_fifo_destroy (d); }
xen/common/event_fifo.c new file +445 -0
445 lines not on this page · raw message
xen/include/xen/event_fifo.h new file +47 -0
47 lines not on this page · raw message
xen/include/xen/sched.h +5 -1
@@ -61,7 +61,7 @@ extern struct domain *dom0;#define next_power_of_2 (x) (__RDU32((x)-1) + 1)/* Maximum number of event channels for any ABI. */ -#define MAX_NR_EVTCHNS EVTCHN_2L_NR_CHANNELS +#define MAX_NR_EVTCHNS MAX(EVTCHN_2L_NR_CHANNELS, EVTCHN_FIFO_NR_CHANNELS)#define EVTCHNS_PER_BUCKET (PAGE_SIZE / next_power_of_2(sizeof(struct evtchn)))#define EVTCHNS_PER_GROUP (BUCKETS_PER_GROUP * EVTCHNS_PER_BUCKET)
@@ -95,6 +95,7 @@ struct evtchn } pirq;/* state == ECS_PIRQ */ u16 virq;/* state == ECS_VIRQ */ } u; +u8 priority;#ifdef FLASK_ENABLE void *ssid;#endif
@@ -209,6 +210,8 @@ struct vcpu/* Guest-specified relocation of vcpu_info. */ unsigned long vcpu_info_mfn; +struct evtchn_fifo_vcpu *evtchn_fifo; +struct arch_vcpu arch; };
@@ -290,6 +293,7 @@ struct domainunsigned int max_evtchns;spinlock_t event_lock;const struct evtchn_port_ops *evtchn_port_ops; +struct evtchn_fifo_domain *evtchn_fifo;struct grant_table *grant_table;
Signature · 1 line
1.7.2.5
Re: [PATCH 08/11] evtchn: add FIFO-based event channel hypercalls and port ops
Quoted 8 lines
Quoted 1 line
Quoted 1 line · David Vrabel
From: David Vrabel <[email protected]>
Add the implementation for the FIFO-based event channel ABI. The new hypercall sub-ops (
EVTCHNOP_init_control,EVTCHNOP_expand_array) and the requiredevtchn_ops(set_pending, unmask, etc.).Signed-off-by David Vrabel <[email protected]>
xen/common/event_fifo.c line 333
Quoted 10 lines
xen/common/event_fifo.c new file +10
-0+static void set_priority_all (struct domain *d,unsigned int priority) +{ +unsigned int port; + +for ( port =1 ; port < d->max_evtchns; port++ ) + { +if ( !port_is_valid (d, port) ) +break ; + +evtchn_port_set_priority (d,evtchn_from_port (d, port), priority);
Couldn't you short cut this and call your internal function directly instead of through the generic wrapper?
Jan
Re: [PATCH 08/11] evtchn: add FIFO-based event channel hypercalls and port ops
Quoted 10 lines · Jan Beulich
Quoted 8 lines
Quoted 1 line
Quoted 1 line · David Vrabel
From: David Vrabel <[email protected]>
Add the implementation for the FIFO-based event channel ABI. The new hypercall sub-ops (
EVTCHNOP_init_control,EVTCHNOP_expand_array) and the requiredevtchn_ops(set_pending, unmask, etc.).Signed-off-by David Vrabel <[email protected]>Reviewed-by Jan Beulich <[email protected]>
Thanks!
Quoted 5 lines
Quoted 5 lines
xen/common/event_fifo.c new file +5
-0+static void set_priority_all (struct domain *d,unsigned int priority) +{ +unsigned int port; + +for ( port =1 ; port < d->max_evtchns; port++ )
Quoted 8 lines
xen/common/event_fifo.c line 333
Quoted 5 lines
xen/common/event_fifo.c new file +5
-0+ { +if ( !port_is_valid (d, port) ) +break ; + +evtchn_port_set_priority (d,evtchn_from_port (d, port), priority);Couldn't you short cut this and call your internal function directly instead of through the generic wrapper?
I dithered over this at the time I added this and I don't recall why. I'll make a note to change this up in a follow-up patch.
David
PATCH v6 9/11 xen: Add DOMCTL to limit the number of event channels a domain may use
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add XEN_DOMCTL_set_max_evtchn which may be used during domain creation to set the maximum event channel port a domain may use. This may be used to limit the amount of Xen resources (global mapping space and xenheap) that a domain may use for event channels.
A domain that does not have a limit set may use all the event channels supported by the event channel ABI in use.
--- tools/flask/policy/policy/modules/xen/xen.if | 2 +- tools/flask/policy/policy/modules/xen/xen.te | 2 +- xen/common/domctl.c | 8 ++++++++ xen/common/event_channel.c | 7 ++++++- xen/include/public/domctl.h | 13 +++++++++++++ xen/include/xen/sched.h | 1 + xen/xsm/flask/hooks.c | 3 +++ xen/xsm/flask/policy/access_vectors | 2 ++ 8 files changed, 35 insertions(+), 3 deletions(-)
tools/flask/policy/policy/modules/xen/xen.if +1 -1
@@ -49,7 +49,7 @@ define(`create_domain_common', ` getdomaininfo hypercall setvcpucontext setextvcpucontext getscheduler getvcpuinfo getvcpuextstate getaddrsize getaffinity setaffinity }; - allow $1 $2:domain2 { set_cpuid settsc setscheduler setclaim }; + allow $1 $2:domain2 { set_cpuid settsc setscheduler setclaim set_max_evtchn }; allow $1 $2:security check_context; allow $1 $2:shadow enable; allow $1 $2:mmu { map_read map_write adjust memorymap physmap pinpage mmuext_op };
tools/flask/policy/policy/modules/xen/xen.te +1 -1
@@ -76,7 +76,7 @@ allow dom0_t dom0_t:domain { getpodtarget setpodtarget set_misc_info set_virq_handler }; allow dom0_t dom0_t:domain2 { - set_cpuid gettsc settsc setscheduler + set_cpuid gettsc settsc setscheduler set_max_evtchn }; allow dom0_t dom0_t:resource { add remove };
xen/common/domctl.c +8 -0
@@ -863,6 +863,14 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) }break ; +case XEN_DOMCTL_set_max_evtchn: + { + d->max_evtchn_port = min_t(unsigned int, + op->u.set_max_evtchn.max_port, +INT_MAX ); + } +break ; +default : ret =arch_do_domctl (op, d, u_domctl);break ;
xen/common/event_channel.c +6 -1
@@ -168,10 +168,14 @@ static int get_free_port(struct domain *d)return -EINVAL ;for ( port =0 ;port_is_valid (d, port); port++ ) + { +if ( port > d->max_evtchn_port ) +return -ENOSPC ;if (evtchn_from_port (d, port)->state ==ECS_FREE )return port; + } -if ( port == d->max_evtchns ) +if ( port == d->max_evtchns || port > d->max_evtchn_port )return -ENOSPC ;if ( !group_from_port (d, port) )
@@ -1230,6 +1234,7 @@ void evtchn_check_pollers(struct domain *d, unsigned int port)int evtchn_init (struct domain *d) {evtchn_2l_init (d); + d->max_evtchn_port =INT_MAX ; d->evtchn =alloc_evtchn_bucket (d,0 );if ( !d->evtchn )
xen/include/public/domctl.h +13 -0
@@ -852,6 +852,17 @@ struct xen_domctl_set_broken_page_p2m {typedef struct xen_domctl_set_broken_page_p2m xen_domctl_set_broken_page_p2m_t ;DEFINE_XEN_GUEST_HANDLE (xen_domctl_set_broken_page_p2m_t); +/* +* XEN_DOMCTL_set_max_evtchn: sets the maximum event channel port +* number the guest may use. Use this limit the amount of resources +* (global mapping space, xenheap) a guest may use for event channels. +*/ +struct xen_domctl_set_max_evtchn { +uint32_t max_port; +}; +typedef struct xen_domctl_set_max_evtchn xen_domctl_set_max_evtchn_t ; +DEFINE_XEN_GUEST_HANDLE (xen_domctl_set_max_evtchn_t); +struct xen_domctl {uint32_t cmd;#define XEN_DOMCTL_createdomain 1
@@ -920,6 +931,7 @@ struct xen_domctl {#define XEN_DOMCTL_set_broken_page_p2m 67#define XEN_DOMCTL_setnodeaffinity 68#define XEN_DOMCTL_getnodeaffinity 69 +#define XEN_DOMCTL_set_max_evtchn 70#define XEN_DOMCTL_gdbsx_guestmemio 1000#define XEN_DOMCTL_gdbsx_pausevcpu 1001#define XEN_DOMCTL_gdbsx_unpausevcpu 1002
@@ -975,6 +987,7 @@ struct xen_domctl {struct xen_domctl_set_access_required access_required;struct xen_domctl_audit_p2m audit_p2m;struct xen_domctl_set_virq_handler set_virq_handler; +struct xen_domctl_set_max_evtchn set_max_evtchn;struct xen_domctl_gdbsx_memio gdbsx_guest_memio;struct xen_domctl_set_broken_page_p2m set_broken_page_p2m;struct xen_domctl_gdbsx_pauseunp_vcpu gdbsx_pauseunp_vcpu;
xen/include/xen/sched.h +1 -0
@@ -291,6 +291,7 @@ struct domainstruct evtchn *evtchn;/* first bucket only */ struct evtchn **evtchn_group[NR_EVTCHN_GROUPS ];/* all other buckets */ unsigned int max_evtchns; +unsigned int max_evtchn_port;spinlock_t event_lock;const struct evtchn_port_ops *evtchn_port_ops;struct evtchn_fifo_domain *evtchn_fifo;
xen/xsm/flask/hooks.c +3 -0
@@ -727,6 +727,9 @@ static int flask_domctl(struct domain *d, int cmd)case XEN_DOMCTL_audit_p2m:return current_has_perm (d,SECCLASS_HVM ,HVM__AUDIT_P2M ); +case XEN_DOMCTL_set_max_evtchn: +return current_has_perm (d,SECCLASS_DOMAIN2 ,DOMAIN2__SET_MAX_EVTCHN ); +default :printk ("flask_domctl: Unknown op %d\n" , cmd);return -EPERM ;
xen/xsm/flask/policy/access_vectors +2 -0
@@ -194,6 +194,8 @@ class domain2 setscheduler # XENMEM_claim_pages setclaim +# XEN_DOMCTL_set_max_evtchn + set_max_evtchn } # Similar to class domain, but primarily contains domctls related to HVM domains
Signature · 1 line
1.7.2.5
PATCH v6 10/11 libxc: add xc_domain_set_max_evtchn()
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add xc_domain_set_max_evtchn(), a wrapper around the DOMCTL_set_max_evtchn hypercall.
--- tools/libxc/xc_domain.c | 11 +++++++++++ tools/libxc/xenctrl.h | 12 ++++++++++++ 2 files changed, 23 insertions(+), 0 deletions(-)
tools/libxc/xc_domain.c +11 -0
@@ -1766,6 +1766,17 @@ int xc_domain_set_virq_handler(xc_interface *xch, uint32_t domid, int virq)return do_domctl (xch, &domctl); } +int xc_domain_set_max_evtchn (xc_interface *xch,uint32_t domid, +uint32_t max_port) +{ +DECLARE_DOMCTL ; + + domctl.cmd = XEN_DOMCTL_set_max_evtchn; + domctl.domain = domid; + domctl.u.set_max_evtchn.max_port = max_port; +return do_domctl (xch, &domctl); +} +/* * Local variables: * mode: C
tools/libxc/xenctrl.h +12 -0
@@ -847,6 +847,18 @@ int xc_domain_set_access_required(xc_interface *xch,*/ int xc_domain_set_virq_handler (xc_interface *xch,uint32_t domid,int virq); +/** +* Set the maximum event channel port a domain may bind. +* +* This does not affect ports that are already bound. +* +* @param xch a handle to an open hypervisor interface +* @param domid the domain id +* @param max_port maximum port number +*/ +int xc_domain_set_max_evtchn (xc_interface *xch,uint32_t domid, +uint32_t max_port); +/* * CPUPOOL MANAGEMENT FUNCTIONS */
Signature · 1 line
1.7.2.5
PATCH v6 11/11 libxl, xl: add max_event_channels option to xl configuration file
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add the 'max_event_channels' option to the xl configuration file to limit the number of event channels that domain may use.
Plumb this option through to libxl via a new libxl_build_info field and call xc_domain_set_max_evtchn() in the post build stage of domain creation.
A new LIBXL_HAVE_BUILDINFO_EVENT_CHANNELS #define indicates that this new field is available.
The default value of 1023 limits the domain to using the minimum amount of global mapping pages and at most 5 xenheap pages.
--- docs/man/xl.cfg.pod.5 | 11 +++++++++++ tools/libxl/libxl.h | 5 +++++ tools/libxl/libxl_create.c | 3 +++ tools/libxl/libxl_dom.c | 7 +++++++ tools/libxl/libxl_types.idl | 1 + tools/libxl/xl_cmdimpl.c | 3 +++ 6 files changed, 30 insertions(+), 0 deletions(-)
docs/man/xl.cfg.pod.5 +11 -0
@@ -572,6 +572,17 @@ Allow a guest to access specific physical IRQs. It is recommended to use this option only for trusted VMs under administrator control. +=item B<max_event_channels=N> + +Limit the guest to using at most N event channels (PV interrupts). +Guests use hypervisor resources for each event channel they use. + +The default of 1023 should be sufficient for typical guests. The +maximum value depends what the guest supports. Guests supporting the +FIFO-based event channel ABI support up to 131,071 event channels. +Other guests are limited to 4095 (64-bit x86 and ARM) or 1023 (32-bit +x86). + =back =head2 Paravirtualised (PV) Guest Specific Options
tools/libxl/libxl.h +5 -0
@@ -90,6 +90,11 @@#define LIBXL_HAVE_BUILDINFO_HVM_VENDOR_DEVICE 1/* +* The libxl_domain_build_info has the event_channels field. +*/ +#define LIBXL_HAVE_BUILDINFO_EVENT_CHANNELS 1 + +/* * libxl ABI compatibility * * The only guarantee which libxl makes regarding ABI compatibility
tools/libxl/libxl_create.c +3 -0
@@ -208,6 +208,9 @@ int libxl__domain_build_info_setdefault(libxl__gc *gc,libxl_defbool_setdefault (&b_info->disable_migrate, false); +if (!b_info->event_channels) + b_info->event_channels =1023 ; +switch (b_info->type) {case LIBXL_DOMAIN_TYPE_HVM :if (b_info->shadow_memkb ==LIBXL_MEMKB_DEFAULT )
tools/libxl/libxl_dom.c +7 -0
@@ -268,6 +268,13 @@ int libxl__build_post(libxl__gc *gc, uint32_t domid,if (rc)return rc; + rc =xc_domain_set_max_evtchn (ctx->xch, domid, info->event_channels); +if (rc) { +LOG (ERROR ,"Failed to set event channel limit to %d (%d)" , + info->event_channels, rc); +return ERROR_FAIL ; + } +libxl_cpuid_apply_policy (ctx, domid);if (info->cpuid !=NULL )libxl_cpuid_set (ctx, domid, info->cpuid);
tools/libxl/libxl_types.idl +1 -0
@@ -308,6 +308,7 @@ libxl_domain_build_info = Struct("domain_build_info",[ ("irqs", Array(uint32, "num_irqs")), ("iomem", Array(libxl_iomem_range, "num_iomem")), ("claim_mode", libxl_defbool), + ("event_channels", uint32), ("u", KeyedUnion(None, libxl_domain_type, "type", [("hvm", Struct(None, [("firmware", string), ("bios", libxl_bios_type),
tools/libxl/xl_cmdimpl.c +3 -0
@@ -844,6 +844,9 @@ static void parse_config_data(const char *config_source,if (!xlu_cfg_get_long (config,"videoram" , &l,0 )) b_info->video_memkb = l *1024 ; +if (!xlu_cfg_get_long (config,"max_event_channels" , &l,0 )) + b_info->event_channels = l; +switch (b_info->type) {case LIBXL_DOMAIN_TYPE_HVM :if (!xlu_cfg_get_string (config,"kernel" , &buf,0 ))
Signature · 1 line
1.7.2.5
Quoted 3 lines · David Vrabel
This is a complete implementation of the hypervisor and xl toolstack parts of the FIFO-based event channel ABI described in this design document:
Hi Keir,
This series has now been completely Reviewed-by Jan Beulich (hypervisor) or Acked-by Ian Campbell (tools). Could I get an Acked-by from you to get this merged in, please?
David
Quoted 74 lines · David Vrabel
This is a complete implementation of the hypervisor and xl toolstack parts of the FIFO-based event channel ABI described in this design document:
http://xenbits.xen.org/people/dvrabel/event-channels-F.pdf
The v6 version of the Linux patch series will be posted shortly and can be found in the orochi-v6 branch of:
git://xenbits.xen.org/people/dvrabel/linux.gitPatch 1-4 do some preparatory work for supporting alternate ABIs.
Patch 5 expands the number of evtchn objects a domain may have by changing how they are allocated.
Patch 6 adds the public ABI.
Patch 7 adds the
EVTCHNOP_set_priorityimplementation. This will return-ENOSYSfor ABIs that do not support priority.Patch 8* adds the FIFO-based ABI implementation.
Patch 9-10 adds the
DOMCTL_set_max_evtchnimplementation and adds a function to libxc. This will also work with the 2-level ABI.Patch 11 add the
max_event_channelsconfiguration option to xl and libxl bits needed for this.* Reviewed-by pending.
Changes in v6:
- fixed
unmap_guest_page().
- fixed flask build.Changes in v5:
- xl config option renamed to '
max_event_channels'.
- Default set by libxl is 1023.
- Fix flask (I think).
- Usedomain_page_map_to_mfn()when unmapping guest pages.
- Coding style (unsigned -> unsigned int throughout, x == NULL -> !x).Changes in v4:
- Updates for Draft F of the design.
-DOMCTL_set_max_evtchnreplacesEVTCHNOP_set_limit.
- Hypervisor defaults to unlimited event channels for for DomU.
- Optimized memory allocation for struct evtchn's when fewer than 128 are required (see patch 5).
- Addedevent_channelsoption to the xl domain configuration file and plumbed this throughlibxl_build_info. Defaults to 127.Changes in v3:
- Updates for Draft E of the design.
- Store priority in struct evtchn.
- Implementset_prioritywith generic code + hook.
- Implementset_limitand add libxc function.
- Add ABI specific output to 'e' debug key.Changes in v2:
- Updates for Draft D of the design.
- 130,000+ event channels are now supported.
-event_port.c->event_2l.cand only contains 2l functions.
- Addresses various review comments
- int -> unsigned in lots of places
- usewrite_atomic()to set HEAD
- removedMAX_EVTCHNS
-evtchn_opsare const.
- Pack struct evtchns better to reduce memory needed.