xenbus_probe.c 18.4 KB
Newer Older
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
/******************************************************************************
 * 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 DPRINTK(fmt, args...)				\
	pr_debug("xenbus_probe (%s:%d) " fmt ".\n",	\
		 __func__, __LINE__, ##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>
43
#include <linux/proc_fs.h>
44 45 46 47
#include <linux/notifier.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/io.h>
48
#include <linux/slab.h>
49
#include <linux/module.h>
50 51 52 53

#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/xen/hypervisor.h>
54 55

#include <xen/xen.h>
56 57 58 59
#include <xen/xenbus.h>
#include <xen/events.h>
#include <xen/page.h>

60 61
#include <xen/hvm.h>

62 63 64
#include "xenbus_comms.h"
#include "xenbus_probe.h"

65

66
int xen_store_evtchn;
67
EXPORT_SYMBOL_GPL(xen_store_evtchn);
68

69
struct xenstore_domain_interface *xen_store_interface;
70 71
EXPORT_SYMBOL_GPL(xen_store_interface);

72 73 74
enum xenstore_init xen_store_domain_type;
EXPORT_SYMBOL_GPL(xen_store_domain_type);

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
static unsigned long xen_store_mfn;

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)
{
	for (; *arr->devicetype != '\0'; arr++) {
		if (!strcmp(arr->devicetype, dev->devicetype))
			return arr;
	}
	return NULL;
}

int xenbus_match(struct device *_dev, struct device_driver *_drv)
{
	struct xenbus_driver *drv = to_xenbus_driver(_drv);

	if (!drv->ids)
		return 0;

	return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
}
99 100
EXPORT_SYMBOL_GPL(xenbus_match);

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

static void free_otherend_details(struct xenbus_device *dev)
{
	kfree(dev->otherend);
	dev->otherend = NULL;
}


static void free_otherend_watch(struct xenbus_device *dev)
{
	if (dev->otherend_watch.node) {
		unregister_xenbus_watch(&dev->otherend_watch);
		kfree(dev->otherend_watch.node);
		dev->otherend_watch.node = NULL;
	}
}


119 120 121 122 123 124 125 126 127 128 129 130 131 132
static int talk_to_otherend(struct xenbus_device *dev)
{
	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);

	free_otherend_watch(dev);
	free_otherend_details(dev);

	return drv->read_otherend_details(dev);
}



static int watch_otherend(struct xenbus_device *dev)
{
133 134
	struct xen_bus_type *bus =
		container_of(dev->dev.bus, struct xen_bus_type, bus);
135

136 137
	return xenbus_watch_pathfmt(dev, &dev->otherend_watch,
				    bus->otherend_changed,
138 139 140 141 142
				    "%s/%s", dev->otherend, "state");
}


int xenbus_read_otherend_details(struct xenbus_device *xendev,
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
				 char *id_node, char *path_node)
{
	int err = xenbus_gather(XBT_NIL, xendev->nodename,
				id_node, "%i", &xendev->otherend_id,
				path_node, NULL, &xendev->otherend,
				NULL);
	if (err) {
		xenbus_dev_fatal(xendev, err,
				 "reading other end details from %s",
				 xendev->nodename);
		return err;
	}
	if (strlen(xendev->otherend) == 0 ||
	    !xenbus_exists(XBT_NIL, xendev->otherend, "")) {
		xenbus_dev_fatal(xendev, -ENOENT,
				 "unable to read other end from %s.  "
				 "missing or inaccessible.",
				 xendev->nodename);
		free_otherend_details(xendev);
		return -ENOENT;
	}

	return 0;
}
167
EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
168

169 170 171
void xenbus_otherend_changed(struct xenbus_watch *watch,
			     const char **vec, unsigned int len,
			     int ignore_on_shutdown)
172 173 174 175 176 177 178 179 180 181 182
{
	struct xenbus_device *dev =
		container_of(watch, struct xenbus_device, otherend_watch);
	struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
	enum xenbus_state state;

	/* Protect us against watches firing on old details when the otherend
	   details change, say immediately after a resume. */
	if (!dev->otherend ||
	    strncmp(dev->otherend, vec[XS_WATCH_PATH],
		    strlen(dev->otherend))) {
183 184
		dev_dbg(&dev->dev, "Ignoring watch at %s\n",
			vec[XS_WATCH_PATH]);
185 186 187 188 189
		return;
	}

	state = xenbus_read_driver_state(dev->otherend);

