SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/hysdn/hysdn_proclog.c

   1 /* $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>
  14 #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 */
  22 extern struct proc_dir_entry *hysdn_proc_entry;
  23
  24 static void put_log_buffer(hysdn_card * card, char *cp);
  25
  26 /*************************************************/
  27 /* structure keeping ascii log for device output */
  28 /*************************************************/
  29 struct log_data {
  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) */
  34 };
  35
  36 /**********************************************/
  37 /* structure holding proc entrys for one card */
  38 /**********************************************/
  39 struct 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 */
  45         uchar logtmp[LOG_MAX_LINELEN];
  46         wait_queue_head_t rd_queue;
  47 };
  48
  49
  50 /**********************************************/
  51 /* log function for cards error log interface */
  52 /**********************************************/
  53 void
  54 hysdn_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 /***************************************************/
  65 void
  66 hysdn_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 /********************************************/
  97 static void
  98 put_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 /****************************************/
 153 static ssize_t
 154 hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
 155 {
 156         ulong u = 0;
 157         int found = 0;
 158         uchar *cp, valbuf[128];
 159         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 /******************/
 203 static ssize_t
 204 hysdn_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 /******************/
 247 static int
 248 hysdn_log_open(struct inode *ino, struct file *filep)
 249 {
 250         hysdn_card *card;
 251         struct procdata *pd = NULL;
 252         ulong flags;
 253
 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 /*******************************************************************************/
 296 static int
 297 hysdn_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 /*************************************************/
 356 static unsigned int
 357 hysdn_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 /**************************************************/
 389 static 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 /***********************************************************************************/
 404 int
 405 hysdn_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 /************************************************************************************/
 431 void
 432 hysdn_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 */