blob: f7e83a86f444cdb37d2bc18b3962212f1bf7a41c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $Id: hysdn_proclog.c,v 1.9.6.3 2001/09/23 22:24:54 kai Exp $
2 *
3 * Linux driver for HYSDN cards, /proc/net filesystem log functions.
4 *
5 * Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
6 * Copyright 1999 by Werner Cornelius (werner@titro.de)
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 */
12
13#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/poll.h>
15#include <linux/proc_fs.h>
16#include <linux/pci.h>
17#include <linux/smp_lock.h>
18
19#include "hysdn_defs.h"
20
21/* the proc subdir for the interface is defined in the procconf module */
22extern struct proc_dir_entry *hysdn_proc_entry;
23
Adrian Bunkaade0e82005-06-28 20:44:56 -070024static void put_log_buffer(hysdn_card * card, char *cp);
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026/*************************************************/
27/* structure keeping ascii log for device output */
28/*************************************************/
29struct log_data {
30 struct log_data *next;
Andrew Mortonc721bcc2006-03-25 03:07:04 -080031 unsigned long usage_cnt;/* number of files still to work */
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 void *proc_ctrl; /* pointer to own control procdata structure */
33 char log_start[2]; /* log string start (final len aligned by size) */
34};
35
36/**********************************************/
37/* structure holding proc entrys for one card */
38/**********************************************/
39struct procdata {
40 struct proc_dir_entry *log; /* log entry */
41 char log_name[15]; /* log filename */
42 struct log_data *log_head, *log_tail; /* head and tail for queue */
43 int if_used; /* open count for interface */
44 int volatile del_lock; /* lock for delete operations */
Andrew Mortonc721bcc2006-03-25 03:07:04 -080045 unsigned char logtmp[LOG_MAX_LINELEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 wait_queue_head_t rd_queue;
47};
48
49
50/**********************************************/
51/* log function for cards error log interface */
52/**********************************************/
53void
54hysdn_card_errlog(hysdn_card * card, tErrLogEntry * logp, int maxsize)
55{
56 char buf[ERRLOG_TEXT_SIZE + 40];
57
58 sprintf(buf, "LOG 0x%08lX 0x%08lX : %s\n", logp->ulErrType, logp->ulErrSubtype, logp->ucText);
59 put_log_buffer(card, buf); /* output the string */
60} /* hysdn_card_errlog */
61
62/***************************************************/
63/* Log function using format specifiers for output */
64/***************************************************/
65void
66hysdn_addlog(hysdn_card * card, char *fmt,...)
67{
68 struct procdata *pd = card->proclog;
69 char *cp;
70 va_list args;
71
72 if (!pd)
73 return; /* log structure non existent */
74
75 cp = pd->logtmp;
76 cp += sprintf(cp, "HYSDN: card %d ", card->myid);
77
78 va_start(args, fmt);
79 cp += vsprintf(cp, fmt, args);
80 va_end(args);
81 *cp++ = '\n';
82 *cp = 0;
83
84 if (card->debug_flags & DEB_OUT_SYSLOG)
85 printk(KERN_INFO "%s", pd->logtmp);
86 else
87 put_log_buffer(card, pd->logtmp);
88
89} /* hysdn_addlog */
90
91/********************************************/
92/* put an log buffer into the log queue. */
93/* This buffer will be kept until all files */
94/* opened for read got the contents. */
95/* Flushes buffers not longer in use. */
96/********************************************/
Adrian Bunkaade0e82005-06-28 20:44:56 -070097static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070098put_log_buffer(hysdn_card * card, char *cp)
99{
100 struct log_data *ib;
101 struct procdata *pd = card->proclog;
102 int i;
103 unsigned long flags;
104
105 if (!pd)
106 return;
107 if (!cp)
108 return;
109 if (!*cp)
110 return;
111 if (pd->if_used <= 0)
112 return; /* no open file for read */
113
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800114 if (!(ib = kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return; /* no memory */
116 strcpy(ib->log_start, cp); /* set output string */
117 ib->next = NULL;
118 ib->proc_ctrl = pd; /* point to own control structure */
Amol Lad0d9ba862006-10-17 00:10:36 -0700119 spin_lock_irqsave(&card->hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 ib->usage_cnt = pd->if_used;
121 if (!pd->log_head)
122 pd->log_head = ib; /* new head */
123 else
124 pd->log_tail->next = ib; /* follows existing messages */
125 pd->log_tail = ib; /* new tail */
126 i = pd->del_lock++; /* get lock state */
Amol Lad0d9ba862006-10-17 00:10:36 -0700127 spin_unlock_irqrestore(&card->hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129 /* delete old entrys */
130 if (!i)
131 while (pd->log_head->next) {
132 if ((pd->log_head->usage_cnt <= 0) &&
133 (pd->log_head->next->usage_cnt <= 0)) {
134 ib = pd->log_head;
135 pd->log_head = pd->log_head->next;
136 kfree(ib);
137 } else
138 break;
139 } /* pd->log_head->next */
140 pd->del_lock--; /* release lock level */
141 wake_up_interruptible(&(pd->rd_queue)); /* announce new entry */
142} /* put_log_buffer */
143
144
145/******************************/
146/* file operations and tables */
147/******************************/
148
149/****************************************/
150/* write log file -> set log level bits */
151/****************************************/
152static ssize_t
153hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
154{
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800155 unsigned long u = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 int found = 0;
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800157 unsigned char *cp, valbuf[128];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 long base = 10;
159 hysdn_card *card = (hysdn_card *) file->private_data;
160
161 if (count > (sizeof(valbuf) - 1))
162 count = sizeof(valbuf) - 1; /* limit length */
163 if (copy_from_user(valbuf, buf, count))
164 return (-EFAULT); /* copy failed */
165
166 valbuf[count] = 0; /* terminating 0 */
167 cp = valbuf;
168 if ((count > 2) && (valbuf[0] == '0') && (valbuf[1] == 'x')) {
169 cp += 2; /* pointer after hex modifier */
170 base = 16;
171 }
172 /* scan the input for debug flags */
173 while (*cp) {
174 if ((*cp >= '0') && (*cp <= '9')) {
175 found = 1;
176 u *= base; /* adjust to next digit */
177 u += *cp++ - '0';
178 continue;
179 }
180 if (base != 16)
181 break; /* end of number */
182
183 if ((*cp >= 'a') && (*cp <= 'f')) {
184 found = 1;
185 u *= base; /* adjust to next digit */
186 u += *cp++ - 'a' + 10;
187 continue;
188 }
189 break; /* terminated */
190 }
191
192 if (found) {
193 card->debug_flags = u; /* remember debug flags */
194 hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
195 }
196 return (count);
197} /* hysdn_log_write */
198
199/******************/
200/* read log file */
201/******************/
202static ssize_t
203hysdn_log_read(struct file *file, char __user *buf, size_t count, loff_t * off)
204{
205 struct log_data *inf;
206 int len;
Josef Sipek4482dfa2006-12-08 02:37:13 -0800207 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 struct procdata *pd = NULL;
209 hysdn_card *card;
210
211 if (!*((struct log_data **) file->private_data)) {
212 if (file->f_flags & O_NONBLOCK)
213 return (-EAGAIN);
214
215 /* sorry, but we need to search the card */
216 card = card_root;
217 while (card) {
218 pd = card->proclog;
219 if (pd->log == pde)
220 break;
221 card = card->next; /* search next entry */
222 }
223 if (card)
224 interruptible_sleep_on(&(pd->rd_queue));
225 else
226 return (-EAGAIN);
227
228 }
229 if (!(inf = *((struct log_data **) file->private_data)))
230 return (0);
231
232 inf->usage_cnt--; /* new usage count */
233 file->private_data = &inf->next; /* next structure */
234 if ((len = strlen(inf->log_start)) <= count) {
235 if (copy_to_user(buf, inf->log_start, len))
236 return -EFAULT;
237 *off += len;
238 return (len);
239 }
240 return (0);
241} /* hysdn_log_read */
242
243/******************/
244/* open log file */
245/******************/
246static int
247hysdn_log_open(struct inode *ino, struct file *filep)
248{
249 hysdn_card *card;
250 struct procdata *pd = NULL;
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800251 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 lock_kernel();
254 card = card_root;
255 while (card) {
256 pd = card->proclog;
257 if (pd->log == PDE(ino))
258 break;
259 card = card->next; /* search next entry */
260 }
261 if (!card) {
262 unlock_kernel();
263 return (-ENODEV); /* device is unknown/invalid */
264 }
265 filep->private_data = card; /* remember our own card */
266
267 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
268 /* write only access -> write log level only */
269 } else if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
270
271 /* read access -> log/debug read */
Amol Lad0d9ba862006-10-17 00:10:36 -0700272 spin_lock_irqsave(&card->hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 pd->if_used++;
274 if (pd->log_head)
275 filep->private_data = &pd->log_tail->next;
276 else
277 filep->private_data = &pd->log_head;
Amol Lad0d9ba862006-10-17 00:10:36 -0700278 spin_unlock_irqrestore(&card->hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 } else { /* simultaneous read/write access forbidden ! */
280 unlock_kernel();
281 return (-EPERM); /* no permission this time */
282 }
283 unlock_kernel();
284 return nonseekable_open(ino, filep);
285} /* hysdn_log_open */
286
287/*******************************************************************************/
288/* close a cardlog file. If the file has been opened for exclusive write it is */
289/* assumed as pof data input and the pof loader is noticed about. */
290/* Otherwise file is handled as log output. In this case the interface usage */
291/* count is decremented and all buffers are noticed of closing. If this file */
292/* was the last one to be closed, all buffers are freed. */
293/*******************************************************************************/
294static int
295hysdn_log_close(struct inode *ino, struct file *filep)
296{
297 struct log_data *inf;
298 struct procdata *pd;
299 hysdn_card *card;
300 int retval = 0;
301 unsigned long flags;
Amol Lad0d9ba862006-10-17 00:10:36 -0700302 spinlock_t hysdn_lock = SPIN_LOCK_UNLOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 lock_kernel();
305 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
306 /* write only access -> write debug level written */
307 retval = 0; /* success */
308 } else {
309 /* read access -> log/debug read, mark one further file as closed */
310
311 pd = NULL;
Amol Lad0d9ba862006-10-17 00:10:36 -0700312 spin_lock_irqsave(&hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 inf = *((struct log_data **) filep->private_data); /* get first log entry */
314 if (inf)
315 pd = (struct procdata *) inf->proc_ctrl; /* still entries there */
316 else {
317 /* no info available -> search card */
318 card = card_root;
319 while (card) {
320 pd = card->proclog;
321 if (pd->log == PDE(ino))
322 break;
323 card = card->next; /* search next entry */
324 }
325 if (card)
326 pd = card->proclog; /* pointer to procfs log */
327 }
328 if (pd)
329 pd->if_used--; /* decrement interface usage count by one */
330
331 while (inf) {
332 inf->usage_cnt--; /* decrement usage count for buffers */
333 inf = inf->next;
334 }
Amol Lad0d9ba862006-10-17 00:10:36 -0700335 spin_unlock_irqrestore(&hysdn_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337 if (pd)
338 if (pd->if_used <= 0) /* delete buffers if last file closed */
339 while (pd->log_head) {
340 inf = pd->log_head;
341 pd->log_head = pd->log_head->next;
342 kfree(inf);
343 }
344 } /* read access */
345 unlock_kernel();
346
347 return (retval);
348} /* hysdn_log_close */
349
350/*************************************************/
351/* select/poll routine to be able using select() */
352/*************************************************/
353static unsigned int
354hysdn_log_poll(struct file *file, poll_table * wait)
355{
356 unsigned int mask = 0;
Josef Sipek4482dfa2006-12-08 02:37:13 -0800357 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 hysdn_card *card;
359 struct procdata *pd = NULL;
360
361 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE)
362 return (mask); /* no polling for write supported */
363
364 /* we need to search the card */
365 card = card_root;
366 while (card) {
367 pd = card->proclog;
368 if (pd->log == pde)
369 break;
370 card = card->next; /* search next entry */
371 }
372 if (!card)
373 return (mask); /* card not found */
374
375 poll_wait(file, &(pd->rd_queue), wait);
376
377 if (*((struct log_data **) file->private_data))
378 mask |= POLLIN | POLLRDNORM;
379
380 return mask;
381} /* hysdn_log_poll */
382
383/**************************************************/
384/* table for log filesystem functions defined above. */
385/**************************************************/
Arjan van de Ven2b8693c2007-02-12 00:55:32 -0800386static const struct file_operations log_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 .llseek = no_llseek,
389 .read = hysdn_log_read,
390 .write = hysdn_log_write,
391 .poll = hysdn_log_poll,
392 .open = hysdn_log_open,
393 .release = hysdn_log_close,
394};
395
396
397/***********************************************************************************/
398/* hysdn_proclog_init is called when the module is loaded after creating the cards */
399/* conf files. */
400/***********************************************************************************/
401int
402hysdn_proclog_init(hysdn_card * card)
403{
404 struct procdata *pd;
405
406 /* create a cardlog proc entry */
407
Burman Yan41f96932006-12-08 02:39:35 -0800408 if ((pd = kzalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
410 if ((pd->log = create_proc_entry(pd->log_name, S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry)) != NULL) {
411 pd->log->proc_fops = &log_fops;
412 pd->log->owner = THIS_MODULE;
413 }
414
415 init_waitqueue_head(&(pd->rd_queue));
416
417 card->proclog = (void *) pd; /* remember procfs structure */
418 }
419 return (0);
420} /* hysdn_proclog_init */
421
422/************************************************************************************/
423/* hysdn_proclog_release is called when the module is unloaded and before the cards */
424/* conf file is released */
425/* The module counter is assumed to be 0 ! */
426/************************************************************************************/
427void
428hysdn_proclog_release(hysdn_card * card)
429{
430 struct procdata *pd;
431
432 if ((pd = (struct procdata *) card->proclog) != NULL) {
433 if (pd->log)
434 remove_proc_entry(pd->log_name, hysdn_proc_entry);
435 kfree(pd); /* release memory */
436 card->proclog = NULL;
437 }
438} /* hysdn_proclog_release */