190
	dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
191 192 193 194 195 196 197 198
		state, xenbus_strstate(state), dev->otherend_watch.node,
		vec[XS_WATCH_PATH]);

	/*
	 * Ignore xenbus transitions during shutdown. This prevents us doing
	 * work that can fail e.g., when the rootfs is gone.
	 */
	if (system_state > SYSTEM_RUNNING) {
199
		if (ignore_on_shutdown && (state == XenbusStateClosing))
200 201 202 203 204 205 206
			xenbus_frontend_closed(dev);
		return;
	}

	if (drv->otherend_changed)
		drv->otherend_changed(dev, state);
}
207
EXPORT_SYMBOL_GPL(xenbus_otherend_changed);
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250

int xenbus_dev_probe(struct device *_dev)
{
	struct xenbus_device *dev = to_xenbus_device(_dev);
	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
	const struct xenbus_device_id *id;
	int err;

	DPRINTK("%s", dev->nodename);

	if (!drv->probe) {
		err = -ENODEV;
		goto fail;
	}

	id = match_device(drv->ids, dev);
	if (!id) {
		err = -ENODEV;
		goto fail;
	}

	err = talk_to_otherend(dev);
	if (err) {
		dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n",
			 dev->nodename);
		return err;
	}

	err = drv->probe(dev, id);
	if (err)
		goto fail;

	err = watch_otherend(dev);
	if (err) {
		dev_warn(&dev->dev, "watch_otherend on %s failed.\n",
		       dev->nodename);
		return err;
	}

	return 0;
fail:
	xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
	xenbus_switch_state(dev, XenbusStateClosed);
251
	return err;
252
}
253
EXPORT_SYMBOL_GPL(xenbus_dev_probe);
254 255 256 257 258 259 260 261 262 263 264 265 266

int xenbus_dev_remove(struct device *_dev)
{
	struct xenbus_device *dev = to_xenbus_device(_dev);
	struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);

	DPRINTK("%s", dev->nodename);

	free_otherend_watch(dev);

	if (drv->remove)
		drv->remove(dev);

267 268
	free_otherend_details(dev);

269 270 271
	xenbus_switch_state(dev, XenbusStateClosed);
	return 0;
}
272
EXPORT_SYMBOL_GPL(xenbus_dev_remove);
273

274
void xenbus_dev_shutdown(struct device *_dev)
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
{
	struct xenbus_device *dev = to_xenbus_device(_dev);
	unsigned long timeout = 5*HZ;

	DPRINTK("%s", dev->nodename);

	get_device(&dev->dev);
	if (dev->state != XenbusStateConnected) {
		printk(KERN_INFO "%s: %s: %s != Connected, skipping\n", __func__,
		       dev->nodename, xenbus_strstate(dev->state));
		goto out;
	}
	xenbus_switch_state(dev, XenbusStateClosing);
	timeout = wait_for_completion_timeout(&dev->down, timeout);
	if (!timeout)
		printk(KERN_INFO "%s: %s timeout closing device\n",
		       __func__, dev->nodename);
 out:
	put_device(&dev->dev);
}
295
EXPORT_SYMBOL_GPL(xenbus_dev_shutdown);
296 297

int xenbus_register_driver_common(struct xenbus_driver *drv,
298
				  struct xen_bus_type *bus)
299 300 301 302 303
{
	drv->driver.bus = &bus->bus;

	return driver_register(&drv->driver);
}
304
EXPORT_SYMBOL_GPL(xenbus_register_driver_common);
305 306 307 308 309 310 311

