#define pr_fmt(fmt) …
#define dev_fmt …
#define DPRINTK(fmt, args...) …
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/notifier.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <asm/page.h>
#include <asm/xen/hypervisor.h>
#include <xen/xen.h>
#include <xen/xenbus.h>
#include <xen/events.h>
#include <xen/xen-ops.h>
#include <xen/page.h>
#include <xen/hvm.h>
#include "xenbus.h"
static int xs_init_irq = …;
int xen_store_evtchn;
EXPORT_SYMBOL_GPL(…);
struct xenstore_domain_interface *xen_store_interface;
EXPORT_SYMBOL_GPL(…);
#define XS_INTERFACE_READY …
enum xenstore_init xen_store_domain_type;
EXPORT_SYMBOL_GPL(…);
static unsigned long xen_store_gfn;
static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
static const struct xenbus_device_id *
match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
{ … }
int xenbus_match(struct device *_dev, const struct device_driver *_drv)
{ … }
EXPORT_SYMBOL_GPL(…);
static void free_otherend_details(struct xenbus_device *dev)
{ … }
static void free_otherend_watch(struct xenbus_device *dev)
{ … }
static int talk_to_otherend(struct xenbus_device *dev)
{ … }
static int watch_otherend(struct xenbus_device *dev)
{ … }
int xenbus_read_otherend_details(struct xenbus_device *xendev,
char *id_node, char *path_node)
{ … }
EXPORT_SYMBOL_GPL(…);
void xenbus_otherend_changed(struct xenbus_watch *watch,
const char *path, const char *token,
int ignore_on_shutdown)
{ … }
EXPORT_SYMBOL_GPL(…);
#define XENBUS_SHOW_STAT(name) …
XENBUS_SHOW_STAT(…);
XENBUS_SHOW_STAT(…);
XENBUS_SHOW_STAT(…);
XENBUS_SHOW_STAT(…);
static ssize_t spurious_threshold_show(struct device *_dev,
struct device_attribute *attr,
char *buf)
{ … }
static ssize_t spurious_threshold_store(struct device *_dev,
struct device_attribute *attr,
const char *buf, size_t count)
{ … }
static DEVICE_ATTR_RW(spurious_threshold);
static struct attribute *xenbus_attrs[] = …;
static const struct attribute_group xenbus_group = …;
int xenbus_dev_probe(struct device *_dev)
{ … }
EXPORT_SYMBOL_GPL(…);
void xenbus_dev_remove(struct device *_dev)
{ … }
EXPORT_SYMBOL_GPL(…);
int xenbus_register_driver_common(struct xenbus_driver *drv,
struct xen_bus_type *bus,
struct module *owner, const char *mod_name)
{ … }
EXPORT_SYMBOL_GPL(…);
void xenbus_unregister_driver(struct xenbus_driver *drv)
{ … }
EXPORT_SYMBOL_GPL(…);
struct xb_find_info { … };
static int cmp_dev(struct device *dev, void *data)
{ … }
static struct xenbus_device *xenbus_device_find(const char *nodename,
struct bus_type *bus)
{ … }
static int cleanup_dev(struct device *dev, void *data)
{ … }
static void xenbus_cleanup_devices(const char *path, struct bus_type *bus)
{ … }
static void xenbus_dev_release(struct device *dev)
{ … }
static ssize_t nodename_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(nodename);
static ssize_t devtype_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(devtype);
static ssize_t modalias_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(modalias);
static ssize_t state_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(state);
static struct attribute *xenbus_dev_attrs[] = …;
static const struct attribute_group xenbus_dev_group = …;
const struct attribute_group *xenbus_dev_groups[] = …;
EXPORT_SYMBOL_GPL(…);
int xenbus_probe_node(struct xen_bus_type *bus,
const char *type,
const char *nodename)
{ … }
EXPORT_SYMBOL_GPL(…);
static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
{ … }
int xenbus_probe_devices(struct xen_bus_type *bus)
{ … }
EXPORT_SYMBOL_GPL(…);
static unsigned int char_count(const char *str, char c)
{ … }
static int strsep_len(const char *str, char c, unsigned int len)
{ … }
void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
{ … }
EXPORT_SYMBOL_GPL(…);
int xenbus_dev_suspend(struct device *dev)
{ … }
EXPORT_SYMBOL_GPL(…);
int xenbus_dev_resume(struct device *dev)
{ … }
EXPORT_SYMBOL_GPL(…);
int xenbus_dev_cancel(struct device *dev)
{ … }
EXPORT_SYMBOL_GPL(…);
int xenstored_ready;
int register_xenstore_notifier(struct notifier_block *nb)
{ … }
EXPORT_SYMBOL_GPL(…);
void unregister_xenstore_notifier(struct notifier_block *nb)
{ … }
EXPORT_SYMBOL_GPL(…);
static void xenbus_probe(void)
{ … }
static bool xs_hvm_defer_init_for_callback(void)
{ … }
static int xenbus_probe_thread(void *unused)
{ … }
static int __init xenbus_probe_initcall(void)
{ … }
device_initcall(xenbus_probe_initcall);
int xen_set_callback_via(uint64_t via)
{ … }
EXPORT_SYMBOL_GPL(…);
static int __init xenstored_local_init(void)
{ … }
static int xenbus_resume_cb(struct notifier_block *nb,
unsigned long action, void *data)
{ … }
static struct notifier_block xenbus_resume_nb = …;
static irqreturn_t xenbus_late_init(int irq, void *unused)
{ … }
static int __init xenbus_init(void)
{ … }
postcore_initcall(xenbus_init);
MODULE_LICENSE(…) …;