1 /* $Id: hysdn_proclog.c,v 1.1.4.1 2001/11/20 14:19:37 kai Exp $
3 * Linux driver for HYSDN cards, /proc/net filesystem log functions.
5 * Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
6 * Copyright 1999 by Werner Cornelius (werner@titro.de)
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
13 #define __NO_VERSION__
14 #include <linux/module.h>
15 #include <linux/version.h>
16 #include <linux/poll.h>
17 #include <linux/proc_fs.h>
18 #include <linux/pci.h>
19 #include <linux/smp_lock.h>
21 #include "hysdn_defs.h"
23 /* the proc subdir for the interface is defined in the procconf module */
24 extern struct proc_dir_entry *hysdn_proc_entry;
26 /*************************************************/
27 /* structure keeping ascii log for device output */
28 /*************************************************/
30 struct log_data *next;
31 ulong usage_cnt; /* number of files still to work */
32 void *proc_ctrl; /* pointer to own control procdata structure */
33 char log_start[2]; /* log string start (final len aligned by size) */
36 /**********************************************/
37 /* structure holding proc entrys for one card */
38 /**********************************************/
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 */
45 uchar logtmp[LOG_MAX_LINELEN];
46 wait_queue_head_t rd_queue;
50 /**********************************************/
51 /* log function for cards error log interface */
52 /**********************************************/
54 hysdn_card_errlog(hysdn_card * card, tErrLogEntry * logp, int maxsize)
56 char buf[ERRLOG_TEXT_SIZE + 40];
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 */
62 /***************************************************/
63 /* Log function using format specifiers for output */
64 /***************************************************/
66 hysdn_addlog(hysdn_card * card, char *fmt,...)
68 struct procdata *pd = card->proclog;
73 return; /* log structure non existent */
76 cp += sprintf(cp, "HYSDN: card %d ", card->myid);
79 cp += vsprintf(cp, fmt, args);
84 if (card->debug_flags & DEB_OUT_SYSLOG)
85 printk(KERN_INFO "%s", pd->logtmp);
87 put_log_buffer(card, pd->logtmp);
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 /********************************************/
98 put_log_buffer(hysdn_card * card, char *cp)
101 struct procdata *pd = card->proclog;
110 if (pd->if_used <= 0)
111 return; /* no open file for read */
113 if (!(ib = (struct log_data *) kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
114 return; /* no memory */
115 strcpy(ib->log_start, cp); /* set output string */
117 ib->proc_ctrl = pd; /* point to own control structure */
120 ib->usage_cnt = pd->if_used;
122 pd->log_head = ib; /* new head */
124 pd->log_tail->next = ib; /* follows existing messages */
125 pd->log_tail = ib; /* new tail */
126 i = pd->del_lock++; /* get lock state */
127 restore_flags(flags);
129 /* delete old entrys */
131 while (pd->log_head->next) {
132 if ((pd->log_head->usage_cnt <= 0) &&
133 (pd->log_head->next->usage_cnt <= 0)) {
135 pd->log_head = pd->log_head->next;
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 */
145 /******************************/
146 /* file operations and tables */
147 /******************************/
149 /****************************************/
150 /* write log file -> set log level bits */
151 /****************************************/
153 hysdn_log_write(struct file *file, const char *buf, size_t count, loff_t * off)
157 uchar *cp, valbuf[128];
159 hysdn_card *card = (hysdn_card *) file->private_data;
161 if (&file->f_pos != off) /* fs error check */
164 if (count > (sizeof(valbuf) - 1))
165 count = sizeof(valbuf) - 1; /* limit length */
166 if (copy_from_user(valbuf, buf, count))
167 return (-EFAULT); /* copy failed */
169 valbuf[count] = 0; /* terminating 0 */
171 if ((count > 2) && (valbuf[0] == '0') && (valbuf[1] == 'x')) {
172 cp += 2; /* pointer after hex modifier */
175 /* scan the input for debug flags */
177 if ((*cp >= '0') && (*cp <= '9')) {
179 u *= base; /* adjust to next digit */
184 break; /* end of number */
186 if ((*cp >= 'a') && (*cp <= 'f')) {
188 u *= base; /* adjust to next digit */
189 u += *cp++ - 'a' + 10;
192 break; /* terminated */
196 card->debug_flags = u; /* remember debug flags */
197 hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
200 } /* hysdn_log_write */
206 hysdn_log_read(struct file *file, char *buf, size_t count, loff_t * off)
208 struct log_data *inf;
211 struct procdata *pd = NULL;
215 if (!*((struct log_data **) file->private_data)) {
216 if (file->f_flags & O_NONBLOCK)
219 /* sorry, but we need to search the card */
220 ino = file->f_dentry->d_inode->i_ino & 0xFFFF; /* low-ino */
224 if (pd->log->low_ino == ino)
226 card = card->next; /* search next entry */
229 interruptible_sleep_on(&(pd->rd_queue));
234 if (!(inf = *((struct log_data **) file->private_data)))
237 inf->usage_cnt--; /* new usage count */
238 file->private_data = &inf->next; /* next structure */
239 if ((len = strlen(inf->log_start)) <= count) {
240 if (copy_to_user(buf, inf->log_start, len))
246 } /* hysdn_log_read */
252 hysdn_log_open(struct inode *ino, struct file *filep)
255 struct procdata *pd = NULL;
262 if (pd->log->low_ino == (ino->i_ino & 0xFFFF))
264 card = card->next; /* search next entry */
268 return (-ENODEV); /* device is unknown/invalid */
270 filep->private_data = card; /* remember our own card */
272 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
273 /* write only access -> write log level only */
274 } else if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
276 /* read access -> log/debug read */
281 filep->private_data = &(pd->log_tail->next);
283 filep->private_data = &(pd->log_head);
284 restore_flags(flags);
285 } else { /* simultaneous read/write access forbidden ! */
287 return (-EPERM); /* no permission this time */
291 } /* hysdn_log_open */
293 /*******************************************************************************/
294 /* close a cardlog file. If the file has been opened for exclusive write it is */
295 /* assumed as pof data input and the pof loader is noticed about. */
296 /* Otherwise file is handled as log output. In this case the interface usage */
297 /* count is decremented and all buffers are noticed of closing. If this file */
298 /* was the last one to be closed, all buffers are freed. */
299 /*******************************************************************************/
301 hysdn_log_close(struct inode *ino, struct file *filep)
303 struct log_data *inf;
306 int flags, retval = 0;
310 if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
311 /* write only access -> write debug level written */
312 retval = 0; /* success */
314 /* read access -> log/debug read, mark one further file as closed */
319 inf = *((struct log_data **) filep->private_data); /* get first log entry */
321 pd = (struct procdata *) inf->proc_ctrl; /* still entries there */
323 /* no info available -> search card */
327 if (pd->log->low_ino == (ino->i_ino & 0xFFFF))
329 card = card->next; /* search next entry */
332 pd = card->proclog; /* pointer to procfs log */
335 pd->if_used--; /* decrement interface usage count by one */
338 inf->usage_cnt--; /* decrement usage count for buffers */
341 restore_flags(flags);
344 if (pd->if_used <= 0) /* delete buffers if last file closed */
345 while (pd->log_head) {
347 pd->log_head = pd->log_head->next;
354 } /* hysdn_log_close */
356 /*************************************************/
357 /* select/poll routine to be able using select() */
358 /*************************************************/
360 hysdn_log_poll(struct file *file, poll_table * wait)
362 unsigned int mask = 0;
365 struct procdata *pd = NULL;
367 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE)
368 return (mask); /* no polling for write supported */
370 /* we need to search the card */
371 ino = file->f_dentry->d_inode->i_ino & 0xFFFF; /* low-ino */
375 if (pd->log->low_ino == ino)
377 card = card->next; /* search next entry */
380 return (mask); /* card not found */
382 poll_wait(file, &(pd->rd_queue), wait);
384 if (*((struct log_data **) file->private_data))
385 mask |= POLLIN | POLLRDNORM;
388 } /* hysdn_log_poll */
390 /**************************************************/
391 /* table for log filesystem functions defined above. */
392 /**************************************************/
393 static struct file_operations log_fops =
396 read: hysdn_log_read,
397 write: hysdn_log_write,
398 poll: hysdn_log_poll,
399 open: hysdn_log_open,
400 release: hysdn_log_close,
404 /***********************************************************************************/
405 /* hysdn_proclog_init is called when the module is loaded after creating the cards */
407 /***********************************************************************************/
409 hysdn_proclog_init(hysdn_card * card)
413 /* create a cardlog proc entry */
415 if ((pd = (struct procdata *) kmalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
416 memset(pd, 0, sizeof(struct procdata));
417 sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
418 if ((pd->log = create_proc_entry(pd->log_name, S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry)) != NULL) {
419 pd->log->proc_fops = &log_fops;
420 pd->log->owner = THIS_MODULE;
423 init_waitqueue_head(&(pd->rd_queue));
425 card->proclog = (void *) pd; /* remember procfs structure */
428 } /* hysdn_proclog_init */
430 /************************************************************************************/
431 /* hysdn_proclog_release is called when the module is unloaded and before the cards */
432 /* conf file is released */
433 /* The module counter is assumed to be 0 ! */
434 /************************************************************************************/
436 hysdn_proclog_release(hysdn_card * card)
440 if ((pd = (struct procdata *) card->proclog) != NULL) {
442 remove_proc_entry(pd->log_name, hysdn_proc_entry);
443 kfree(pd); /* release memory */
444 card->proclog = NULL;
446 } /* hysdn_proclog_release */