1/******************************************************************************
2 * Copyright (C) 2005 XenSource Ltd
3 *
4 * This file may be distributed separately from the Linux kernel, or
5 * incorporated into other software packages, subject to the following license:
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this source file (the "Software"), to deal in the Software without
9 * restriction, including without limitation the rights to use, copy, modify,
10 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
11 * and to permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 * IN THE SOFTWARE.
24 */
25
26/**
27 * \file xenbus.c
28 *
29 * \brief Client-facing interface for the Xenbus driver.
30 *
31 * In other words, the interface between the Xenbus and the device-specific
32 * code, be it the frontend or the backend of that driver.
33 */
34
35#if 0
36#define DPRINTK(fmt, args...) \
37    printk("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
38#else
39#define DPRINTK(fmt, args...) ((void)0)
40#endif
41
42#include <sys/cdefs.h>
43__FBSDID("$FreeBSD$");
44
45#include <sys/cdefs.h>
46#include <sys/param.h>
47#include <sys/kernel.h>
48#include <sys/types.h>
49#include <sys/malloc.h>
50#include <sys/libkern.h>
51#include <sys/sbuf.h>
52
53#include <xen/xen-os.h>
54#include <xen/hypervisor.h>
55#include <xen/evtchn.h>
56#include <xen/gnttab.h>
57#include <xen/xenbus/xenbusvar.h>
58
59#include <machine/stdarg.h>
60
61MALLOC_DEFINE(M_XENBUS, "xenbus", "XenBus Support");
62
63/*------------------------- Private Functions --------------------------------*/
64/**
65 * \brief Construct the error path corresponding to the given XenBus
66 *        device.
67 *
68 * \param dev  The XenBus device for which we are constructing an error path.
69 *
70 * \return  On success, the contructed error path.  Otherwise NULL.
71 *
72 * It is the caller's responsibility to free any returned error path
73 * node using the M_XENBUS malloc type.
74 */
75static char *
76error_path(device_t dev)
77{
78	char *path_buffer = malloc(strlen("error/")
79	    + strlen(xenbus_get_node(dev)) + 1,M_XENBUS, M_WAITOK);
80
81	strcpy(path_buffer, "error/");
82	strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
83
84	return (path_buffer);
85}
86
87/*--------------------------- Public Functions -------------------------------*/
88/*-------- API comments for these methods can be found in xenbusvar.h --------*/
89const char *
90xenbus_strstate(XenbusState state)
91{
92	static const char *const name[] = {
93		[ XenbusStateUnknown      ] = "Unknown",
94		[ XenbusStateInitialising ] = "Initialising",
95		[ XenbusStateInitWait     ] = "InitWait",
96		[ XenbusStateInitialised  ] = "Initialised",
97		[ XenbusStateConnected    ] = "Connected",
98		[ XenbusStateClosing      ] = "Closing",
99		[ XenbusStateClosed	  ] = "Closed",
100	};
101
102	return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
103}
104
105void
106xenbus_dev_verror(device_t dev, int err, const char *fmt, va_list ap)
107{
108	int ret;
109	unsigned int len;
110	char *printf_buffer = NULL, *path_buffer = NULL;
111
112#define PRINTF_BUFFER_SIZE 4096
113	printf_buffer = malloc(PRINTF_BUFFER_SIZE,M_XENBUS, M_WAITOK);
114
115	len = sprintf(printf_buffer, "%i ", err);
116	ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
117
118	KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
119	device_printf(dev, "Error %s\n", printf_buffer);
120	path_buffer = error_path(dev);
121
122	if (path_buffer == NULL) {
123		printf("xenbus: failed to write error node for %s (%s)\n",
124		       xenbus_get_node(dev), printf_buffer);
125		goto fail;
126	}
127
128	if (xs_write(XST_NIL, path_buffer, "error", printf_buffer) != 0) {
129		printf("xenbus: failed to write error node for %s (%s)\n",
130		       xenbus_get_node(dev), printf_buffer);
131		goto fail;
132	}
133
134 fail:
135	if (printf_buffer)
136		free(printf_buffer,M_XENBUS);
137	if (path_buffer)
138		free(path_buffer,M_XENBUS);
139}
140
141void
142xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
143{
144	va_list ap;
145
146	va_start(ap, fmt);
147	xenbus_dev_verror(dev, err, fmt, ap);
148	va_end(ap);
149}
150
151void
152xenbus_dev_vfatal(device_t dev, int err, const char *fmt, va_list ap)
153{
154	xenbus_dev_verror(dev, err, fmt, ap);
155	device_printf(dev, "Fatal error. Transitioning to Closing State\n");
156	xenbus_set_state(dev, XenbusStateClosing);
157}
158
159void
160xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
161{
162	va_list ap;
163
164	va_start(ap, fmt);
165	xenbus_dev_vfatal(dev, err, fmt, ap);
166	va_end(ap);
167}
168
169int
170xenbus_grant_ring(device_t dev, unsigned long ring_mfn, grant_ref_t *refp)
171{
172	int error;
173
174	error = gnttab_grant_foreign_access(
175		xenbus_get_otherend_id(dev), ring_mfn, 0, refp);
176	if (error) {
177		xenbus_dev_fatal(dev, error, "granting access to ring page");
178		return (error);
179	}
180
181	return (0);
182}
183
184XenbusState
185xenbus_read_driver_state(const char *path)
186{
187        XenbusState result;
188        int error;
189
190        error = xs_gather(XST_NIL, path, "state", "%d", &result, NULL);
191        if (error)
192                result = XenbusStateClosed;
193
194        return (result);
195}
196
197int
198xenbus_dev_is_online(device_t dev)
199{
200	const char *path;
201	int error;
202	int value;
203
204	path = xenbus_get_node(dev);
205	error = xs_gather(XST_NIL, path, "online", "%d", &value, NULL);
206	if (error != 0) {
207		/* Default to not online. */
208		value = 0;
209	}
210
211	return (value);
212}
213
214void
215xenbus_localend_changed(device_t dev, const char *path)
216{
217}
218