void xenbus_unregister_driver(struct xenbus_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL_GPL(xenbus_unregister_driver);

312
struct xb_find_info {
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
	struct xenbus_device *dev;
	const char *nodename;
};

static int cmp_dev(struct device *dev, void *data)
{
	struct xenbus_device *xendev = to_xenbus_device(dev);
	struct xb_find_info *info = data;

	if (!strcmp(xendev->nodename, info->nodename)) {
		info->dev = xendev;
		get_device(dev);
		return 1;
	}
	return 0;
}

330 331
static struct xenbus_device *xenbus_device_find(const char *nodename,
						struct bus_type *bus)
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
{
	struct xb_find_info info = { .dev = NULL, .nodename = nodename };

	bus_for_each_dev(bus, NULL, &info, cmp_dev);
	return info.dev;
}

static int cleanup_dev(struct device *dev, void *data)
{
	struct xenbus_device *xendev = to_xenbus_device(dev);
	struct xb_find_info *info = data;
	int len = strlen(info->nodename);

	DPRINTK("%s", info->nodename);

	/* Match the info->nodename path, or any subdirectory of that path. */
	if (strncmp(xendev->nodename, info->nodename, len))
		return 0;

	/* If the node name is longer, ensure it really is a subdirectory. */
	if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/'))
		return 0;

	info->dev = xendev;
	get_device(dev);
	return 1;
}

static void xenbus_cleanup_devices(const char *path, struct bus_type *bus)
{
	struct xb_find_info info = { .nodename = path };

	do {
		info.dev = NULL;
		bus_for_each_dev(bus, NULL, &info, cleanup_dev);
		if (info.dev) {
			device_unregister(&info.dev->dev);
			put_device(&info.dev->dev);
		}
	} while (info.dev);
}

static void xenbus_dev_release(struct device *dev)
{
	if (dev)
		kfree(to_xenbus_device(dev));
}

380 381
static ssize_t nodename_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
382 383 384 385
{
	return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
}

386 387
static ssize_t devtype_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
388 389 390 391
{
	return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
}

392 393
static ssize_t modalias_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
394
{
395 396
	return sprintf(buf, "%s:%s\n", dev->bus->name,
		       to_xenbus_device(dev)->devicetype);
397
}
398 399 400 401 402 403 404 405

struct device_attribute xenbus_dev_attrs[] = {
	__ATTR_RO(nodename),
	__ATTR_RO(devtype),
	__ATTR_RO(modalias),
	__ATTR_NULL
};
EXPORT_SYMBOL_GPL(xenbus_dev_attrs);
406 407 408 409 410

int xenbus_probe_node(struct xen_bus_type *bus,
		      const char *type,
		      const char *nodename)
{
411
	char devname[XEN_BUS_ID_SIZE];
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
	int err;
	struct xenbus_device *xendev;
	size_t stringlen;
	char *tmpstring;

	enum xenbus_state state = xenbus_read_driver_state(nodename);

	if (state != XenbusStateInitialising) {
		/* Device is not new, so ignore it.  This can happen if a
		   device is going away after switching to Closed.  */
		return 0;
	}

	stringlen = strlen(nodename) + 1 + strlen(type) + 1;
	xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL);
	if (!xendev)
		return -ENOMEM;

	xendev->state = XenbusStateInitialising;

	/* Copy the strings into the extra space. */

	tmpstring = (char *)(xendev + 1);
	strcpy(tmpstring, nodename);
	xendev->nodename = tmpstring;

	tmpstring += strlen(tmpstring) + 1;
	strcpy(tmpstring, type);
	xendev->devicetype = tmpstring;
	init_completion(&xendev->down);

	xendev->dev.bus = &bus->bus;
	xendev->dev.release = xenbus_dev_release;

446
	err = bus->get_bus_id(devname, xendev->nodename);
447 448 449
	if (err)
		goto fail;

450
	dev_set_name(&xendev->dev, "%s", devname);
451

452 453 454 455 456 457 458 459 460 461
	/* Register with generic device framework. */
	err = device_register(&xendev->dev);
	if (err)
		goto fail;

	return 0;
fail:
	kfree(xendev);
	return err;
}
462
EXPORT_SYMBOL_GPL(xenbus_probe_node);
463 464 465 466 467 468 469 470 471

static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
{
	int err = 0;
	char **dir;
	unsigned int dir_n = 0;
	int i;

	dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n);
472
	if (IS_ERR(dir))
473 474 475
		return PTR_ERR(dir);

	for (i = 0; i < dir_n; i++) {
476
		err = bus->probe(bus, type, dir[i]);
477
		if (err)
478 479
			break;
	}
480

481 482 483 484 485 486 487 488 489 490 491
	kfree(dir);
	return err;
}

int xenbus_probe_devices(struct xen_bus_type *bus)
{
	int err = 0;
	char **dir;
	unsigned int i, dir_n;

	dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);
492
	if (IS_ERR(dir))
493 494 495 496
		return PTR_ERR(dir);

	for (i = 0; i < dir_n; i++) {
		err = xenbus_probe_device_type(bus, dir[i]);
497
		if (err)
498 499
			break;
	}
500

501 502 503
	kfree(dir);
	return err;
}
504
EXPORT_SYMBOL_GPL(xenbus_probe_devices);
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532

