/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
*
* xenbus.h (renamed to xenbus_impl.h)
*
* Talks to Xen Store to figure out what devices we have.
*
* Copyright (C) 2005 Rusty Russell, IBM Corporation
*
* This file may be distributed separately from the Linux kernel, or
* incorporated into other software packages, subject to the following license:
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this source file (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy, modify,
* and to permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#ifndef _SYS_XENBUS_H
#define _SYS_XENBUS_H
#ifdef __cplusplus
extern "C" {
#endif
#define XBT_NULL 0
/* Register callback to watch this node. */
struct xenbus_watch;
struct xenbus_watch {
};
/*
* Call this function when xenstore is available, i.e. the daemon is
* connected to the xenbus device.
*/
struct xenbus_notify {
void (*notify_func) (int);
};
/* A xenbus device. */
struct xenbus_device {
const char *devicetype;
const char *nodename;
const char *otherend;
int otherend_id;
int otherend_state;
int has_error;
int frontend;
void *data;
};
void *arg);
typedef struct xd_xb_watches {
int xxw_ref;
void *xxw_arg;
const char *node);
const char *node);
extern int xenbus_transaction_start(xenbus_transaction_t *t);
/* Single read and scanf: returns errno or num scanned if > 0. */
/* Single printf and write: returns errno or 0. */
/*
* Generic read function: NULL-terminated triples of name,
* sprintf-style type string, and pointer. Returns 0 or errno.
*/
extern void reregister_xenbus_watches(void);
/* Called from xen core code. */
extern void xenbus_suspend(void);
extern void xenbus_resume(void);
/*
* Register a watch on the given path, using the given xenbus_watch structure
* for storage, and the given callback function as the callback. Return 0 on
* success, or errno on error. On success, the given path will be saved as
* watch->node, and remains the caller's to free. On error, watch->node will
* be NULL, the device will switch to XenbusStateClosing, and the error will
* be saved in the store.
*/
struct xenbus_watch *watch,
void (*callback)(struct xenbus_watch *,
const char **, unsigned int));
/*
* structure for storage, and the given callback function as the callback.
* Return 0 on success, or errno on error. On success, the watched path
* kfree(). On error, watch->node will be NULL, so the caller has nothing to
* free, the device will switch to XenbusStateClosing, and the error will be
* saved in the store.
*/
void (*callback)(struct xenbus_watch *,
const char **, unsigned int));
/*
* Advertise in the store a change of the given driver to the given new_state.
* Perform the change inside the given transaction xbt. xbt may be NULL, in
* which case this is performed inside its own transaction. Return 0 on
* success, or errno on error. On error, the device will switch to
* XenbusStateClosing, and the error will be saved in the store.
*/
/*
* Grant access to the given ring_mfn to the peer of the given device. Return
* 0 on success, or errno on error. On error, the device will switch to
* XenbusStateClosing, and the error will be saved in the store.
*/
/*
* Allocate an event channel for the given xenbus_device, assigning the newly
* created local port to *port. Return 0 on success, or errno on error. On
* error, the device will switch to XenbusStateClosing, and the error will be
* saved in the store.
*/
/*
* Return the state of the driver rooted at the given store path, or
* XenbusStateClosed if no state can be read.
*/
/*
* Report the given negative errno into the store, along with the given
* formatted message.
*/
const char *fmt, ...);
/*
* Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
* xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
* closedown of this driver and its peer.
*/
/* Clear any error. */
/*
* Set up watches on other end of split device.
*/
/*
* Register a notify callback function.
*/
extern int xs_register_xenbus_callback(void (*callback)(int));
/*
* Notify clients that xenstore is up
*/
extern void xs_notify_xenstore_up(void);
/*
* Notify clients that xenstore is down
*/
extern void xs_notify_xenstore_down(void);
struct xsd_sockmsg;
extern int xenbus_dev_request_and_reply(struct xsd_sockmsg *, void **);
#ifdef __cplusplus
}
#endif
#endif /* _SYS_XENBUS_H */