Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 441 insertions, 0 deletions

diff --git a/drivers/isdn/hysdn/hysdn_proclog.c b/drivers/isdn/hysdn/hysdn_proclog.c
new file mode 100644
index 000000000000..8ef2b7c952a6
--- /dev/null
+++ b/drivers/isdn/hysdn/hysdn_proclog.c
@@ -0,0 +1,441 @@
+/* $Id: hysdn_proclog.c,v 1.9.6.3 2001/09/23 22:24:54 kai Exp $
+ *
+ * Linux driver for HYSDN cards, /proc/net filesystem log functions.
+ *
+ * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
+ * Copyright 1999 by Werner Cornelius (werner@titro.de)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/poll.h>
+#include <linux/proc_fs.h>
+#include <linux/pci.h>
+#include <linux/smp_lock.h>
+
+#include "hysdn_defs.h"
+
+/* the proc subdir for the interface is defined in the procconf module */
+extern struct proc_dir_entry *hysdn_proc_entry;
+
+/*************************************************/
+/* structure keeping ascii log for device output */
+/*************************************************/
+struct log_data {
+        struct log_data *next;
+        ulong usage_cnt;        /* number of files still to work */
+        void *proc_ctrl;        /* pointer to own control procdata structure */
+        char log_start[2];      /* log string start (final len aligned by size) */
+};
+
+/**********************************************/
+/* structure holding proc entrys for one card */
+/**********************************************/
+struct procdata {
+        struct proc_dir_entry *log;     /* log entry */
+        char log_name[15];      /* log filename */
+        struct log_data *log_head, *log_tail;   /* head and tail for queue */
+        int if_used;            /* open count for interface */
+        int volatile del_lock;  /* lock for delete operations */
+        uchar logtmp[LOG_MAX_LINELEN];
+        wait_queue_head_t rd_queue;
+};
+
+
+/**********************************************/
+/* log function for cards error log interface */
+/**********************************************/
+void
+hysdn_card_errlog(hysdn_card * card, tErrLogEntry * logp, int maxsize)
+{
+        char buf[ERRLOG_TEXT_SIZE + 40];
+
+        sprintf(buf, "LOG 0x%08lX 0x%08lX : %s\n", logp->ulErrType, logp->ulErrSubtype, logp->ucText);
+        put_log_buffer(card, buf);      /* output the string */
+}                               /* hysdn_card_errlog */
+
+/***************************************************/
+/* Log function using format specifiers for output */
+/***************************************************/
+void
+hysdn_addlog(hysdn_card * card, char *fmt,...)
+{
+        struct procdata *pd = card->proclog;
+        char *cp;
+        va_list args;
+
+        if (!pd)
+                return;         /* log structure non existent */
+
+        cp = pd->logtmp;
+        cp += sprintf(cp, "HYSDN: card %d ", card->myid);
+
+        va_start(args, fmt);
+        cp += vsprintf(cp, fmt, args);
+        va_end(args);
+        *cp++ = '\n';
+        *cp = 0;
+
+        if (card->debug_flags & DEB_OUT_SYSLOG)
+                printk(KERN_INFO "%s", pd->logtmp);
+        else
+                put_log_buffer(card, pd->logtmp);
+
+}                               /* hysdn_addlog */
+
+/********************************************/
+/* put an log buffer into the log queue.    */
+/* This buffer will be kept until all files */
+/* opened for read got the contents.        */
+/* Flushes buffers not longer in use.       */
+/********************************************/
+void
+put_log_buffer(hysdn_card * card, char *cp)
+{
+        struct log_data *ib;
+        struct procdata *pd = card->proclog;
+        int i;
+        unsigned long flags;
+
+        if (!pd)
+                return;
+        if (!cp)
+                return;
+        if (!*cp)
+                return;
+        if (pd->if_used <= 0)
+                return;         /* no open file for read */
+
+        if (!(ib = (struct log_data *) kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
+                 return;        /* no memory */
+        strcpy(ib->log_start, cp);      /* set output string */
+        ib->next = NULL;
+        ib->proc_ctrl = pd;     /* point to own control structure */
+        save_flags(flags);
+        cli();
+        ib->usage_cnt = pd->if_used;
+        if (!pd->log_head)
+                pd->log_head = ib;      /* new head */
+        else
+                pd->log_tail->next = ib;        /* follows existing messages */
+        pd->log_tail = ib;      /* new tail */
+        i = pd->del_lock++;     /* get lock state */
+        restore_flags(flags);
+
+        /* delete old entrys */
+        if (!i)
+                while (pd->log_head->next) {
+                        if ((pd->log_head->usage_cnt <= 0) &&
+                            (pd->log_head->next->usage_cnt <= 0)) {
+                                ib = pd->log_head;
+                                pd->log_head = pd->log_head->next;
+                                kfree(ib);
+                        } else
+                                break;
+                }               /* pd->log_head->next */
+        pd->del_lock--;         /* release lock level */
+        wake_up_interruptible(&(pd->rd_queue));         /* announce new entry */
+}                               /* put_log_buffer */
+
+
+/******************************/
+/* file operations and tables */
+/******************************/
+
+/****************************************/
+/* write log file -> set log level bits */
+/****************************************/
+static ssize_t
+hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
+{
+        ulong u = 0;
+        int found = 0;
+        uchar *cp, valbuf[128];
+        long base = 10;
+        hysdn_card *card = (hysdn_card *) file->private_data;
+
+        if (count > (sizeof(valbuf) - 1))
+                count = sizeof(valbuf) - 1;     /* limit length */
+        if (copy_from_user(valbuf, buf, count))
+                return (-EFAULT);       /* copy failed */
+
+        valbuf[count] = 0;      /* terminating 0 */
+        cp = valbuf;
+        if ((count > 2) && (valbuf[0] == '0') && (valbuf[1] == 'x')) {
+                cp += 2;        /* pointer after hex modifier */
+                base = 16;
+        }
+        /* scan the input for debug flags */
+        while (*cp) {
+                if ((*cp >= '0') && (*cp <= '9')) {
+                        found = 1;
+                        u *= base;      /* adjust to next digit */
+                        u += *cp++ - '0';
+                        continue;
+                }
+                if (base != 16)
+                        break;  /* end of number */
+
+                if ((*cp >= 'a') && (*cp <= 'f')) {
+                        found = 1;
+                        u *= base;      /* adjust to next digit */
+                        u += *cp++ - 'a' + 10;
+                        continue;
+                }
+                break;          /* terminated */
+        }
+
+        if (found) {
+                card->debug_flags = u;  /* remember debug flags */
+                hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
+        }
+        return (count);
+}                               /* hysdn_log_write */
+
+/******************/
+/* read log file */
+/******************/
+static ssize_t
+hysdn_log_read(struct file *file, char __user *buf, size_t count, loff_t * off)
+{
+        struct log_data *inf;
+        int len;
+        struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
+        struct procdata *pd = NULL;
+        hysdn_card *card;
+
+        if (!*((struct log_data **) file->private_data)) {
+                if (file->f_flags & O_NONBLOCK)
+                        return (-EAGAIN);
+
+                /* sorry, but we need to search the card */
+                card = card_root;
+                while (card) {
+                        pd = card->proclog;
+                        if (pd->log == pde)
+                                break;
+                        card = card->next;      /* search next entry */
+                }
+                if (card)
+                        interruptible_sleep_on(&(pd->rd_queue));
+                else
+                        return (-EAGAIN);
+
+        }
+        if (!(inf = *((struct log_data **) file->private_data)))
+                return (0);
+
+        inf->usage_cnt--;       /* new usage count */
+        file->private_data = &inf->next;        /* next structure */
+        if ((len = strlen(inf->log_start)) <= count) {
+                if (copy_to_user(buf, inf->log_start, len))
+                        return -EFAULT;
+                *off += len;
+                return (len);
+        }
+        return (0);
+}                               /* hysdn_log_read */
+
+/******************/
+/* open log file */
+/******************/
+static int
+hysdn_log_open(struct inode *ino, struct file *filep)
+{
+        hysdn_card *card;
+        struct procdata *pd = NULL;
+        ulong flags;
+
+        lock_kernel();
+        card = card_root;
+        while (card) {
+                pd = card->proclog;
+                if (pd->log == PDE(ino))
+                        break;
+                card = card->next;      /* search next entry */
+        }
+        if (!card) {
+                unlock_kernel();
+                return (-ENODEV);       /* device is unknown/invalid */
+        }
+        filep->private_data = card;     /* remember our own card */
+
+        if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
+                /* write only access -> write log level only */
+        } else if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
+
+                /* read access -> log/debug read */
+                save_flags(flags);
+                cli();
+                pd->if_used++;
+                if (pd->log_head)
+                        filep->private_data = &pd->log_tail->next;
+                else
+                        filep->private_data = &pd->log_head;
+                restore_flags(flags);
+        } else {                /* simultaneous read/write access forbidden ! */
+                unlock_kernel();
+                return (-EPERM);        /* no permission this time */
+        }
+        unlock_kernel();
+        return nonseekable_open(ino, filep);
+}                               /* hysdn_log_open */
+
+/*******************************************************************************/
+/* close a cardlog file. If the file has been opened for exclusive write it is */
+/* assumed as pof data input and the pof loader is noticed about.              */
+/* Otherwise file is handled as log output. In this case the interface usage   */
+/* count is decremented and all buffers are noticed of closing. If this file   */
+/* was the last one to be closed, all buffers are freed.                       */
+/*******************************************************************************/
+static int
+hysdn_log_close(struct inode *ino, struct file *filep)
+{
+        struct log_data *inf;
+        struct procdata *pd;
+        hysdn_card *card;
+        int retval = 0;
+        unsigned long flags;
+
+
+        lock_kernel();
+        if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
+                /* write only access -> write debug level written */
+                retval = 0;     /* success */
+        } else {
+                /* read access -> log/debug read, mark one further file as closed */
+
+                pd = NULL;
+                save_flags(flags);
+                cli();
+                inf = *((struct log_data **) filep->private_data);      /* get first log entry */
+                if (inf)
+                        pd = (struct procdata *) inf->proc_ctrl;        /* still entries there */
+                else {
+                        /* no info available -> search card */
+                        card = card_root;
+                        while (card) {
+                                pd = card->proclog;
+                                if (pd->log == PDE(ino))
+                                        break;
+                                card = card->next;      /* search next entry */
+                        }
+                        if (card)
+                                pd = card->proclog;     /* pointer to procfs log */
+                }
+                if (pd)
+                        pd->if_used--;  /* decrement interface usage count by one */
+
+                while (inf) {
+                        inf->usage_cnt--;       /* decrement usage count for buffers */
+                        inf = inf->next;
+                }
+                restore_flags(flags);
+
+                if (pd)
+                        if (pd->if_used <= 0)   /* delete buffers if last file closed */
+                                while (pd->log_head) {
+                                        inf = pd->log_head;
+                                        pd->log_head = pd->log_head->next;
+                                        kfree(inf);
+                                }
+        }                       /* read access */
+        unlock_kernel();
+
+        return (retval);
+}                               /* hysdn_log_close */
+
+/*************************************************/
+/* select/poll routine to be able using select() */
+/*************************************************/
+static unsigned int
+hysdn_log_poll(struct file *file, poll_table * wait)
+{
+        unsigned int mask = 0;
+        struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
+        hysdn_card *card;
+        struct procdata *pd = NULL;
+
+        if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE)
+                return (mask);  /* no polling for write supported */
+
+        /* we need to search the card */
+        card = card_root;
+        while (card) {
+                pd = card->proclog;
+                if (pd->log == pde)
+                        break;
+                card = card->next;      /* search next entry */
+        }
+        if (!card)
+                return (mask);  /* card not found */
+
+        poll_wait(file, &(pd->rd_queue), wait);
+
+        if (*((struct log_data **) file->private_data))
+                mask |= POLLIN | POLLRDNORM;
+
+        return mask;
+}                               /* hysdn_log_poll */
+
+/**************************************************/
+/* table for log filesystem functions defined above. */
+/**************************************************/
+static struct file_operations log_fops =
+{
+        .llseek         = no_llseek,
+        .read           = hysdn_log_read,
+        .write          = hysdn_log_write,
+        .poll           = hysdn_log_poll,
+        .open           = hysdn_log_open,
+        .release        = hysdn_log_close,                                        
+};
+
+
+/***********************************************************************************/
+/* hysdn_proclog_init is called when the module is loaded after creating the cards */
+/* conf files.                                                                     */
+/***********************************************************************************/
+int
+hysdn_proclog_init(hysdn_card * card)
+{
+        struct procdata *pd;
+
+        /* create a cardlog proc entry */
+
+        if ((pd = (struct procdata *) kmalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
+                memset(pd, 0, sizeof(struct procdata));
+                sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
+                if ((pd->log = create_proc_entry(pd->log_name, S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry)) != NULL) {
+                        pd->log->proc_fops = &log_fops; 
+                        pd->log->owner = THIS_MODULE;
+                }
+
+                init_waitqueue_head(&(pd->rd_queue));
+
+                card->proclog = (void *) pd;    /* remember procfs structure */
+        }
+        return (0);
+}                               /* hysdn_proclog_init */
+
+/************************************************************************************/
+/* hysdn_proclog_release is called when the module is unloaded and before the cards */
+/* conf file is released                                                            */
+/* The module counter is assumed to be 0 !                                          */
+/************************************************************************************/
+void
+hysdn_proclog_release(hysdn_card * card)
+{
+        struct procdata *pd;
+
+        if ((pd = (struct procdata *) card->proclog) != NULL) {
+                if (pd->log)
+                        remove_proc_entry(pd->log_name, hysdn_proc_entry);
+                kfree(pd);      /* release memory */
+                card->proclog = NULL;
+        }
+}                               /* hysdn_proclog_release */