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/sim_if.c Go to the documentation of this file. /* * Copyright 2007. 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; version 2 of * the License. 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. */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/ioctl.h> #include <linux/proc_fs.h> #include <linux/fs.h> #include "oq_kmod.h" #include "avl.h" #include <sim_if.h> struct oq_req_resp_list *req_resp_lists; EXPORT_SYMBOL(req_resp_lists); extern char oq_simulation_daemon[PATH_MAX]; extern struct proc_dir_entry *oq_dir; extern struct oq_dev *oq_device; struct proc_dir_entry *oq_hosts; struct proc_dir_entry *oq_sensors; struct knode { unsigned int id; }; struct ksensor { unsigned int node_id; unsigned int sensor_number; struct proc_dir_entry *proc_entry; struct sensor_stats sensor; }; struct avltree ksensors; struct avltree knodes; unsigned int simulation_on; unsigned long ksim_id; unsigned long ktime_dilation_ratio; struct khost { struct list_head list; char name[MAX_NAME]; } khosts; static int sim_test; static struct oq_req_resp_list rr_lists; /****************************** base spec ******************************/ #define META_NUM_TYPES 4 enum file_t { SIM_ID = 0, TIME = 1, ADD_HOST = 2, RM_HOST = 3, }; struct data_t { enum file_t file; } metadata[META_NUM_TYPES]; static int read_base(char *page, char **start, off_t off, int count, int *eof, void *data) { int result = 0; enum file_t type = *((enum file_t *) data); if (off > 0) { *eof = 1; return 0; } switch (type) { case SIM_ID: result = sprintf(page, "%ld\n", ksim_id); break; case TIME: result = sprintf(page, "%ld\n", ktime_dilation_ratio); break; default: break; } return result; } static ssize_t write_base(struct file *filp, const char __user *buf, unsigned long len, void *data) { struct khost *tmp; struct list_head *pos, *q; char user_str[len + 1]; enum file_t type = *((enum file_t *) data); memset(user_str, '\0', len + 1); if (copy_from_user(&user_str, buf, len)) return -EFAULT; switch (type) { case SIM_ID: ksim_id = simple_strtoul(user_str, NULL, 10); break; case TIME: ktime_dilation_ratio = simple_strtoul(user_str, NULL, 10); break; case ADD_HOST: tmp = (struct khost *) kmalloc(sizeof(struct khost), GFP_KERNEL); strncpy(tmp->name, user_str, len); list_add(&(tmp->list), &(khosts.list)); create_proc_entry(tmp->name, 0666, oq_hosts); break; case RM_HOST: list_for_each_safe(pos, q, &khosts.list) { tmp = list_entry(pos, struct khost, list); if (strncmp(tmp->name, user_str, len) == 0) { remove_proc_entry(tmp->name, oq_hosts); list_del(pos); kfree(tmp); } } break; default: break; } return len; } static void initialize(struct ksensor *ksensor, unsigned int node_id, unsigned int sensor_num, unsigned int id) { if (ksensor == NULL) return; ksensor->node_id = node_id; ksensor->sensor_number = sensor_num; ksensor->proc_entry = NULL; ksensor->sensor.id = id; ksensor->sensor.rx_bytes = ksensor->sensor.rx_errors = 0; ksensor->sensor.rx_dropped = ksensor->sensor.rx_overruns = 0; ksensor->sensor.tx_bytes = ksensor->sensor.tx_errors = 0; ksensor->sensor.tx_dropped = ksensor->sensor.tx_overruns = 0; } static int read_nodes(char *page, char **start, off_t off, int count, int *eof, void *data) { struct avlnode *item; unsigned int len = MAX_NODES * (INTEGER_STRING + 2); char nodes[len]; if (off > 0) { *eof = 1; return 0; } while ((item = avl_find_min(&knodes)) != NULL) { char name[INTEGER_STRING]; snprintf(name, INTEGER_STRING, "%d, ", ((struct knode *)item->element)->id); strncat(nodes, name, len - (strlen(nodes) + strlen(name))); } nodes[strlen(nodes)-2] = '\0'; return sprintf(page, "%s\n", nodes); } static int read_sensor(char *page, char **start, off_t off, int count, int *eof, void *data) { unsigned int number = *(unsigned int *) data; struct ksensor *ksensor = (struct ksensor *) avl_retrieve(number, &ksensors); struct sensor_stats *sensor; if (ksensor == NULL) return 0; if (off > 0) { *eof = 1; return 0; } sensor = &(ksensor->sensor); return sprintf(page, "RX bytes:%ld errors:%ld dropped:%ld overruns:%ld\n" "TX bytes:%ld errors:%ld dropped:%ld overruns:%ld\n", sensor->rx_bytes, sensor->rx_errors, sensor->rx_dropped, sensor->rx_overruns, sensor->tx_bytes, sensor->tx_errors, sensor->tx_dropped, sensor->tx_overruns); } int add_node(unsigned int id) { struct knode *knode; if ((knode = OQ_ALLOCATE(sizeof(struct knode))) == NULL) { printk(KERN_WARNING "orbisquartus: knode id %d failed\n", id); return -ENOMEM; } knode->id = id; if (avl_insert(knode, id, &knodes) != 0) { printk(KERN_WARNING "orbisquartus: knode id %d insertion failed\n", id); OQ_FREE(knode); return -EFAULT; } return 0; } void remove_node(unsigned int number) { void *knode = NULL; avl_delete(knode, number, &knodes); OQ_FREE(knode); } int add_sensor_entry(unsigned int node, unsigned int number, unsigned int id) { int len = 0; char entry_name[MAX_NAME]; struct ksensor *ksensor = (struct ksensor *) avl_retrieve(id, &ksensors); if (ksensor != NULL) { printk(KERN_WARNING "orbisquartus: sensor id %d is in use\n", id); return -EFAULT; } if ((ksensor = OQ_ALLOCATE(sizeof(struct ksensor))) == NULL) { printk(KERN_WARNING "orbisquartus: ksensor id %d failed\n", id); return -ENOMEM; } if (avl_insert(ksensor, id, &ksensors) != 0) { printk(KERN_WARNING "orbisquartus: ksensor id %d insertion failed\n", id); len = -EFAULT; goto cleanup_avl_entry; } initialize(ksensor, node, number, id); snprintf(entry_name, MAX_NAME, "%d::%d", node, number); if ((ksensor->proc_entry = proc_mkdir(entry_name, oq_sensors)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't create sensor proc entry\n"); len = -ENOMEM; goto cleanup_proc_entry; } ksensor->proc_entry->read_proc = read_sensor; ksensor->proc_entry->owner = THIS_MODULE; ksensor->proc_entry->data = &(ksensor->sensor.id); goto end; cleanup_proc_entry: remove_proc_entry(entry_name, oq_sensors); ksensor->proc_entry = NULL; cleanup_avl_entry: avl_delete(NULL, id, &ksensors); OQ_FREE(ksensor); end: return len; } void remove_sensor_entry(unsigned int number) { char entry_name[MAX_NAME]; struct ksensor *ksensor = (struct ksensor *) avl_retrieve(number, &ksensors); if (ksensor == NULL) return; snprintf(entry_name, MAX_NAME, "%d::%d", ksensor->node_id, ksensor->sensor_number); remove_proc_entry(entry_name, oq_sensors); ksensor->proc_entry = NULL; avl_delete(NULL, ksensor->sensor.id, &ksensors); OQ_FREE(ksensor); } int post_sensor_stats(struct sensor_stats stats) { struct ksensor *ksensor = (struct ksensor *) avl_retrieve(stats.id, &ksensors); if (ksensor == NULL) return 0; ksensor->sensor.rx_bytes = stats.rx_bytes; ksensor->sensor.rx_errors = stats.rx_errors; ksensor->sensor.rx_dropped = stats.rx_dropped; ksensor->sensor.rx_overruns = stats.rx_overruns; ksensor->sensor.tx_bytes = stats.tx_bytes; ksensor->sensor.tx_errors = stats.tx_errors; ksensor->sensor.tx_dropped = stats.tx_dropped; ksensor->sensor.tx_overruns = stats.tx_overruns; return 1; } /****************************** char device functionality ******************************/ static int oq_clear_log(struct oq_dev *dev) { struct oq_log_item *next, *dptr; int i, qset = OQ_LOG_SIZE; for (dptr = dev->data; dptr; dptr = next) { if (dptr->data) { for (i = 0; i < qset; i++) kfree(dptr->data[i]); kfree(dptr->data); dptr->data = NULL; } next = dptr->next; kfree(dptr); } dev->size = 0; dev->data = NULL; return 0; } static struct oq_log_item *oq_traverse_log(struct oq_dev *dev, int where) { struct oq_log_item *items = dev->data; if (!items) { dev->data = kmalloc(sizeof(struct oq_log_item), GFP_KERNEL); if ((items = dev->data) == NULL) return NULL; memset(items, 0, sizeof(struct oq_log_item)); } while (where--) { if (!items->next) { if ((items->next = kmalloc(sizeof(struct oq_log_item), GFP_KERNEL)) == NULL) return NULL; memset(items->next, 0, sizeof(struct oq_log_item)); } items = items->next; } return items; } loff_t oq_llseek(struct file *filp, loff_t pos, int where) { struct oq_dev *dev = filp->private_data; loff_t new_pos; switch(where) { case 0: /* set */ new_pos = pos; break; case 1: /* current */ new_pos = filp->f_pos + pos; break; case 2: /* end */ new_pos = dev->size + pos; break; default: return -EINVAL; } if (new_pos < 0) return -EINVAL; filp->f_pos = new_pos; return new_pos; } ssize_t oq_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) { struct oq_dev *dev = filp->private_data; struct oq_log_item *dptr; int quantum = OQ_LOG_ITEM_SIZE; int qset = OQ_LOG_SIZE; int itemsize = quantum * qset; int item, s_pos, q_pos, rest; ssize_t retval = 0; if (down_interruptible(&dev->sem)) return -ERESTARTSYS; if (*f_pos >= dev->size) goto end; if (*f_pos + count > dev->size) count = dev->size - *f_pos; item = (long)*f_pos / itemsize; rest = (long)*f_pos % itemsize; s_pos = rest / quantum; q_pos = rest % quantum; dptr = oq_traverse_log(dev, item); if (dptr == NULL || !dptr->data || ! dptr->data[s_pos]) goto end; if (count > quantum - q_pos) count = quantum - q_pos; if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) { retval = -EFAULT; goto end; } *f_pos += count; retval = count; end: up(&dev->sem); return retval; } static ssize_t __oq_wrt(struct oq_dev *dev, const char __user *buf, size_t count, loff_t *f_pos) { struct oq_log_item *dptr; int quantum = OQ_LOG_ITEM_SIZE; int qset = OQ_LOG_SIZE; int itemsize = quantum * qset; int item, s_pos, q_pos, rest; ssize_t retval = -ENOMEM; if (down_interruptible(&dev->sem)) return -ERESTARTSYS; item = (long)*f_pos / itemsize; rest = (long)*f_pos % itemsize; s_pos = rest / quantum; q_pos = rest % quantum; dptr = oq_traverse_log(dev, item); if (dptr == NULL) goto end; if (!dptr->data) { dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL); if (!dptr->data) goto end; memset(dptr->data, 0, qset * sizeof(char *)); } if (!dptr->data[s_pos]) { dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL); if (!dptr->data[s_pos]) goto end; } if (count > quantum - q_pos) count = quantum - q_pos; if (copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) { retval = -EFAULT; goto end; } *f_pos += count; retval = count; if (dev->size < *f_pos) dev->size = *f_pos; end: up(&dev->sem); return retval; } ssize_t oq_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { struct oq_dev *dev = filp->private_data; return __oq_wrt(dev, buf, count, f_pos); } /* interfaces with user-space solver */ int oq_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { DECLARE_WAITQUEUE(waitqueue, current); struct oq_req_resp *req; struct oq_req_resp *resp; int result = 0; switch (cmd) { case OQ_RESP_INIT: simulation_on++; if (down_interruptible(&req_resp_lists->simd_sem)) return -ERESTARTSYS; goto await_result; break; case OQ_RESP_REINIT: if (down_interruptible(&req_resp_lists->simd_sem)) return -ERESTARTSYS; goto await_result; break; case OQ_RESP_RESULT: if (down_interruptible(&req_resp_lists->simd_sem)) return -ERESTARTSYS; if ((resp = new_response(arg)) == NULL) return OQ_REQ_REPEAT; list_add_tail(&resp->list, &req_resp_lists->response_list); wake_up_interruptible(&req_resp_lists->response_wait); await_result: add_wait_queue(&req_resp_lists->request_wait, &waitqueue); set_current_state(TASK_INTERRUPTIBLE); while (list_empty(&req_resp_lists->request_list)) { up(&req_resp_lists->simd_sem); schedule(); /* enter:sleep -> exit:wake */ if (signal_pending(current)) return OQ_REQ_REPEAT; if (down_interruptible(&req_resp_lists->simd_sem)) return OQ_REQ_REPEAT; } __set_current_state(TASK_RUNNING); remove_wait_queue(&req_resp_lists->request_wait, &waitqueue); req = list_entry(&req_resp_lists->request_list, struct oq_req_resp, list); list_del(&req->list); result = copy_to_user((struct oq_req_resp __user *)arg, req, sizeof(struct oq_req_resp)); kfree(req); up(&req_resp_lists->simd_sem); break; default: return -ENOIOCTLCMD; } return result; } int oq_open(struct inode *inode, struct file *filp) { struct oq_dev *dev; dev = container_of(inode->i_cdev, struct oq_dev, cdev); filp->private_data = dev; if ((filp->f_flags & O_ACCMODE) == O_WRONLY) { if (down_interruptible(&dev->sem)) return -ERESTARTSYS; oq_clear_log(dev); up(&dev->sem); } return 0; } int oq_release(struct inode *inode, struct file *filp) { return 0; } int OQLOG(const char *fmt, ...) { va_list ap; char buf[OQ_LOG_ITEM_SIZE]; int len; va_start(ap, fmt); if ((len = vsnprintf(buf, OQ_LOG_ITEM_SIZE, fmt, ap)) < 0) return len; if (oq_device == NULL) return -ENODEV; len = __oq_wrt(oq_device, buf, strlen(buf) + 1, (loff_t *) &oq_device->size); va_end(ap); return len; } /******************************/ int init_simulator_iface(int test) { int result = -1; struct proc_dir_entry *id_entry, *dilation_entry, *add_entry, *rm_entry, *nodes_entry; req_resp_lists = &rr_lists; simulation_on = 0; sim_test = test; init_waitqueue_head(&req_resp_lists->request_wait); init_waitqueue_head(&req_resp_lists->response_wait); init_MUTEX_LOCKED(&req_resp_lists->simd_sem); INIT_LIST_HEAD(&req_resp_lists->request_list); INIT_LIST_HEAD(&req_resp_lists->response_list); INIT_LIST_HEAD(&khosts.list); if ((id_entry = create_proc_entry("simulation_id", 0666, oq_dir)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't create sim id entry\n"); result = -ENOMEM; goto cleanup_id; } id_entry->read_proc = read_base; id_entry->write_proc = write_base; id_entry->owner = THIS_MODULE; id_entry->data = &metadata[SIM_ID]; if ((dilation_entry = create_proc_entry("time_dilation", 0666, oq_dir)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't enable time dilation entry\n"); result = -ENOMEM; goto cleanup_time; } dilation_entry->read_proc = read_base; dilation_entry->write_proc = write_base; dilation_entry->owner = THIS_MODULE; dilation_entry->data = &metadata[TIME]; if ((oq_hosts = proc_mkdir("hosts", oq_dir)) == NULL) { printk(KERN_ERR "orbisquartus: Couldn't create hosts proc entry\n"); result = -ENOMEM; goto cleanup_hosts; } oq_hosts->owner = THIS_MODULE; if ((add_entry = create_proc_entry("add", 0666, oq_hosts)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't enable hosts entry\n"); result = -ENOMEM; goto cleanup_add; } add_entry->read_proc = read_base; add_entry->write_proc = write_base; add_entry->owner = THIS_MODULE; add_entry->data = &metadata[ADD_HOST]; if ((rm_entry = create_proc_entry("remove", 0666, oq_hosts)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't enable hosts entry\n"); result = -ENOMEM; goto cleanup_rm; } rm_entry->read_proc = read_base; rm_entry->write_proc = write_base; rm_entry->owner = THIS_MODULE; rm_entry->data = &metadata[RM_HOST]; if ((oq_sensors = proc_mkdir("sensors", oq_dir)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't create sensors proc entry\n"); result = -ENOMEM; goto cleanup_sensors; } oq_sensors->owner = THIS_MODULE; if ((nodes_entry = create_proc_entry("nodes", 0666, oq_dir)) == NULL) { printk(KERN_WARNING "orbisquartus: Couldn't create nodes entry\n"); result = -ENOMEM; goto cleanup_nodes; } nodes_entry->read_proc = read_nodes; nodes_entry->owner = THIS_MODULE; /* argv[0] = oq_simulation_daemon; argv[1] = 0; envp[0] = "HOME=/"; envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; envp[2] = 0; result = call_usermodehelper(argv[0], argv, envp, 0); */ goto end; cleanup_nodes: remove_proc_entry("nodes", oq_dir); cleanup_sensors: remove_proc_entry("sensors", oq_dir); cleanup_time: remove_proc_entry("time_dilation", oq_dir); cleanup_rm: remove_proc_entry("remove", oq_hosts); cleanup_add: remove_proc_entry("add", oq_hosts); cleanup_hosts: remove_proc_entry("hosts", oq_dir); cleanup_id: remove_proc_entry("simulation_id", oq_dir); end: return result; } void shutdown_simulator_iface(void) { struct khost *tmp; struct list_head *pos, *q; struct avlnode *item; simulation_on = 0; while ((item = avl_find_min(&ksensors)) != NULL) { unsigned int num = ((struct knode *)item->element)->id; remove_node(num); } remove_proc_entry("nodes", oq_dir); while ((item = avl_find_min(&ksensors)) != NULL) { unsigned int num = ((struct ksensor *)item->element)->sensor.id; remove_sensor_entry(num); } remove_proc_entry("sensors", oq_dir); remove_proc_entry("time_dilation", oq_dir); list_for_each_safe(pos, q, &khosts.list) { tmp = list_entry(pos, struct khost, list); remove_proc_entry(tmp->name, oq_hosts); list_del(pos); kfree(tmp); } remove_proc_entry("remove", oq_hosts); remove_proc_entry("add", oq_hosts); remove_proc_entry("hosts", oq_dir); remove_proc_entry("simulation_id", oq_dir); }

© 2007, Los Alamos National Security, LLC.