Staging: dgnc: Remove unused sniff code

The output written by dgnc_sniff_nowait_nolock() is never used
anywhere since commit 35cf90459312f ("staging: dgnc: removes proc code")
deleted the code that used to copy it to user space.
dgnc_sniff_nowait_nolock() uses 'timeval' to create header timestamps for
the data dump.

32-bit systems using 'struct timeval' will break in the year 2038,
This patch removes dgnc_sniff_nowait_nolock() and all ch_sniff_* members
of struct channel_t defined in "dgnc_driver.h". It also removes their usage
from the driver files and hence y2038 issue is also resolved.

Signed-off-by: Somya Anand <somyaanand214@gmail.com>
Reviewed-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/dgnc/dgnc_cls.c b/drivers/staging/dgnc/dgnc_cls.c
index c1c4bb9..360fe25 100644 (file)
--- a/drivers/staging/dgnc/dgnc_cls.c
+++ b/drivers/staging/dgnc/dgnc_cls.c
@@ -918,8 +918,6 @@ static void cls_copy_data_from_uart_to_queue(struct channel_t *ch)
                ch->ch_equeue[head] = linestatus & (UART_LSR_BI | UART_LSR_PE
                                                                 | UART_LSR_FE);
                ch->ch_rqueue[head] = readb(&ch->ch_cls_uart->txrx);
-               dgnc_sniff_nowait_nolock(ch, "UART READ",
-                                                ch->ch_rqueue + head, 1);
 
                qleft--;
 
@@ -1086,8 +1084,6 @@ static void cls_copy_data_from_queue_to_uart(struct channel_t *ch)
                        ch->ch_tun.un_flags |= (UN_EMPTY);
                }
                writeb(ch->ch_wqueue[ch->ch_w_tail], &ch->ch_cls_uart->txrx);
-               dgnc_sniff_nowait_nolock(ch, "UART WRITE",
-                                           ch->ch_wqueue + ch->ch_w_tail, 1);
                ch->ch_w_tail++;
                ch->ch_w_tail &= WQUEUEMASK;
                ch->ch_txcount++;

diff --git a/drivers/staging/dgnc/dgnc_driver.h b/drivers/staging/dgnc/dgnc_driver.h
index d5de3e2..695c3c6 100644 (file)
--- a/drivers/staging/dgnc/dgnc_driver.h
+++ b/drivers/staging/dgnc/dgnc_driver.h
@@ -123,8 +123,6 @@
 #define   _POSIX_VDISABLE '\0'
 #endif
 
-#define SNIFF_MAX      65536           /* Sniff buffer size (2^n) */
-#define SNIFF_MASK     (SNIFF_MAX - 1) /* Sniff wrap mask */
 
 /*
  * All the possible states the driver can be while being loaded.
@@ -331,13 +329,6 @@ struct un_t {
 #define CH_FORCED_STOP  0x20000                /* Output is forcibly stopped   */
 #define CH_FORCED_STOPI 0x40000                /* Input is forcibly stopped    */
 
-/*
- * Definitions for ch_sniff_flags
- */
-#define SNIFF_OPEN     0x1
-#define SNIFF_WAIT_DATA        0x2
-#define SNIFF_WAIT_SPACE 0x4
-
 
 /* Our Read/Error/Write queue sizes */
 #define RQUEUEMASK     0x1FFF          /* 8 K - 1 */
@@ -431,11 +422,6 @@ struct channel_t {
        struct proc_dir_entry *proc_entry_pointer;
        struct dgnc_proc_entry *dgnc_channel_table;
 
-       uint ch_sniff_in;
-       uint ch_sniff_out;
-       char *ch_sniff_buf;             /* Sniff buffer for proc */
-       ulong ch_sniff_flags;           /* Channel flags                */
-       wait_queue_head_t ch_sniff_wait;
 };
 
 /*

diff --git a/drivers/staging/dgnc/dgnc_neo.c b/drivers/staging/dgnc/dgnc_neo.c
index 27a525e..cc61364 100644 (file)
--- a/drivers/staging/dgnc/dgnc_neo.c
+++ b/drivers/staging/dgnc/dgnc_neo.c
@@ -1217,7 +1217,6 @@ static void neo_copy_data_from_uart_to_queue(struct channel_t *ch)
 
                /* Copy data from uart to the queue */
                memcpy_fromio(ch->ch_rqueue + head, &ch->ch_neo_uart->txrxburst, n);
