linux/drivers/xen/xenbus/xenbus_probe.c

/******************************************************************************
 * Talks to Xen Store to figure out what devices we have.
 *
 * Copyright (C) 2005 Rusty Russell, IBM Corporation
 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
 * Copyright (C) 2005, 2006 XenSource Ltd
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation; or, when 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,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * 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.
 */

#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);

/* If something in array of ids matches this device, return it. */
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();

/* A flag to determine if xenstored is 'ready' (i.e. has started) */
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)
{}

/*
 * Returns true when XenStore init must be deferred in order to
 * allow the PCI platform device to be initialised, before we
 * can actually have event channel interrupts working.
 */
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();

/* Set up event channel for xenstored which is run as a local process
 * (this is normally used only in dom0)
 */
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();