static unsigned int char_count(const char *str, char c)
{
	unsigned int i, ret = 0;

	for (i = 0; str[i]; i++)
		if (str[i] == c)
			ret++;
	return ret;
}

static int strsep_len(const char *str, char c, unsigned int len)
{
	unsigned int i;

	for (i = 0; str[i]; i++)
		if (str[i] == c) {
			if (len == 0)
				return i;
			len--;
		}
	return (len == 0) ? i : -ERANGE;
}

void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
{
	int exists, rootlen;
	struct xenbus_device *dev;
533
	char type[XEN_BUS_ID_SIZE];
534 535 536 537 538 539 540 541 542 543 544 545 546
	const char *p, *root;

	if (char_count(node, '/') < 2)
		return;

	exists = xenbus_exists(XBT_NIL, node, "");
	if (!exists) {
		xenbus_cleanup_devices(node, &bus->bus);
		return;
	}

	/* backend/<type>/... or device/<type>/... */
	p = strchr(node, '/') + 1;
547 548
	snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
	type[XEN_BUS_ID_SIZE-1] = '\0';
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564

	rootlen = strsep_len(node, '/', bus->levels);
	if (rootlen < 0)
		return;
	root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node);
	if (!root)
		return;

	dev = xenbus_device_find(root, &bus->bus);
	if (!dev)
		xenbus_probe_node(bus, type, root);
	else
		put_device(&dev->dev);

	kfree(root);
}
565
EXPORT_SYMBOL_GPL(xenbus_dev_changed);
566

567
int xenbus_dev_suspend(struct device *dev)
568 569 570
{
	int err = 0;
	struct xenbus_driver *drv;
571 572
	struct xenbus_device *xdev
		= container_of(dev, struct xenbus_device, dev);
573

574
	DPRINTK("%s", xdev->nodename);
575 576 577 578 579

	if (dev->driver == NULL)
		return 0;
	drv = to_xenbus_driver(dev->driver);
	if (drv->suspend)
580
		err = drv->suspend(xdev);
581 582
	if (err)
		printk(KERN_WARNING
583
		       "xenbus: suspend %s failed: %i\n", dev_name(dev), err);
584 585
	return 0;
}
586
EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
587

588
int xenbus_dev_resume(struct device *dev)
589 590 591
{
	int err;
	struct xenbus_driver *drv;
592 593
	struct xenbus_device *xdev
		= container_of(dev, struct xenbus_device, dev);
594

595
	DPRINTK("%s", xdev->nodename);
596 597 598 599 600 601 602 603

	if (dev->driver == NULL)
		return 0;
	drv = to_xenbus_driver(dev->driver);
	err = talk_to_otherend(xdev);
	if (err) {
		printk(KERN_WARNING
		       "xenbus: resume (talk_to_otherend) %s failed: %i\n",
604
		       dev_name(dev), err);
605 606 607 608 609 610 611 612 613 614
		return err;
	}

	xdev->state = XenbusStateInitialising;

	if (drv->resume) {
		err = drv->resume(xdev);
		if (err) {
			printk(KERN_WARNING
			       "xenbus: resume %s failed: %i\n",
615
			       dev_name(dev), err);
616 617 618 619 620 621 622 623
			return err;
		}
	}

	err = watch_otherend(xdev);
	if (err) {
		printk(KERN_WARNING
		       "xenbus_probe: resume (watch_otherend) %s failed: "
624
		       "%d.\n", dev_name(dev), err);
625 626 627 628 629
		return err;
	}

	return 0;
}
630
EXPORT_SYMBOL_GPL(xenbus_dev_resume);
631

632 633 634 635 636 637 638 639
int xenbus_dev_cancel(struct device *dev)
{
	/* Do nothing */
	DPRINTK("cancel");
	return 0;
}
EXPORT_SYMBOL_GPL(xenbus_dev_cancel);

640
/* A flag to determine if xenstored is 'ready' (i.e. has started) */
641
int xenstored_ready;
642 643 644 645 646 647


int register_xenstore_notifier(struct notifier_block *nb)
{
	int ret = 0;

648 649 650 651
	if (xenstored_ready > 0)
		ret = nb->notifier_call(nb, 0, NULL);
	else
		blocking_notifier_chain_register(&xenstore_chain, nb);
652 653 654 655 656 657 658 659 660 661 662 663 664

	return ret;
}
EXPORT_SYMBOL_GPL(register_xenstore_notifier);

