| /* |
| * |
| * Copyright 1999 Digi International (www.digi.com) |
| * James Puzzo <jamesp at digi dot com> |
| * |
| * 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, or (at your option) |
| * any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the |
| * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| * PURPOSE. See the GNU General Public License for more details. |
| * |
| */ |
| |
| /* |
| * |
| * Filename: |
| * |
| * dgrp_specproc.c |
| * |
| * Description: |
| * |
| * Handle the "config" proc entry for the linux realport device driver |
| * and provide slots for the "net" and "mon" devices |
| * |
| * Author: |
| * |
| * James A. Puzzo |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/tty.h> |
| #include <linux/sched.h> |
| #include <linux/cred.h> |
| #include <linux/proc_fs.h> |
| #include <linux/slab.h> |
| #include <linux/ctype.h> |
| #include <linux/seq_file.h> |
| #include <linux/uaccess.h> |
| #include <linux/vmalloc.h> |
| |
| #include "dgrp_common.h" |
| |
| static struct proc_dir_entry *dgrp_proc_dir_entry; |
| |
| static int dgrp_add_id(long id); |
| static int dgrp_remove_nd(struct nd_struct *nd); |
| static struct proc_dir_entry *add_proc_file(struct nd_struct *node, |
| struct proc_dir_entry *root, |
| const struct file_operations *fops); |
| |
| /* File operation declarations */ |
| static int parse_write_config(char *); |
| |
| static ssize_t dgrp_config_proc_write(struct file *file, |
| const char __user *buffer, |
| size_t count, loff_t *pos); |
| |
| static int dgrp_nodeinfo_proc_open(struct inode *inode, struct file *file); |
| static int dgrp_info_proc_open(struct inode *inode, struct file *file); |
| static int dgrp_config_proc_open(struct inode *inode, struct file *file); |
| |
| static const struct file_operations config_proc_file_ops = { |
| .owner = THIS_MODULE, |
| .open = dgrp_config_proc_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = seq_release, |
| .write = dgrp_config_proc_write, |
| }; |
| |
| static const struct file_operations info_proc_file_ops = { |
| .owner = THIS_MODULE, |
| .open = dgrp_info_proc_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations nodeinfo_proc_file_ops = { |
| .owner = THIS_MODULE, |
| .open = dgrp_nodeinfo_proc_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = seq_release, |
| }; |
| |
| static struct proc_dir_entry *net_entry_pointer; |
| static struct proc_dir_entry *mon_entry_pointer; |
| static struct proc_dir_entry *dpa_entry_pointer; |
| static struct proc_dir_entry *ports_entry_pointer; |
| |
| static void remove_files(struct nd_struct *nd) |
| { |
| char buf[3]; |
| ID_TO_CHAR(nd->nd_ID, buf); |
| dgrp_remove_node_class_sysfs_files(nd); |
| if (nd->nd_net_de) |
| remove_proc_entry(buf, net_entry_pointer); |
| if (nd->nd_mon_de) |
| remove_proc_entry(buf, mon_entry_pointer); |
| if (nd->nd_dpa_de) |
| remove_proc_entry(buf, dpa_entry_pointer); |
| if (nd->nd_ports_de) |
| remove_proc_entry(buf, ports_entry_pointer); |
| } |
| |
| void dgrp_unregister_proc(void) |
| { |
| net_entry_pointer = NULL; |
| mon_entry_pointer = NULL; |
| dpa_entry_pointer = NULL; |
| ports_entry_pointer = NULL; |
| |
| if (dgrp_proc_dir_entry) { |
| struct nd_struct *nd; |
| list_for_each_entry(nd, &nd_struct_list, list) |
| remove_files(nd); |
| remove_proc_entry("dgrp/config", NULL); |
| remove_proc_entry("dgrp/info", NULL); |
| remove_proc_entry("dgrp/nodeinfo", NULL); |
| remove_proc_entry("dgrp/net", NULL); |
| remove_proc_entry("dgrp/mon", NULL); |
| remove_proc_entry("dgrp/dpa", NULL); |
| remove_proc_entry("dgrp/ports", NULL); |
| remove_proc_entry("dgrp", NULL); |
| dgrp_proc_dir_entry = NULL; |
| } |
| } |
| |
| void dgrp_register_proc(void) |
| { |
| /* |
| * Register /proc/dgrp |
| */ |
| dgrp_proc_dir_entry = proc_mkdir("dgrp", NULL); |
| if (!dgrp_proc_dir_entry) |
| return; |
| proc_create("dgrp/config", 0644, NULL, &config_proc_file_ops); |
| proc_create("dgrp/info", 0644, NULL, &info_proc_file_ops); |
| proc_create("dgrp/nodeinfo", 0644, NULL, &nodeinfo_proc_file_ops); |
| net_entry_pointer = proc_mkdir_mode("dgrp/net", 0500, NULL); |
| mon_entry_pointer = proc_mkdir_mode("dgrp/mon", 0500, NULL); |
| dpa_entry_pointer = proc_mkdir_mode("dgrp/dpa", 0500, NULL); |
| ports_entry_pointer = proc_mkdir_mode("dgrp/ports", 0500, NULL); |
| } |
| |
| static void *dgrp_config_proc_start(struct seq_file *m, loff_t *pos) |
| { |
| return seq_list_start_head(&nd_struct_list, *pos); |
| } |
| |
| static void *dgrp_config_proc_next(struct seq_file *p, void *v, loff_t *pos) |
| { |
| return seq_list_next(v, &nd_struct_list, pos); |
| } |
| |
| static void dgrp_config_proc_stop(struct seq_file *m, void *v) |
| { |
| } |
| |
| static int dgrp_config_proc_show(struct seq_file *m, void *v) |
| { |
| struct nd_struct *nd; |
| char tmp_id[4]; |
| |
| if (v == &nd_struct_list) { |
| seq_puts(m, "#-----------------------------------------------------------------------------\n"); |
| seq_puts(m, "# Avail\n"); |
| seq_puts(m, "# ID Major State Ports\n"); |
| return 0; |
| } |
| |
| nd = list_entry(v, struct nd_struct, list); |
| |
| ID_TO_CHAR(nd->nd_ID, tmp_id); |
| |
| seq_printf(m, " %-2.2s %-5ld %-10.10s %-5d\n", |
| tmp_id, |
| nd->nd_major, |
| ND_STATE_STR(nd->nd_state), |
| nd->nd_chan_count); |
| |
| return 0; |
| } |
| |
| static const struct seq_operations proc_config_ops = { |
| .start = dgrp_config_proc_start, |
| .next = dgrp_config_proc_next, |
| .stop = dgrp_config_proc_stop, |
| .show = dgrp_config_proc_show, |
| }; |
| |
| static int dgrp_config_proc_open(struct inode *inode, struct file *file) |
| { |
| return seq_open(file, &proc_config_ops); |
| } |
| |
| |
| /* |
| * When writing configuration information, each "record" (i.e. each |
| * write) is treated as an independent request. See the "parse" |
| * description for more details. |
| */ |
| static ssize_t dgrp_config_proc_write(struct file *file, |
| const char __user *buffer, |
| size_t count, loff_t *pos) |
| { |
| ssize_t retval; |
| char *inbuf, *sp; |
| char *line, *ldelim; |
| |
| if (count > 32768) |
| return -EINVAL; |
| |
| inbuf = sp = vzalloc(count + 1); |
| if (!inbuf) |
| return -ENOMEM; |
| |
| if (copy_from_user(inbuf, buffer, count)) { |
| retval = -EFAULT; |
| goto done; |
| } |
| |
| inbuf[count] = 0; |
| |
| ldelim = "\n"; |
| |
| line = strpbrk(sp, ldelim); |
| while (line) { |
| *line = 0; |
| retval = parse_write_config(sp); |
| if (retval) |
| goto done; |
| |
| sp = line + 1; |
| line = strpbrk(sp, ldelim); |
| } |
| |
| retval = count; |
| done: |
| vfree(inbuf); |
| return retval; |
| } |
| |
| /* |
| * ------------------------------------------------------------------------ |
| * |
| * The following are the functions to parse input |
| * |
| * ------------------------------------------------------------------------ |
| */ |
| static inline char *skip_past_ws(const char *str) |
| { |
| while ((*str) && !isspace(*str)) |
| ++str; |
| |
| return skip_spaces(str); |
| } |
| |
| static int parse_id(char **c, char *cID) |
| { |
| int tmp = **c; |
| |
| if (isalnum(tmp) || (tmp == '_')) |
| cID[0] = tmp; |
| else |
| return -EINVAL; |
| |
| (*c)++; tmp = **c; |
| |
| if (isalnum(tmp) || (tmp == '_')) { |
| cID[1] = tmp; |
| (*c)++; |
| } else |
| cID[1] = 0; |
| |
| return 0; |
| } |
| |
| static int parse_add_config(char *buf) |
| { |
| char *c = buf; |
| int retval; |
| char cID[2]; |
| long ID; |
| |
| c = skip_past_ws(c); |
| |
| retval = parse_id(&c, cID); |
| if (retval < 0) |
| return retval; |
| |
| ID = CHAR_TO_ID(cID); |
| |
| c = skip_past_ws(c); |
| |
| return dgrp_add_id(ID); |
| } |
| |
| static int parse_del_config(char *buf) |
| { |
| char *c = buf; |
| int retval; |
| struct nd_struct *nd; |
| char cID[2]; |
| long ID; |
| long major; |
| |
| c = skip_past_ws(c); |
| |
| retval = parse_id(&c, cID); |
| if (retval < 0) |
| return retval; |
| |
| ID = CHAR_TO_ID(cID); |
| |
| c = skip_past_ws(c); |
| |
| retval = kstrtol(c, 10, &major); |
| if (retval) |
| return retval; |
| |
| nd = nd_struct_get(major); |
| if (!nd) |
| return -EINVAL; |
| |
| if ((nd->nd_major != major) || (nd->nd_ID != ID)) |
| return -EINVAL; |
| |
| return dgrp_remove_nd(nd); |
| } |
| |
| static int parse_chg_config(char *buf) |
| { |
| return -EINVAL; |
| } |
| |
| /* |
| * The passed character buffer represents a single configuration request. |
| * If the first character is a "+", it is parsed as a request to add a |
| * PortServer |
| * If the first character is a "-", it is parsed as a request to delete a |
| * PortServer |
| * If the first character is a "*", it is parsed as a request to change a |
| * PortServer |
| * Any other character (including whitespace) causes the record to be |
| * ignored. |
| */ |
| static int parse_write_config(char *buf) |
| { |
| int retval; |
| |
| switch (buf[0]) { |
| case '+': |
| retval = parse_add_config(buf); |
| break; |
| case '-': |
| retval = parse_del_config(buf); |
| break; |
| case '*': |
| retval = parse_chg_config(buf); |
| break; |
| default: |
| retval = -EINVAL; |
| } |
| |
| return retval; |
| } |
| |
| static int dgrp_info_proc_show(struct seq_file *m, void *v) |
| { |
| seq_printf(m, "version: %s\n", DIGI_VERSION); |
| seq_puts(m, "register_with_sysfs: 1\n"); |
| seq_printf(m, "pollrate: 0x%08x\t(%d)\n", |
| dgrp_poll_tick, dgrp_poll_tick); |
| |
| return 0; |
| } |
| |
| static int dgrp_info_proc_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, dgrp_info_proc_show, NULL); |
| } |
| |
| |
| static void *dgrp_nodeinfo_start(struct seq_file *m, loff_t *pos) |
| { |
| return seq_list_start_head(&nd_struct_list, *pos); |
| } |
| |
| static void *dgrp_nodeinfo_next(struct seq_file *p, void *v, loff_t *pos) |
| { |
| return seq_list_next(v, &nd_struct_list, pos); |
| } |
| |
| static void dgrp_nodeinfo_stop(struct seq_file *m, void *v) |
| { |
| } |
| |
| static int dgrp_nodeinfo_show(struct seq_file *m, void *v) |
| { |
| struct nd_struct *nd; |
| char hwver[8]; |
| char swver[8]; |
| char tmp_id[4]; |
| |
| if (v == &nd_struct_list) { |
| seq_puts(m, "#-----------------------------------------------------------------------------\n"); |
| seq_puts(m, "# HW HW SW\n"); |
| seq_puts(m, "# ID State Version ID Version Description\n"); |
| return 0; |
| } |
| |
| nd = list_entry(v, struct nd_struct, list); |
| |
| ID_TO_CHAR(nd->nd_ID, tmp_id); |
| |
| if (nd->nd_state == NS_READY) { |
| sprintf(hwver, "%d.%d", (nd->nd_hw_ver >> 8) & 0xff, |
| nd->nd_hw_ver & 0xff); |
| sprintf(swver, "%d.%d", (nd->nd_sw_ver >> 8) & 0xff, |
| nd->nd_sw_ver & 0xff); |
| seq_printf(m, " %-2.2s %-10.10s %-7.7s %-3d %-7.7s %-35.35s\n", |
| tmp_id, |
| ND_STATE_STR(nd->nd_state), |
| hwver, |
| nd->nd_hw_id, |
| swver, |
| nd->nd_ps_desc); |
| |
| } else { |
| seq_printf(m, " %-2.2s %-10.10s\n", |
| tmp_id, |
| ND_STATE_STR(nd->nd_state)); |
| } |
| |
| return 0; |
| } |
| |
| |
| static const struct seq_operations nodeinfo_ops = { |
| .start = dgrp_nodeinfo_start, |
| .next = dgrp_nodeinfo_next, |
| .stop = dgrp_nodeinfo_stop, |
| .show = dgrp_nodeinfo_show, |
| }; |
| |
| static int dgrp_nodeinfo_proc_open(struct inode *inode, struct file *file) |
| { |
| return seq_open(file, &nodeinfo_ops); |
| } |
| |
| /** |
| * dgrp_add_id() -- creates new nd struct and adds it to list |
| * @id: id of device to add |
| */ |
| static int dgrp_add_id(long id) |
| { |
| struct nd_struct *nd; |
| int ret; |
| int i; |
| |
| nd = kzalloc(sizeof(struct nd_struct), GFP_KERNEL); |
| if (!nd) |
| return -ENOMEM; |
| |
| nd->nd_major = 0; |
| nd->nd_ID = id; |
| |
| spin_lock_init(&nd->nd_lock); |
| |
| init_waitqueue_head(&nd->nd_tx_waitq); |
| init_waitqueue_head(&nd->nd_mon_wqueue); |
| init_waitqueue_head(&nd->nd_dpa_wqueue); |
| sema_init(&nd->nd_mon_semaphore, 1); |
| sema_init(&nd->nd_net_semaphore, 1); |
| spin_lock_init(&nd->nd_dpa_lock); |
| nd->nd_state = NS_CLOSED; |
| for (i = 0; i < SEQ_MAX; i++) |
| init_waitqueue_head(&nd->nd_seq_wque[i]); |
| |
| /* setup the structures to get the major number */ |
| ret = dgrp_tty_init(nd); |
| if (ret) |
| goto error_out; |
| |
| nd->nd_major = nd->nd_serial_ttdriver->major; |
| |
| ret = nd_struct_add(nd); |
| if (ret) |
| goto error_out; |
| |
| dgrp_create_node_class_sysfs_files(nd); |
| nd->nd_net_de = add_proc_file(nd, net_entry_pointer, &dgrp_net_ops); |
| nd->nd_mon_de = add_proc_file(nd, mon_entry_pointer, &dgrp_mon_ops); |
| nd->nd_dpa_de = add_proc_file(nd, dpa_entry_pointer, &dgrp_dpa_ops); |
| nd->nd_ports_de = add_proc_file(nd, ports_entry_pointer, |
| &dgrp_ports_ops); |
| return 0; |
| |
| /* FIXME this guy should free the tty driver stored in nd and destroy |
| * all channel ports */ |
| error_out: |
| kfree(nd); |
| return ret; |
| |
| } |
| |
| static int dgrp_remove_nd(struct nd_struct *nd) |
| { |
| int ret; |
| |
| /* Check to see if the selected structure is in use */ |
| if (nd->nd_tty_ref_cnt) |
| return -EBUSY; |
| |
| remove_files(nd); |
| |
| dgrp_tty_uninit(nd); |
| |
| ret = nd_struct_del(nd); |
| if (ret) |
| return ret; |
| |
| kfree(nd); |
| return 0; |
| } |
| |
| static struct proc_dir_entry *add_proc_file(struct nd_struct *node, |
| struct proc_dir_entry *root, |
| const struct file_operations *fops) |
| { |
| char buf[3]; |
| ID_TO_CHAR(node->nd_ID, buf); |
| return proc_create_data(buf, 0600, root, fops, node); |
| } |