blob: c4301e8338eff58a4a01fc7f2120fbfeefe5dd3a [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
114 if (!(ib = (struct log_data *) kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
115 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 */
119 save_flags(flags);
120 cli();
121 ib->usage_cnt = pd->if_used;
122 if (!pd->log_head)
123 pd->log_head = ib; /* new head */
124 else
125 pd->log_tail->next = ib; /* follows existing messages */
126 pd->log_tail = ib; /* new tail */
127 i = pd->del_lock++; /* get lock state */
128 restore_flags(flags);
129
130 /* delete old entrys */
131 if (!i)
132 while (pd->log_head->next) {
133 if ((pd->log_head->usage_cnt <= 0) &&
134 (pd->log_head->next->usage_cnt <= 0)) {
135 ib = pd->log_head;
136 pd->log_head = pd->log_head->next;
137 kfree(ib);
138 } else
139 break;
140 } /* pd->log_head->next */
141 pd->del_lock--; /* release lock level */
142 wake_up_interruptible(&(pd->rd_queue)); /* announce new entry */
143} /* put_log_buffer */
144
145
146/******************************/
147/* file operations and tables */
148/******************************/
149
150/****************************************/
151/* write log file -> set log level bits */
152/****************************************/
153static ssize_t
154hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
155{
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800156 unsigned long u = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 int found = 0;
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800158 unsigned char *cp, valbuf[128];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 long base = 10;
160 hysdn_card *card = (hysdn_card *) file->private_data;
161
162 if (count > (sizeof(valbuf) - 1))
163 count = sizeof(valbuf) - 1; /* limit length */
164 if (copy_from_user(valbuf, buf, count))
165 return (-EFAULT); /* copy failed */
166
167 valbuf[count] = 0; /* terminating 0 */
168 cp = valbuf;
169 if ((count > 2) && (valbuf[0] == '0') && (valbuf[1] == 'x')) {
170 cp += 2; /* pointer after hex modifier */
171 base = 16;
172 }
173 /* scan the input for debug flags */
174 while (*cp) {
175 if ((*cp >= '0') && (*cp <= '9')) {
176 found = 1;
177 u *= base; /* adjust to next digit */
178 u += *cp++ - '0';
179 continue;
180 }
181 if (base != 16)
182 break; /* end of number */
183
184 if ((*cp >= 'a') && (*cp <= 'f')) {
185 found = 1;
186 u *= base; /* adjust to next digit */
187 u += *cp++ - 'a' + 10;
188 continue;
189 }
190 break; /* terminated */
191 }
192
193 if (found) {
194 card->debug_flags = u; /* remember debug flags */
195 hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
196 }
197 return (count);
198} /* hysdn_log_write */
199
200/******************/
201/* read log file */
202/******************/
203static ssize_t
204hysdn_log_read(struct file *file, char __user *buf, size_t count, loff_t * off)
205{
206 struct log_data *inf;
207 int len;
208 struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
209 struct procdata *pd = NULL;
210 hysdn_card *card;
211
212 if (!*((struct log_data **) file->private_data)) {
213 if (file->f_flags & O_NONBLOCK)
214 return (-EAGAIN);
215
216 /* sorry, but we need to search the card */
217 card = card_root;
218 while (card) {
219 pd = card->proclog;
220 if (pd->log == pde)
221 break;
222 card = card->next; /* search next entry */
223 }
224 if (card)
225 interruptible_sleep_on(&(pd->rd_queue));
226 else
227 return (-EAGAIN);
228
229 }
230 if (!(inf = *((struct log_data **) file->private_data)))
231 return (0);
232
233 inf->usage_cnt--; /* new usage count */
234 file->private_data = &inf->next; /* next structure */
235 if ((len = strlen(inf->log_start)) <= count) {
236 if (copy_to_user(buf, inf->log_start, len))
237 return -EFAULT;
238 *off += len;
239 return (len);
240 }
241 return (0);
242} /* hysdn_log_read */
243
244/******************/
245/* open log file */
246/******************/
247static int
248hysdn_log_open(struct inode *ino, struct file *filep)
249{
250 hysdn_card *card;
251 struct procdata *pd = NULL;
Andrew Mortonc721bcc2006-03-25 03:07:04 -0800252 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 lock_kernel();
255 card = card_root;
256 while (card) {
257 pd = card->proclog;
258 if (pd->log == PDE(ino))
259 break;
260 card = card->next; /* search next entry */
261 }
262 if (!card) {
263 unlock_kernel();
264 return (-ENODEV); /* device is unknown/invalid */
265 }
266 filep->private_data = card; /* remember our own card */
267
268 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
269 /* write only access -> write log level only */
270 } else if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
271
272 /* read access -> log/debug read */
273 save_flags(flags);
274 cli();
275 pd->if_used++;
276 if (pd->log_head)
277 filep->private_data = &pd->log_tail->next;
278 else
279 filep->private_data = &pd->log_head;
280 restore_flags(flags);
281 } else { /* simultaneous read/write access forbidden ! */
282 unlock_kernel();
283 return (-EPERM); /* no permission this time */
284 }
285 unlock_kernel();
286 return nonseekable_open(ino, filep);
287} /* hysdn_log_open */
288
289/*******************************************************************************/
290/* close a cardlog file. If the file has been opened for exclusive write it is */
291/* assumed as pof data input and the pof loader is noticed about. */
292/* Otherwise file is handled as log output. In this case the interface usage */
293/* count is decremented and all buffers are noticed of closing. If this file */
294/* was the last one to be closed, all buffers are freed. */
295/*******************************************************************************/
296static int
297hysdn_log_close(struct inode *ino, struct file *filep)
298{
299 struct log_data *inf;
300 struct procdata *pd;
301 hysdn_card *card;
302 int retval = 0;
303 unsigned long flags;
304
305
306 lock_kernel();
307 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
308 /* write only access -> write debug level written */
309 retval = 0; /* success */
310 } else {
311 /* read access -> log/debug read, mark one further file as closed */
312
313 pd = NULL;
314 save_flags(flags);
315 cli();
316 inf = *((struct log_data **) filep->private_data); /* get first log entry */
317 if (inf)
318 pd = (struct procdata *) inf->proc_ctrl; /* still entries there */
319 else {
320 /* no info available -> search card */
321 card = card_root;
322 while (card) {
323 pd = card->proclog;
324 if (pd->log == PDE(ino))
325 break;
326 card = card->next; /* search next entry */
327 }
328 if (card)
329 pd = card->proclog; /* pointer to procfs log */
330 }
331 if (pd)
332 pd->if_used--; /* decrement interface usage count by one */
333
334 while (inf) {
335 inf->usage_cnt--; /* decrement usage count for buffers */
336 inf = inf->next;
337 }
338 restore_flags(flags);
339
340 if (pd)
341 if (pd->if_used <= 0) /* delete buffers if last file closed */
342 while (pd->log_head) {
343 inf = pd->log_head;
344 pd->log_head = pd->log_head->next;
345 kfree(inf);
346 }
347 } /* read access */
348 unlock_kernel();
349
350 return (retval);
351} /* hysdn_log_close */
352
353/*************************************************/
354/* select/poll routine to be able using select() */
355/*************************************************/
356static unsigned int
357hysdn_log_poll(struct file *file, poll_table * wait)
358{
359 unsigned int mask = 0;
360 struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
361 hysdn_card *card;
362 struct procdata *pd = NULL;
363
364 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE)
365 return (mask); /* no polling for write supported */
366
367 /* we need to search the card */
368 card = card_root;
369 while (card) {
370 pd = card->proclog;
371 if (pd->log == pde)
372 break;
373 card = card->next; /* search next entry */
374 }
375 if (!card)
376 return (mask); /* card not found */
377
378 poll_wait(file, &(pd->rd_queue), wait);
379
380 if (*((struct log_data **) file->private_data))
381 mask |= POLLIN | POLLRDNORM;
382
383 return mask;
384} /* hysdn_log_poll */
385
386/**************************************************/
387/* table for log filesystem functions defined above. */
388/**************************************************/
389static struct file_operations log_fops =
390{
391 .llseek = no_llseek,
392 .read = hysdn_log_read,
393 .write = hysdn_log_write,
394 .poll = hysdn_log_poll,
395 .open = hysdn_log_open,
396 .release = hysdn_log_close,
397};
398
399
400/***********************************************************************************/
401/* hysdn_proclog_init is called when the module is loaded after creating the cards */
402/* conf files. */
403/***********************************************************************************/
404int
405hysdn_proclog_init(hysdn_card * card)
406{
407 struct procdata *pd;
408
409 /* create a cardlog proc entry */
410
411 if ((pd = (struct procdata *) kmalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
412 memset(pd, 0, sizeof(struct procdata));
413 sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
414 if ((pd->log = create_proc_entry(pd->log_name, S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry)) != NULL) {
415 pd->log->proc_fops = &log_fops;
416 pd->log->owner = THIS_MODULE;
417 }
418
419 init_waitqueue_head(&(pd->rd_queue));
420
421 card->proclog = (void *) pd; /* remember procfs structure */
422 }
423 return (0);
424} /* hysdn_proclog_init */
425
426/************************************************************************************/
427/* hysdn_proclog_release is called when the module is unloaded and before the cards */
428/* conf file is released */
429/* The module counter is assumed to be 0 ! */
430/************************************************************************************/
431void
432hysdn_proclog_release(hysdn_card * card)
433{
434 struct procdata *pd;
435
436 if ((pd = (struct procdata *) card->proclog) != NULL) {
437 if (pd->log)
438 remove_proc_entry(pd->log_name, hysdn_proc_entry);
439 kfree(pd); /* release memory */
440 card->proclog = NULL;
441 }
442} /* hysdn_proclog_release */