Commit 36beff6e authored by Somya Anand's avatar Somya Anand Committed by Greg Kroah-Hartman
Browse files

Staging: dgnc: Remove unused sniff code 



The output written by dgnc_sniff_nowait_nolock() is never used
anywhere since commit 35cf9045 ("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: default avatarSomya Anand <somyaanand214@gmail.com>
Reviewed-by: default avatarArnd Bergmann <arnd@arndb.de>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 0a985868

drivers/staging/dgnc/dgnc_cls.c

+0 −4
Original line number Diff line number Diff line
@@ -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++;

drivers/staging/dgnc/dgnc_driver.h

+0 −14
Original line number Diff line number Diff line
@@ -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;

};



/*

drivers/staging/dgnc/dgnc_neo.c

+0 −3
Original line number Diff line number Diff line
@@ -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;

drivers/staging/dgnc/dgnc_tty.c

+0 −127
Original line number Diff line number Diff line
@@ -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;

	}

drivers/staging/dgnc/dgnc_tty.h

+0 −2
Original line number Diff line number Diff line
@@ -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