N-sim Emulation and simulation of Wireless Sensor Networks    Home    Project Page    Download    CVS    Installation    Configuration    Plug-ins  Hosted by

/home/brennan/n-sim/OrbisQuartus/server/xen/backend/sdev_bus.c Go to the documentation of this file. /* * Copyright (C) 2005 Rusty Russell <rusty@rustcorp.com.au> * Copyright (C) 2005 XenSource Ltd * * Copyright 2006. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * Additionally, this program is free software; you can redistribute it * and/or modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. Accordingly, this * program is distributed in the hope it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. ****************************** * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include <stdarg.h> #include <linux/module.h> #include <xen/xenbus.h> #include <xen/net_driver_util.h> #include "sdev.h" struct backend_info { struct xenbus_device *dev; sdev_t *sdev; struct xenbus_watch backend_watch; XenbusState frontend_state; }; static int connect_rings(struct backend_info *); static void connect(struct backend_info *); static void maybe_connect(struct backend_info *); static void backend_changed(struct xenbus_watch *, const char **, unsigned int); static int sdevback_remove(struct xenbus_device *dev) { struct backend_info *be = dev->data; if (be->backend_watch.node) { unregister_xenbus_watch(&be->backend_watch); kfree(be->backend_watch.node); be->backend_watch.node = NULL; } if (be->sdev) { sdev_disconnect(be->sdev); be->sdev = NULL; } kfree(be); dev->data = NULL; return 0; } static int sdevback_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { int err; struct backend_info *be = kzalloc(sizeof(struct backend_info), GFP_KERNEL); if (!be) { xenbus_dev_fatal(dev, -ENOMEM, "allocating backend structure"); return -ENOMEM; } be->dev = dev; dev->data = be; err = xenbus_watch_path2(dev, dev->nodename, "handle", &be->backend_watch, backend_changed); if (err) goto fail; err = xenbus_switch_state(dev, XenbusStateInitWait); if (err) { goto fail; } return 0; fail: DPRINTK("failed"); sdevback_remove(dev); return err; } static int sdevback_uevent(struct xenbus_device *xdev, char **envp, int num_envp, char *buffer, int buffer_size) { struct backend_info *be = xdev->data; sdev_t *sdev = be->sdev; int i = 0, length = 0; char *val; DPRINTK("sdevback_uevent"); val = xenbus_read(XBT_NULL, xdev->nodename, "script", NULL); if (IS_ERR(val)) { int err = PTR_ERR(val); xenbus_dev_fatal(xdev, err, "reading script"); return err; } else { add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, "script=%s", val); kfree(val); } add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, "vwif=%s", sdev->dev->name); envp[i] = NULL; return 0; } static void backend_changed(struct xenbus_watch *watch, const char **vec, unsigned int len) { int err; long handle; struct backend_info *be = container_of(watch, struct backend_info, backend_watch); struct xenbus_device *dev = be->dev; DPRINTK(""); err = xenbus_scanf(XBT_NULL, dev->nodename, "handle", "%li", &handle); if (XENBUS_EXIST_ERR(err)) { /* Since this watch will fire once immediately after it is registered, we expect this. Ignore it, and wait for the hotplug scripts. */ return; } if (err != 1) { xenbus_dev_fatal(dev, err, "reading handle"); return; } if (be->sdev == NULL) { u8 be_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 }; be->sdev = alloc_sdev(dev->otherend_id, handle, be_mac); if (IS_ERR(be->sdev)) { err = PTR_ERR(be->sdev); be->sdev = NULL; xenbus_dev_fatal(dev, err, "creating interface"); return; } kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE); maybe_connect(be); } } static void frontend_changed(struct xenbus_device *dev, XenbusState frontend_state) { struct backend_info *be = dev->data; DPRINTK(""); be->frontend_state = frontend_state; switch (frontend_state) { case XenbusStateInitialising: case XenbusStateInitialised: break; case XenbusStateConnected: maybe_connect(be); break; case XenbusStateClosing: xenbus_switch_state(dev, XenbusStateClosing); break; case XenbusStateClosed: if (be->sdev != NULL) kobject_uevent(&dev->dev.kobj, KOBJ_OFFLINE); device_unregister(&dev->dev); break; case XenbusStateUnknown: case XenbusStateInitWait: default: xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend", frontend_state); break; } } /* ** Connection ** */ static void maybe_connect(struct backend_info *be) { if (be->sdev != NULL && be->frontend_state == XenbusStateConnected) { connect(be); } } static void connect(struct backend_info *be) { int err; struct xenbus_device *dev = be->dev; err = connect_rings(be); if (err) return; err = xen_net_read_mac(dev, be->sdev->fe_dev_addr); if (err) { xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename); return; } xenbus_switch_state(dev, XenbusStateConnected); } static int connect_rings(struct backend_info *be) { struct xenbus_device *dev = be->dev; unsigned long tx_ring_ref, rx_ring_ref; unsigned int evtchn; int err; DPRINTK(""); err = xenbus_gather(XBT_NULL, dev->otherend, "tx-ring-ref", "%lu", &tx_ring_ref, "rx-ring-ref", "%lu", &rx_ring_ref, "event-channel", "%u", &evtchn, NULL); if (err) { xenbus_dev_fatal(dev, err, "reading %s/ring-ref and event-channel", dev->otherend); return err; } /* Map the shared frame, irq etc. */ err = sdev_map(be->sdev, tx_ring_ref, rx_ring_ref, evtchn); if (err) { xenbus_dev_fatal(dev, err, "mapping shared-frames %lu/%lu port %u", tx_ring_ref, rx_ring_ref, evtchn); return err; } return 0; } /* ** Driver Registration ** */ static struct xenbus_device_id sdevback_ids[] = { { "vwif" }, { "" } }; static struct xenbus_driver sdevback = { .name = "vwif", .owner = THIS_MODULE, .ids = sdevback_ids, .probe = sdevback_probe, .remove = sdevback_remove, .uevent = sdevback_uevent, .otherend_changed = frontend_changed, }; void sdev_xenbus_init(void) { char *err1 = "failed to register vwif device due to "; char * err2 = "faulty de-registration upon module unload"; if (xenbus_register_backend(&sdevback) < 0) printk(KERN_ERR "orbisquartus: %s%s\n", err1, err2); } void sdev_xenbus_exit(void) { xenbus_unregister_driver(&sdevback); }

© 2007, Los Alamos National Security, LLC.