tty_io: drag screaming into coding style compliance

 *      -- Russell King <rmk@arm.linux.org.uk>

 *

 * Move do_SAK() into process context.  Less stack use in devfs functions.

 * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01

 * alloc_tty_struct() always uses kmalloc()

 *			 -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01

 */

#include <linux/types.h>

static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);

static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);

ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);

ssize_t redirected_tty_write(struct file *, const char __user *,

							size_t, loff_t *);

static unsigned int tty_poll(struct file *, poll_table *);

static int tty_open(struct inode *, struct file *);

static int tty_release(struct inode *, struct file *);

 *	Locking: May call functions taking tty->buf.lock

 */

int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)

int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,

								size_t size)

{

	int space = tty_buffer_request_room(tty, size);

	if (likely(space)) {

 *	Locking: May call functions taking tty->buf.lock

 */

int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)

int tty_prepare_flip_string_flags(struct tty_struct *tty,

			unsigned char **chars, char **flags, size_t size)

{

	int space = tty_buffer_request_room(tty, size);

	if (likely(space)) {

static DEFINE_SPINLOCK(tty_ldisc_lock);

static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);

static struct tty_ldisc tty_ldiscs[NR_LDISCS];	/* line disc dispatch table */

/* Line disc dispatch table */

static struct tty_ldisc tty_ldiscs[NR_LDISCS];

/**

 *	tty_register_ldisc	-	install a line discipline

	ld = &tty_ldiscs[disc];

	/* Check the entry is defined */

	if(ld->flags & LDISC_FLAG_DEFINED)

	{

	if (ld->flags & LDISC_FLAG_DEFINED) {

		/* If the module is being unloaded we can't use it */

		if (!try_module_get(ld->owner))

			ld = NULL;

		else /* lock it */

			ld->refcount++;

	}

	else

	} else

		ld = NULL;

	spin_unlock_irqrestore(&tty_ldisc_lock, flags);

	return ld;

	spin_lock_irqsave(&tty_ldisc_lock, flags);

	ld = &tty->ldisc;

	if(test_bit(TTY_LDISC, &tty->flags))

	{

	if (test_bit(TTY_LDISC, &tty->flags)) {

		ld->refcount++;

		ret = 1;

	}

			 * There are several reasons we may be busy, including

			 * random momentary I/O traffic. We must therefore

			 * retry. We could distinguish between blocking ops

			 * and retries if we made tty_ldisc_wait() smarter. That

			 * is up for discussion.

			 * and retries if we made tty_ldisc_wait() smarter.

			 * That is up for discussion.

			 */

			if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)

				return -ERESTARTSYS;

			goto restart;

		}

	}

	/* if the TTY_LDISC bit is set, then we are racing against another ldisc change */

	/*

	 *	If the TTY_LDISC bit is set, then we are racing against

	 *	another ldisc change

	 */

	if (!test_bit(TTY_LDISC, &tty->flags)) {

		spin_unlock_irqrestore(&tty_ldisc_lock, flags);

		tty_ldisc_put(ldisc);

	/*

	 * Wait for ->hangup_work and ->buf.work handlers to terminate

	 */

	flush_scheduled_work();

	/* Shutdown the current discipline. */

	if (tty->ldisc.close)

		filp->f_op = &hung_up_tty_fops;

	}

	file_list_unlock();

	/* FIXME! What are the locking issues here? This may me overdoing things..

	 * this question is especially important now that we've removed the irqlock. */

	/*

	 * FIXME! What are the locking issues here? This may me overdoing

	 * things... This question is especially important now that we've

	 * removed the irqlock.

	 */

	ld = tty_ldisc_ref(tty);

	if(ld != NULL)	/* We may have no line discipline at this point */

	{

	if (ld != NULL) {

		/* We may have no line discipline at this point */

		if (ld->flush_buffer)

			ld->flush_buffer(tty);

		if (tty->driver->flush_buffer)

		if (ld->hangup)

			ld->hangup(tty);

	}

	/* FIXME: Once we trust the LDISC code better we can wait here for

	   ldisc completion and fix the driver call race */

	/*

	 * FIXME: Once we trust the LDISC code better we can wait here for

	 * ldisc completion and fix the driver call race

	 */

	wake_up_interruptible(&tty->write_wait);

	wake_up_interruptible(&tty->read_wait);

	/*

	 * Shutdown the current line discipline, and reset it to

	 * N_TTY.

	 */

	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)

		tty_reset_termios(tty);

	/* Defer ldisc switch */

	/* tty_deferred_ldisc_switch(N_TTY);

				tty->driver->close(tty, cons_filp);

	} else if (tty->driver->hangup)

		(tty->driver->hangup)(tty);

	/* We don't want to have driver/ldisc interactions beyond

	   the ones we did here. The driver layer expects no

	   calls after ->hangup() from the ldisc side. However we

	   can't yet guarantee all that */

	/*

	 * We don't want to have driver/ldisc interactions beyond

	 * the ones we did here. The driver layer expects no

	 * calls after ->hangup() from the ldisc side. However we

	 * can't yet guarantee all that.

	 */

	set_bit(TTY_HUPPED, &tty->flags);

	if (ld) {

		tty_ldisc_enable(tty);

{

#ifdef TTY_DEBUG_HANGUP

	char	buf[64];

	printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));

