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
104
105
106
107
108
109
110
111
112
113
114
|
/******************************************************************************
* ctrl_if.h
*
* Management functions for special interface to the domain controller.
*
* Copyright (c) 2004, K A Fraser
*/
#ifndef __ASM_XEN__CTRL_IF_H__
#define __ASM_XEN__CTRL_IF_H__
#include <asm/hypervisor.h>
typedef control_msg_t ctrl_msg_t;
/*
* Callback function type. Called for asynchronous processing of received
* request messages, and responses to previously-transmitted request messages.
* The parameters are (@msg, @id).
* @msg: Original request/response message (not a copy). The message can be
* modified in-place by the handler (e.g., a response callback can
* turn a request message into a response message in place). The message
* is no longer accessible after the callback handler returns -- if the
* message is required to persist for longer then it must be copied.
* @id: (Response callbacks only) The 'id' that was specified when the
* original request message was queued for transmission.
*/
typedef void (*ctrl_msg_handler_t)(ctrl_msg_t *, unsigned long);
/*
* Send @msg to the domain controller. Execute @hnd when a response is
* received, passing the response message and the specified @id. This
* operation will not block: it will return -EAGAIN if there is no space.
* Notes:
* 1. The @msg is copied if it is transmitted and so can be freed after this
* function returns.
* 2. If @hnd is NULL then no callback is executed.
*/
int ctrl_if_send_message_noblock(
ctrl_msg_t *msg,
ctrl_msg_handler_t hnd,
unsigned long id);
/*
* Send @msg to the domain controller. Execute @hnd when a response is
* received, passing the response message and the specified @id. This
* operation will block until the message is sent, or a signal is received
* for the calling process (unless @wait_state is TASK_UNINTERRUPTIBLE).
* Notes:
* 1. The @msg is copied if it is transmitted and so can be freed after this
* function returns.
* 2. If @hnd is NULL then no callback is executed.
*/
int ctrl_if_send_message(
ctrl_msg_t *msg,
ctrl_msg_handler_t hnd,
unsigned long id,
long wait_state);
/*
* Request a callback when there is /possibly/ space to immediately send a
* message to the domain controller. This function returns 0 if there is
* already space to trasnmit a message --- in this case the callback task /may/
* still be executed. If this function returns 1 then the callback /will/ be
* executed when space becomes available.
*/
int ctrl_if_enqueue_space_callback(struct tq_struct *task);
/*
* Send a response (@msg) to a message from the domain controller. This will
* never block.
* Notes:
* 1. The @msg is copied and so can be freed after this function returns.
* 2. The @msg may be the original request message, modified in-place.
*/
void ctrl_if_send_response(ctrl_msg_t *msg);
/*
* Register a receiver for typed messages from the domain controller. The
* handler (@hnd) is called for every received message of specified @type.
* Returns TRUE (non-zero) if the handler was successfully registered.
*/
int ctrl_if_register_receiver(u8 type, ctrl_msg_handler_t hnd);
/*
* Unregister a receiver for typed messages from the domain controller. The
* handler (@hnd) will not be executed after this function returns.
*/
void ctrl_if_unregister_receiver(u8 type, ctrl_msg_handler_t hnd);
/* Suspend/resume notifications. */
void ctrl_if_suspend(void);
void ctrl_if_resume(void);
/* Start-of-day setup. */
void ctrl_if_init(void);
/*
* Returns TRUE if there are no outstanding message requests at the domain
* controller. This can be used to ensure that messages have really flushed
* through when it is not possible to use the response-callback interface.
* WARNING: If other subsystems are using the control interface then this
* function might never return TRUE!
*/
int ctrl_if_transmitter_empty(void); /* !! DANGEROUS FUNCTION !! */
/*
* Manually discard response messages from the domain controller.
* WARNING: This is usually done automatically -- this function should only
* be called when normal interrupt mechanisms are disabled!
*/
void ctrl_if_discard_responses(void); /* !! DANGEROUS FUNCTION !! */
#endif /* __ASM_XEN__CONTROL_IF_H__ */
|