-               dgnc_sniff_nowait_nolock(ch, "UART READ", ch->ch_rqueue + head, n);
 
                /*
                 * Since RX_FIFO_DATA_ERROR was 0, we are guarenteed
@@ -1303,7 +1302,6 @@ static void neo_copy_data_from_uart_to_queue(struct channel_t *ch)
 
                memcpy_fromio(ch->ch_rqueue + head, &ch->ch_neo_uart->txrxburst, 1);
                ch->ch_equeue[head] = (unsigned char) linestatus;
-               dgnc_sniff_nowait_nolock(ch, "UART READ", ch->ch_rqueue + head, 1);
 
                /* Ditch any remaining linestatus value. */
                linestatus = 0;
@@ -1556,7 +1554,6 @@ static void neo_copy_data_from_queue_to_uart(struct channel_t *ch)
                }
 
                memcpy_toio(&ch->ch_neo_uart->txrxburst, ch->ch_wqueue + tail, s);
-               dgnc_sniff_nowait_nolock(ch, "UART WRITE", ch->ch_wqueue + tail, s);
 
                /* Add and flip queue if needed */
                tail = (tail + s) & WQUEUEMASK;

diff --git a/drivers/staging/dgnc/dgnc_tty.c b/drivers/staging/dgnc/dgnc_tty.c
index b0fcbe7..8384e3d 100644 (file)
--- a/drivers/staging/dgnc/dgnc_tty.c
+++ b/drivers/staging/dgnc/dgnc_tty.c
@@ -49,7 +49,6 @@
 #include <linux/delay.h>       /* For udelay */
 #include <linux/uaccess.h>     /* For copy_from_user/copy_to_user */
 #include <linux/pci.h>
-
 #include "dgnc_driver.h"
 #include "dgnc_tty.h"
 #include "dgnc_types.h"
@@ -374,7 +373,6 @@ int dgnc_tty_init(struct dgnc_board *brd)
                init_waitqueue_head(&ch->ch_flags_wait);
                init_waitqueue_head(&ch->ch_tun.un_flags_wait);
                init_waitqueue_head(&ch->ch_pun.un_flags_wait);
