1 /*****************************************************************************
3 * Copyright 1999 Digi International (www.digi.com)
4 * James Puzzo <jamesp at digi dot com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
13 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 * PURPOSE. See the GNU General Public License for more details.
26 * Handle the file operations required for the "monitor" devices.
27 * Includes those functions required to register the "mon" devices
36 #include <linux/module.h>
37 #include <linux/tty.h>
38 #include <linux/sched.h>
39 #include <asm/unaligned.h>
40 #include <linux/proc_fs.h>
41 #include <linux/uaccess.h>
43 #include "dgrp_common.h"
45 /* File operation declarations */
46 static int dgrp_mon_open(struct inode *, struct file *);
47 static int dgrp_mon_release(struct inode *, struct file *);
48 static ssize_t dgrp_mon_read(struct file *, char __user *, size_t, loff_t *);
49 static long dgrp_mon_ioctl(struct file *file, unsigned int cmd,
52 static const struct file_operations mon_ops = {
54 .read = dgrp_mon_read,
55 .unlocked_ioctl = dgrp_mon_ioctl,
56 .open = dgrp_mon_open,
57 .release = dgrp_mon_release,
60 static struct inode_operations mon_inode_ops = {
61 .permission = dgrp_inode_permission
64 void dgrp_register_mon_hook(struct proc_dir_entry *de)
66 struct nd_struct *node = de->data;
68 de->proc_iops = &mon_inode_ops;
69 rcu_assign_pointer(de->proc_fops, &mon_ops);
71 sema_init(&node->nd_mon_semaphore, 1);
75 * dgrp_mon_open() -- open /proc/dgrp/ports device for a PortServer
76 * @inode: struct inode *
77 * @file: struct file *
79 * Open function to open the /proc/dgrp/ports device for a PortServer.
81 static int dgrp_mon_open(struct inode *inode, struct file *file)
84 struct proc_dir_entry *de;
90 rtn = try_module_get(THIS_MODULE);
96 if (!capable(CAP_SYS_ADMIN)) {
102 * Make sure that the "private_data" field hasn't already been used.
104 if (file->private_data) {
110 * Get the node pointer, and fail if it doesn't exist.
118 nd = (struct nd_struct *)de->data;
124 file->private_data = (void *) nd;
127 * Allocate the monitor buffer.
133 down(&nd->nd_mon_semaphore);
135 if (nd->nd_mon_buf) {
140 nd->nd_mon_buf = kmalloc(MON_MAX, GFP_KERNEL);
142 if (!nd->nd_mon_buf) {
148 * Enter an RPDUMP file header into the buffer.
151 buf = nd->nd_mon_buf;
153 strcpy(buf, RPDUMP_MAGIC);
154 buf += strlen(buf) + 1;
156 do_gettimeofday(&tv);
159 * tv.tv_sec might be a 64 bit quantity. Pare
160 * it down to 32 bits before attempting to encode
163 time = (uint32_t) (tv.tv_sec & 0xffffffff);
165 put_unaligned_be32(time, buf);
166 put_unaligned_be16(0, buf + 4);
169 if (nd->nd_tx_module) {
170 buf[0] = RPDUMP_CLIENT;
171 put_unaligned_be32(0, buf + 1);
172 put_unaligned_be16(1, buf + 5);
173 buf[7] = 0xf0 + nd->nd_tx_module;
177 if (nd->nd_rx_module) {
178 buf[0] = RPDUMP_SERVER;
179 put_unaligned_be32(0, buf + 1);
180 put_unaligned_be16(1, buf + 5);
181 buf[7] = 0xf0 + nd->nd_rx_module;
186 nd->nd_mon_in = buf - nd->nd_mon_buf;
187 nd->nd_mon_lbolt = jiffies;
190 up(&nd->nd_mon_semaphore);
194 module_put(THIS_MODULE);
200 * dgrp_mon_release() - Close the MON device for a particular PortServer
201 * @inode: struct inode *
202 * @file: struct file *
204 static int dgrp_mon_release(struct inode *inode, struct file *file)
206 struct nd_struct *nd;
209 * Get the node pointer, and quit if it doesn't exist.
211 nd = (struct nd_struct *)(file->private_data);
216 * Free the monitor buffer.
219 down(&nd->nd_mon_semaphore);
221 kfree(nd->nd_mon_buf);
222 nd->nd_mon_buf = NULL;
223 nd->nd_mon_out = nd->nd_mon_in;
226 * Wakeup any thread waiting for buffer space.
229 if (nd->nd_mon_flag & MON_WAIT_SPACE) {
230 nd->nd_mon_flag &= ~MON_WAIT_SPACE;
231 wake_up_interruptible(&nd->nd_mon_wqueue);
234 up(&nd->nd_mon_semaphore);
237 * Make sure there is no thread in the middle of writing a packet.
239 down(&nd->nd_net_semaphore);
240 up(&nd->nd_net_semaphore);
243 module_put(THIS_MODULE);
244 file->private_data = NULL;
249 * dgrp_mon_read() -- Copy data from the monitoring buffer to the user
251 static ssize_t dgrp_mon_read(struct file *file, char __user *buf, size_t count,
254 struct nd_struct *nd;
261 * Get the node pointer, and quit if it doesn't exist.
263 nd = (struct nd_struct *)(file->private_data);
268 * Wait for some data to appear in the buffer.
271 down(&nd->nd_mon_semaphore);
274 res = (nd->nd_mon_in - nd->nd_mon_out) & MON_MASK;
279 nd->nd_mon_flag |= MON_WAIT_DATA;
281 up(&nd->nd_mon_semaphore);
284 * Go to sleep waiting until the condition becomes true.
286 rtn = wait_event_interruptible(nd->nd_mon_wqueue,
287 ((nd->nd_mon_flag & MON_WAIT_DATA) == 0));
292 down(&nd->nd_mon_semaphore);
296 * Read whatever is there.
302 r = MON_MAX - nd->nd_mon_out;
305 rtn = copy_to_user((void __user *)buf,
306 nd->nd_mon_buf + nd->nd_mon_out, r);
308 up(&nd->nd_mon_semaphore);
317 rtn = copy_to_user((void __user *) buf + offset,
318 nd->nd_mon_buf + nd->nd_mon_out, res);
320 up(&nd->nd_mon_semaphore);
324 nd->nd_mon_out += res;
328 up(&nd->nd_mon_semaphore);
331 * Wakeup any thread waiting for buffer space.
334 if (nd->nd_mon_flag & MON_WAIT_SPACE) {
335 nd->nd_mon_flag &= ~MON_WAIT_SPACE;
336 wake_up_interruptible(&nd->nd_mon_wqueue);
342 /* ioctl is not valid on monitor device */
343 static long dgrp_mon_ioctl(struct file *file, unsigned int cmd,