1 /* $Id: hysdn_proclog.c,v 1.9.6.3 2001/09/23 22:24:54 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 #include <linux/module.h>
14 #include <linux/poll.h>
15 #include <linux/proc_fs.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/smp_lock.h>
20 #include "hysdn_defs.h"
22 /* the proc subdir for the interface is defined in the procconf module */
23 extern struct proc_dir_entry
*hysdn_proc_entry
;
25 static void put_log_buffer(hysdn_card
* card
, char *cp
);
27 /*************************************************/
28 /* structure keeping ascii log for device output */
29 /*************************************************/
31 struct log_data
*next
;
32 unsigned long usage_cnt
;/* number of files still to work */
33 void *proc_ctrl
; /* pointer to own control procdata structure */
34 char log_start
[2]; /* log string start (final len aligned by size) */
37 /**********************************************/
38 /* structure holding proc entrys for one card */
39 /**********************************************/
41 struct proc_dir_entry
*log
; /* log entry */
42 char log_name
[15]; /* log filename */
43 struct log_data
*log_head
, *log_tail
; /* head and tail for queue */
44 int if_used
; /* open count for interface */
45 int volatile del_lock
; /* lock for delete operations */
46 unsigned char logtmp
[LOG_MAX_LINELEN
];
47 wait_queue_head_t rd_queue
;
51 /**********************************************/
52 /* log function for cards error log interface */
53 /**********************************************/
55 hysdn_card_errlog(hysdn_card
* card
, tErrLogEntry
* logp
, int maxsize
)
57 char buf
[ERRLOG_TEXT_SIZE
+ 40];
59 sprintf(buf
, "LOG 0x%08lX 0x%08lX : %s\n", logp
->ulErrType
, logp
->ulErrSubtype
, logp
->ucText
);
60 put_log_buffer(card
, buf
); /* output the string */
61 } /* hysdn_card_errlog */
63 /***************************************************/
64 /* Log function using format specifiers for output */
65 /***************************************************/
67 hysdn_addlog(hysdn_card
* card
, char *fmt
,...)
69 struct procdata
*pd
= card
->proclog
;
74 return; /* log structure non existent */
77 cp
+= sprintf(cp
, "HYSDN: card %d ", card
->myid
);
80 cp
+= vsprintf(cp
, fmt
, args
);
85 if (card
->debug_flags
& DEB_OUT_SYSLOG
)
86 printk(KERN_INFO
"%s", pd
->logtmp
);
88 put_log_buffer(card
, pd
->logtmp
);
92 /********************************************/
93 /* put an log buffer into the log queue. */
94 /* This buffer will be kept until all files */
95 /* opened for read got the contents. */
96 /* Flushes buffers not longer in use. */
97 /********************************************/
99 put_log_buffer(hysdn_card
* card
, char *cp
)
102 struct procdata
*pd
= card
->proclog
;
112 if (pd
->if_used
<= 0)
113 return; /* no open file for read */
115 if (!(ib
= kmalloc(sizeof(struct log_data
) + strlen(cp
), GFP_ATOMIC
)))
116 return; /* no memory */
117 strcpy(ib
->log_start
, cp
); /* set output string */
119 ib
->proc_ctrl
= pd
; /* point to own control structure */
120 spin_lock_irqsave(&card
->hysdn_lock
, flags
);
121 ib
->usage_cnt
= pd
->if_used
;
123 pd
->log_head
= ib
; /* new head */
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 spin_unlock_irqrestore(&card
->hysdn_lock
, flags
);
130 /* delete old entrys */
132 while (pd
->log_head
->next
) {
133 if ((pd
->log_head
->usage_cnt
<= 0) &&
134 (pd
->log_head
->next
->usage_cnt
<= 0)) {
136 pd
->log_head
= pd
->log_head
->next
;
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 */
146 /******************************/
147 /* file operations and tables */
148 /******************************/
150 /****************************************/
151 /* write log file -> set log level bits */
152 /****************************************/
154 hysdn_log_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
* off
)
158 unsigned char *cp
, valbuf
[128];
160 hysdn_card
*card
= (hysdn_card
*) file
->private_data
;
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 */
167 valbuf
[count
] = 0; /* terminating 0 */
169 if ((count
> 2) && (valbuf
[0] == '0') && (valbuf
[1] == 'x')) {
170 cp
+= 2; /* pointer after hex modifier */
173 /* scan the input for debug flags */
175 if ((*cp
>= '0') && (*cp
<= '9')) {
177 u
*= base
; /* adjust to next digit */
182 break; /* end of number */
184 if ((*cp
>= 'a') && (*cp
<= 'f')) {
186 u
*= base
; /* adjust to next digit */
187 u
+= *cp
++ - 'a' + 10;
190 break; /* terminated */
194 card
->debug_flags
= u
; /* remember debug flags */
195 hysdn_addlog(card
, "debug set to 0x%lx", card
->debug_flags
);
198 } /* hysdn_log_write */
204 hysdn_log_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
* off
)
206 struct log_data
*inf
;
208 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
209 struct procdata
*pd
= NULL
;
212 if (!*((struct log_data
**) file
->private_data
)) {
213 if (file
->f_flags
& O_NONBLOCK
)
216 /* sorry, but we need to search the card */
222 card
= card
->next
; /* search next entry */
225 interruptible_sleep_on(&(pd
->rd_queue
));
230 if (!(inf
= *((struct log_data
**) file
->private_data
)))
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
))
242 } /* hysdn_log_read */
248 hysdn_log_open(struct inode
*ino
, struct file
*filep
)
251 struct procdata
*pd
= NULL
;
258 if (pd
->log
== PDE(ino
))
260 card
= card
->next
; /* search next entry */
264 return (-ENODEV
); /* device is unknown/invalid */
266 filep
->private_data
= card
; /* remember our own card */
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
) {
272 /* read access -> log/debug read */
273 spin_lock_irqsave(&card
->hysdn_lock
, flags
);
276 filep
->private_data
= &pd
->log_tail
->next
;
278 filep
->private_data
= &pd
->log_head
;
279 spin_unlock_irqrestore(&card
->hysdn_lock
, flags
);
280 } else { /* simultaneous read/write access forbidden ! */
282 return (-EPERM
); /* no permission this time */
285 return nonseekable_open(ino
, filep
);
286 } /* hysdn_log_open */
288 /*******************************************************************************/
289 /* close a cardlog file. If the file has been opened for exclusive write it is */
290 /* assumed as pof data input and the pof loader is noticed about. */
291 /* Otherwise file is handled as log output. In this case the interface usage */
292 /* count is decremented and all buffers are noticed of closing. If this file */
293 /* was the last one to be closed, all buffers are freed. */
294 /*******************************************************************************/
296 hysdn_log_close(struct inode
*ino
, struct file
*filep
)
298 struct log_data
*inf
;
304 if ((filep
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_WRITE
) {
305 /* write only access -> write debug level written */
306 retval
= 0; /* success */
308 /* read access -> log/debug read, mark one further file as closed */
311 inf
= *((struct log_data
**) filep
->private_data
); /* get first log entry */
313 pd
= (struct procdata
*) inf
->proc_ctrl
; /* still entries there */
315 /* no info available -> search card */
319 if (pd
->log
== PDE(ino
))
321 card
= card
->next
; /* search next entry */
324 pd
= card
->proclog
; /* pointer to procfs log */
327 pd
->if_used
--; /* decrement interface usage count by one */
330 inf
->usage_cnt
--; /* decrement usage count for buffers */
335 if (pd
->if_used
<= 0) /* delete buffers if last file closed */
336 while (pd
->log_head
) {
338 pd
->log_head
= pd
->log_head
->next
;
345 } /* hysdn_log_close */
347 /*************************************************/
348 /* select/poll routine to be able using select() */
349 /*************************************************/
351 hysdn_log_poll(struct file
*file
, poll_table
* wait
)
353 unsigned int mask
= 0;
354 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
356 struct procdata
*pd
= NULL
;
358 if ((file
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_WRITE
)
359 return (mask
); /* no polling for write supported */
361 /* we need to search the card */
367 card
= card
->next
; /* search next entry */
370 return (mask
); /* card not found */
372 poll_wait(file
, &(pd
->rd_queue
), wait
);
374 if (*((struct log_data
**) file
->private_data
))
375 mask
|= POLLIN
| POLLRDNORM
;
378 } /* hysdn_log_poll */
380 /**************************************************/
381 /* table for log filesystem functions defined above. */
382 /**************************************************/
383 static const struct file_operations log_fops
=
385 .owner
= THIS_MODULE
,
387 .read
= hysdn_log_read
,
388 .write
= hysdn_log_write
,
389 .poll
= hysdn_log_poll
,
390 .open
= hysdn_log_open
,
391 .release
= hysdn_log_close
,
395 /***********************************************************************************/
396 /* hysdn_proclog_init is called when the module is loaded after creating the cards */
398 /***********************************************************************************/
400 hysdn_proclog_init(hysdn_card
* card
)
404 /* create a cardlog proc entry */
406 if ((pd
= kzalloc(sizeof(struct procdata
), GFP_KERNEL
)) != NULL
) {
407 sprintf(pd
->log_name
, "%s%d", PROC_LOG_BASENAME
, card
->myid
);
408 pd
->log
= proc_create(pd
->log_name
,
409 S_IFREG
| S_IRUGO
| S_IWUSR
, hysdn_proc_entry
,
412 init_waitqueue_head(&(pd
->rd_queue
));
414 card
->proclog
= (void *) pd
; /* remember procfs structure */
417 } /* hysdn_proclog_init */
419 /************************************************************************************/
420 /* hysdn_proclog_release is called when the module is unloaded and before the cards */
421 /* conf file is released */
422 /* The module counter is assumed to be 0 ! */
423 /************************************************************************************/
425 hysdn_proclog_release(hysdn_card
* card
)
429 if ((pd
= (struct procdata
*) card
->proclog
) != NULL
) {
431 remove_proc_entry(pd
->log_name
, hysdn_proc_entry
);
432 kfree(pd
); /* release memory */
433 card
->proclog
= NULL
;
435 } /* hysdn_proclog_release */