#endif

	schedule_work(&tty->hangup_work);

#endif

	do_tty_hangup(&tty->hangup_work);

}

EXPORT_SYMBOL(tty_vhangup);

/**

/**

 *	is_tty	-	checker whether file is a TTY

 *	@filp:		file handle that may be a tty

 *

 *	Check if the file handle is a tty handle.

 */

int is_tty(struct file *filp)

{

	return filp->f_op->read == tty_read

	}

	if (tty->driver->start)

		(tty->driver->start)(tty);

	/* If we have a running line discipline it may need kicking */

	tty_wakeup(tty);

}

 *	kernel lock for historical reasons. New code should not rely on this.

 */

static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,

			 loff_t *ppos)

static ssize_t tty_write(struct file *file, const char __user *buf,

						size_t count, loff_t *ppos)

{

	struct tty_struct *tty;

	struct inode *inode = file->f_path.dentry->d_inode;

	tty = (struct tty_struct *)file->private_data;

	if (tty_paranoia_check(tty, inode, "tty_write"))

		return -EIO;

	if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))

	if (!tty || !tty->driver->write ||

		(test_bit(TTY_IO_ERROR, &tty->flags)))

			return -EIO;

	ld = tty_ldisc_ref_wait(tty);

	return ret;

}

ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,

			 loff_t *ppos)

ssize_t redirected_tty_write(struct file *file, const char __user *buf,

						size_t count, loff_t *ppos)

{

	struct file *p = NULL;

		fput(p);

		return res;

	}

	return tty_write(file, buf, count, ppos);

}

		/*

		 * Everything allocated ... set up the o_tty structure.

		 */

		if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {

		if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM))

			driver->other->ttys[idx] = o_tty;

		}

		if (!*o_tp_loc)

			*o_tp_loc = o_tp;

		if (!*o_ltp_loc)

	 * Failures after this point use release_tty to clean up, so

	 * there's no need to null out the local pointers.

	 */

	if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {

	if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM))

		driver->ttys[idx] = tty;

	}

	if (!*tp_loc)

		*tp_loc = tp;

	unsigned long flags;

	tty = (struct tty_struct *)filp->private_data;

	if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))

	if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode,

							"release_dev"))

		return;

	check_tty_count(tty, "release_dev");

	 * side is zero.

	 */

	spin_lock_irqsave(&tty_ldisc_lock, flags);

	while(tty->ldisc.refcount)

	{

	while (tty->ldisc.refcount) {

		spin_unlock_irqrestore(&tty_ldisc_lock, flags);

		wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);

		spin_lock_irqsave(&tty_ldisc_lock, flags);

	}

	filp->f_flags = saved_flags;

	if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))

	if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&

						!capable(CAP_SYS_ADMIN))

		retval = -EBUSY;

	if (retval) {

 *	Allocate a unix98 pty master device from the ptmx driver.

 *

 *	Locking: tty_mutex protects theinit_dev work. tty->count should

 		protect the rest.

 * 		protect the rest.

 *		allocated_ptys_lock handles the list of free pty numbers

 */

		 * This tty is already the controlling

		 * tty for another session group!

		 */

		if ((arg == 1) && capable(CAP_SYS_ADMIN)) {

		if (arg == 1 && capable(CAP_SYS_ADMIN)) {

			/*

			 * Steal it away

			 */

	case TIOCMGET:

		return tty_tiocmget(tty, file, p);

	case TIOCMSET:

	case TIOCMBIC:

	case TIOCMBIS:

		return;

	spin_lock_irqsave(&tty->buf.lock, flags);

	set_bit(TTY_FLUSHING, &tty->flags);	/* So we know a flush is running */

	/* So we know a flush is running */

	set_bit(TTY_FLUSHING, &tty->flags);

	head = tty->buf.head;

	if (head != NULL) {

		tty->buf.head = NULL;

void tty_unregister_device(struct tty_driver *driver, unsigned index)

{

	device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);

	device_destroy(tty_class,

		MKDEV(driver->major, driver->minor_start) + index);

}

EXPORT_SYMBOL(tty_register_device);

	}

	if (!driver->major) {

		error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,

						driver->name);

		error = alloc_chrdev_region(&dev, driver->minor_start,

						driver->num, driver->name);

		if (!error) {

			driver->major = MAJOR(dev);

			driver->minor_start = MINOR(dev);

	if (p) {

		driver->ttys = (struct tty_struct **)p;

		driver->termios = (struct ktermios **)(p + driver->num);

		driver->termios_locked = (struct ktermios **)(p + driver->num * 2);

		driver->termios_locked = (struct ktermios **)

							(p + driver->num * 2);

	} else {

		driver->ttys = NULL;

		driver->termios = NULL;