-               init_waitqueue_head(&ch->ch_sniff_wait);
 
                {
                        struct device *classp;
@@ -449,127 +447,6 @@ void dgnc_tty_uninit(struct dgnc_board *brd)
 
 #define TMPBUFLEN (1024)
 
-/*
- * dgnc_sniff - Dump data out to the "sniff" buffer if the
- * proc sniff file is opened...
- */
-void dgnc_sniff_nowait_nolock(struct channel_t *ch, unsigned char *text, unsigned char *buf, int len)
-{
-       struct timeval tv;
-       int n;
-       int r;
-       int nbuf;
-       int i;
-       int tmpbuflen;
-       char *tmpbuf;
-       char *p;
-       int too_much_data;
-
-       tmpbuf = kzalloc(TMPBUFLEN, GFP_ATOMIC);
-       if (!tmpbuf)
-               return;
-       p = tmpbuf;
-
-       /* Leave if sniff not open */
-       if (!(ch->ch_sniff_flags & SNIFF_OPEN))
-               goto exit;
-
-       do_gettimeofday(&tv);
-
-       /* Create our header for data dump */
-       p += sprintf(p, "<%ld %ld><%s><", tv.tv_sec, tv.tv_usec, text);
-       tmpbuflen = p - tmpbuf;
-
-       do {
-               too_much_data = 0;
-
-               for (i = 0; i < len && tmpbuflen < (TMPBUFLEN - 4); i++) {
-                       p += sprintf(p, "%02x ", *buf);
-                       buf++;
-                       tmpbuflen = p - tmpbuf;
-               }
-
-               if (tmpbuflen < (TMPBUFLEN - 4)) {
-                       if (i > 0)
-                               p += sprintf(p - 1, "%s\n", ">");
-                       else
-                               p += sprintf(p, "%s\n", ">");
-               } else {
-                       too_much_data = 1;
-                       len -= i;
-               }
-
-               nbuf = strlen(tmpbuf);
-               p = tmpbuf;
-
-               /*
-                *  Loop while data remains.
-                */
-               while (nbuf > 0 && ch->ch_sniff_buf) {
-                       /*
-                        *  Determine the amount of available space left in the
-                        *  buffer.  If there's none, wait until some appears.
-                        */
-                       n = (ch->ch_sniff_out - ch->ch_sniff_in - 1) & SNIFF_MASK;
-
-                       /*
-                        * If there is no space left to write to in our sniff buffer,
-                        * we have no choice but to drop the data.
-                        * We *cannot* sleep here waiting for space, because this
-                        * function was probably called by the interrupt/timer routines!
-                        */
-                       if (n == 0)
-                               goto exit;
-
-                       /*
-                        * Copy as much data as will fit.
-                        */
-
-                       if (n > nbuf)
-                               n = nbuf;
-
-                       r = SNIFF_MAX - ch->ch_sniff_in;
-
-                       if (r <= n) {
-                               memcpy(ch->ch_sniff_buf + ch->ch_sniff_in, p, r);
-
-                               n -= r;
-                               ch->ch_sniff_in = 0;
-                               p += r;
-                               nbuf -= r;
-                       }
-
-                       memcpy(ch->ch_sniff_buf + ch->ch_sniff_in, p, n);
-
-                       ch->ch_sniff_in += n;
-                       p += n;
-                       nbuf -= n;
-
-                       /*
-                        *  Wakeup any thread waiting for data
-                        */
-                       if (ch->ch_sniff_flags & SNIFF_WAIT_DATA) {
-                               ch->ch_sniff_flags &= ~SNIFF_WAIT_DATA;
-                               wake_up_interruptible(&ch->ch_sniff_wait);
-                       }
-               }
-
-               /*
-                * If the user sent us too much data to push into our tmpbuf,
-                * we need to keep looping around on all the data.
-                */
-               if (too_much_data) {
-                       p = tmpbuf;
-                       tmpbuflen = 0;
-               }
-
-       } while (too_much_data);
-
-exit:
-       kfree(tmpbuf);
-}
-
-
 /*=======================================================================
  *
  *     dgnc_wmove - Write data to transmit queue.
@@ -784,8 +661,6 @@ void dgnc_input(struct channel_t *ch)
                        tty_insert_flip_string(tp->port, ch->ch_rqueue + tail, s);
                }
 
-               dgnc_sniff_nowait_nolock(ch, "USER READ", ch->ch_rqueue + tail, s);
-
                tail += s;
                n -= s;
                /* Flip queue if needed */
@@ -1981,7 +1856,6 @@ static int dgnc_tty_write(struct tty_struct *tty,
        if (n >= remain) {
                n -= remain;
                memcpy(ch->ch_wqueue + head, buf, remain);
-               dgnc_sniff_nowait_nolock(ch, "USER WRITE", ch->ch_wqueue + head, remain);
                head = 0;
                buf += remain;
        }
@@ -1992,7 +1866,6 @@ static int dgnc_tty_write(struct tty_struct *tty,
                 */
                remain = n;
                memcpy(ch->ch_wqueue + head, buf, remain);
-               dgnc_sniff_nowait_nolock(ch, "USER WRITE", ch->ch_wqueue + head, remain);
                head += remain;
        }
 

diff --git a/drivers/staging/dgnc/dgnc_tty.h b/drivers/staging/dgnc/dgnc_tty.h
index 58eef25..3975f04 100644 (file)
--- a/drivers/staging/dgnc/dgnc_tty.h
+++ b/drivers/staging/dgnc/dgnc_tty.h
@@ -37,6 +37,4 @@ void  dgnc_carrier(struct channel_t *ch);
 void   dgnc_wakeup_writes(struct channel_t *ch);
 void   dgnc_check_queue_flow_control(struct channel_t *ch);
 
-void   dgnc_sniff_nowait_nolock(struct channel_t *ch, unsigned char *text, unsigned char *buf, int nbuf);
-
 #endif