void unregister_xenstore_notifier(struct notifier_block *nb)
{
	blocking_notifier_chain_unregister(&xenstore_chain, nb);
}
EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);

void xenbus_probe(struct work_struct *unused)
{
665
	xenstored_ready = 1;
666 667 668 669

	/* Notify others that xenstore is up */
	blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
}
670
EXPORT_SYMBOL_GPL(xenbus_probe);
671

672 673 674 675 676 677 678 679 680 681 682 683 684 685
static int __init xenbus_probe_initcall(void)
{
	if (!xen_domain())
		return -ENODEV;

	if (xen_initial_domain() || xen_hvm_domain())
		return 0;

	xenbus_probe(NULL);
	return 0;
}

device_initcall(xenbus_probe_initcall);

686 687 688 689
/* 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)
690 691
{
	int err = 0;
692
	unsigned long page = 0;
693
	struct evtchn_alloc_unbound alloc_unbound;
694

695 696 697 698
	/* Allocate Xenstore page */
	page = get_zeroed_page(GFP_KERNEL);
	if (!page)
		goto out_err;
699

700 701 702
	xen_store_mfn = xen_start_info->store_mfn =
		pfn_to_mfn(virt_to_phys((void *)page) >>
			   PAGE_SHIFT);
703

704 705 706
	/* Next allocate a local port which xenstored can bind to */
	alloc_unbound.dom        = DOMID_SELF;
	alloc_unbound.remote_dom = DOMID_SELF;
707

708 709 710 711
	err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
					  &alloc_unbound);
	if (err == -ENOSYS)
		goto out_err;
712

713 714 715
	BUG_ON(err);
	xen_store_evtchn = xen_start_info->store_evtchn =
		alloc_unbound.port;
716

717
	return 0;
718

719 720 721 722 723
 out_err:
	if (page != 0)
		free_page(page);
	return err;
}
724

725 726 727
static int __init xenbus_init(void)
{
	int err = 0;
728
	uint64_t v = 0;
729
	xen_store_domain_type = XS_UNKNOWN;
730

731 732 733
	if (!xen_domain())
		return -ENODEV;

Daniel De Graaf's avatar
Daniel De Graaf committed
734 735
	xenbus_ring_ops_init();

736
	if (xen_pv_domain())
737
		xen_store_domain_type = XS_PV;
738
	if (xen_hvm_domain())
739
		xen_store_domain_type = XS_HVM;
740
	if (xen_hvm_domain() && xen_initial_domain())
741
		xen_store_domain_type = XS_LOCAL;
742
	if (xen_pv_domain() && !xen_start_info->store_evtchn)
743
		xen_store_domain_type = XS_LOCAL;
744 745 746
	if (xen_pv_domain() && xen_start_info->store_evtchn)
		xenstored_ready = 1;

747 748
	switch (xen_store_domain_type) {
	case XS_LOCAL:
749 750 751 752 753
		err = xenstored_local_init();
		if (err)
			goto out_error;
		xen_store_interface = mfn_to_virt(xen_store_mfn);
		break;
754
	case XS_PV:
755 756 757 758
		xen_store_evtchn = xen_start_info->store_evtchn;
		xen_store_mfn = xen_start_info->store_mfn;
		xen_store_interface = mfn_to_virt(xen_store_mfn);
		break;
759
	case XS_HVM:
760 761 762 763 764 765 766 767
		err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
		if (err)
			goto out_error;
		xen_store_evtchn = (int)v;
		err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
		if (err)
			goto out_error;
		xen_store_mfn = (unsigned long)v;
768
		xen_store_interface =
769
			xen_remap(xen_store_mfn << PAGE_SHIFT, PAGE_SIZE);
770 771 772 773
		break;
	default:
		pr_warn("Xenstore state unknown\n");
		break;
774 775 776 777 778 779 780
	}

	/* Initialize the interface to xenstore. */
	err = xs_init();
	if (err) {
		printk(KERN_WARNING
		       "XENBUS: Error initializing xenstore comms: %i\n", err);
781
		goto out_error;
782 783
	}

784 785 786 787 788 789 790 791
#ifdef CONFIG_XEN_COMPAT_XENFS
	/*
	 * Create xenfs mountpoint in /proc for compatibility with
	 * utilities that expect to find "xenbus" under "/proc/xen".
	 */
	proc_mkdir("xen", NULL);
#endif

792
out_error:
793 794 795
	return err;
}

796
postcore_initcall(xenbus_init);
797 798

MODULE_LICENSE("GPL");