tty_io: drag screaming into coding style compliance
Signed-off-by: Alan Cox <alan@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alan Cox
Linus Torvalds
parent
66c6ceae39
commit
37bdfb074e
|
|
@ -62,7 +62,8 @@
|
|||
* -- 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>
|
||||
|
|
@ -146,19 +147,20 @@ static void initialize_tty_struct(struct tty_struct *tty);
|
|||
|
||||
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 *);
|
||||
int tty_ioctl(struct inode * inode, struct file * file,
|
||||
int tty_ioctl(struct inode *inode, struct file *file,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long tty_compat_ioctl(struct file * file, unsigned int cmd,
|
||||
static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg);
|
||||
#else
|
||||
#define tty_compat_ioctl NULL
|
||||
#endif
|
||||
static int tty_fasync(int fd, struct file * filp, int on);
|
||||
static int tty_fasync(int fd, struct file *filp, int on);
|
||||
static void release_tty(struct tty_struct *tty, int idx);
|
||||
static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
|
||||
static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
|
||||
|
|
@ -281,11 +283,11 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
|
|||
static void tty_buffer_free_all(struct tty_struct *tty)
|
||||
{
|
||||
struct tty_buffer *thead;
|
||||
while((thead = tty->buf.head) != NULL) {
|
||||
while ((thead = tty->buf.head) != NULL) {
|
||||
tty->buf.head = thead->next;
|
||||
kfree(thead);
|
||||
}
|
||||
while((thead = tty->buf.free) != NULL) {
|
||||
while ((thead = tty->buf.free) != NULL) {
|
||||
tty->buf.free = thead->next;
|
||||
kfree(thead);
|
||||
}
|
||||
|
|
@ -331,7 +333,7 @@ static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
|
|||
if (tty->buf.memory_used + size > 65536)
|
||||
return NULL;
|
||||
p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
|
||||
if(p == NULL)
|
||||
if (p == NULL)
|
||||
return NULL;
|
||||
p->used = 0;
|
||||
p->size = size;
|
||||
|
|
@ -361,7 +363,7 @@ static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
|
|||
tty->buf.memory_used -= b->size;
|
||||
WARN_ON(tty->buf.memory_used < 0);
|
||||
|
||||
if(b->size >= 512)
|
||||
if (b->size >= 512)
|
||||
kfree(b);
|
||||
else {
|
||||
b->next = tty->buf.free;
|
||||
|
|
@ -384,7 +386,7 @@ static void __tty_buffer_flush(struct tty_struct *tty)
|
|||
{
|
||||
struct tty_buffer *thead;
|
||||
|
||||
while((thead = tty->buf.head) != NULL) {
|
||||
while ((thead = tty->buf.head) != NULL) {
|
||||
tty->buf.head = thead->next;
|
||||
tty_buffer_free(tty, thead);
|
||||
}
|
||||
|
|
@ -436,9 +438,9 @@ static void tty_buffer_flush(struct tty_struct *tty)
|
|||
static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
|
||||
{
|
||||
struct tty_buffer **tbh = &tty->buf.free;
|
||||
while((*tbh) != NULL) {
|
||||
while ((*tbh) != NULL) {
|
||||
struct tty_buffer *t = *tbh;
|
||||
if(t->size >= size) {
|
||||
if (t->size >= size) {
|
||||
*tbh = t->next;
|
||||
t->next = NULL;
|
||||
t->used = 0;
|
||||
|
|
@ -450,7 +452,7 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
|
|||
tbh = &((*tbh)->next);
|
||||
}
|
||||
/* Round the buffer size out */
|
||||
size = (size + 0xFF) & ~ 0xFF;
|
||||
size = (size + 0xFF) & ~0xFF;
|
||||
return tty_buffer_alloc(tty, size);
|
||||
/* Should possibly check if this fails for the largest buffer we
|
||||
have queued and recycle that ? */
|
||||
|
|
@ -520,7 +522,7 @@ int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
|
|||
int space = tty_buffer_request_room(tty, size - copied);
|
||||
struct tty_buffer *tb = tty->buf.tail;
|
||||
/* If there is no space then tb may be NULL */
|
||||
if(unlikely(space == 0))
|
||||
if (unlikely(space == 0))
|
||||
break;
|
||||
memcpy(tb->char_buf_ptr + tb->used, chars, space);
|
||||
memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
|
||||
|
|
@ -556,7 +558,7 @@ int tty_insert_flip_string_flags(struct tty_struct *tty,
|
|||
int space = tty_buffer_request_room(tty, size - copied);
|
||||
struct tty_buffer *tb = tty->buf.tail;
|
||||
/* If there is no space then tb may be NULL */
|
||||
if(unlikely(space == 0))
|
||||
if (unlikely(space == 0))
|
||||
break;
|
||||
memcpy(tb->char_buf_ptr + tb->used, chars, space);
|
||||
memcpy(tb->flag_buf_ptr + tb->used, flags, space);
|
||||
|
|
@ -608,7 +610,8 @@ EXPORT_SYMBOL(tty_schedule_flip);
|
|||
* 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)) {
|
||||
|
|
@ -638,7 +641,8 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
|
|||
* 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)) {
|
||||
|
|
@ -681,7 +685,8 @@ static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
|
|||
|
||||
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
|
||||
|
|
@ -771,15 +776,13 @@ struct tty_ldisc *tty_ldisc_get(int disc)
|
|||
|
||||
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;
|
||||
|
|
@ -854,8 +857,7 @@ static int tty_ldisc_try(struct tty_struct *tty)
|
|||
|
||||
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;
|
||||
}
|
||||
|
|
@ -883,7 +885,7 @@ struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
|
|||
{
|
||||
/* wait_event is a macro */
|
||||
wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
|
||||
if(tty->ldisc.refcount == 0)
|
||||
if (tty->ldisc.refcount == 0)
|
||||
printk(KERN_ERR "tty_ldisc_ref_wait\n");
|
||||
return &tty->ldisc;
|
||||
}
|
||||
|
|
@ -903,7 +905,7 @@ EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
|
|||
|
||||
struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
|
||||
{
|
||||
if(tty_ldisc_try(tty))
|
||||
if (tty_ldisc_try(tty))
|
||||
return &tty->ldisc;
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -927,11 +929,11 @@ void tty_ldisc_deref(struct tty_ldisc *ld)
|
|||
BUG_ON(ld == NULL);
|
||||
|
||||
spin_lock_irqsave(&tty_ldisc_lock, flags);
|
||||
if(ld->refcount == 0)
|
||||
if (ld->refcount == 0)
|
||||
printk(KERN_ERR "tty_ldisc_deref: no references.\n");
|
||||
else
|
||||
ld->refcount--;
|
||||
if(ld->refcount == 0)
|
||||
if (ld->refcount == 0)
|
||||
wake_up(&tty_ldisc_wait);
|
||||
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
|
||||
}
|
||||
|
|
@ -1022,7 +1024,7 @@ restart:
|
|||
|
||||
spin_lock_irqsave(&tty_ldisc_lock, flags);
|
||||
if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
|
||||
if(tty->ldisc.refcount) {
|
||||
if (tty->ldisc.refcount) {
|
||||
/* Free the new ldisc we grabbed. Must drop the lock
|
||||
first. */
|
||||
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
|
||||
|
|
@ -1031,14 +1033,14 @@ restart:
|
|||
* 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(o_tty && o_tty->ldisc.refcount) {
|
||||
if (o_tty && o_tty->ldisc.refcount) {
|
||||
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
|
||||
tty_ldisc_put(ldisc);
|
||||
if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
|
||||
|
|
@ -1046,9 +1048,10 @@ restart:
|
|||
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);
|
||||
|
|
@ -1072,7 +1075,6 @@ restart:
|
|||
/*
|
||||
* Wait for ->hangup_work and ->buf.work handlers to terminate
|
||||
*/
|
||||
|
||||
flush_scheduled_work();
|
||||
/* Shutdown the current discipline. */
|
||||
if (tty->ldisc.close)
|
||||
|
|
@ -1164,7 +1166,7 @@ static struct tty_driver *get_tty_driver(dev_t device, int *index)
|
|||
* Locking: none
|
||||
*/
|
||||
|
||||
int tty_check_change(struct tty_struct * tty)
|
||||
int tty_check_change(struct tty_struct *tty)
|
||||
{
|
||||
if (current->signal->tty != tty)
|
||||
return 0;
|
||||
|
|
@ -1185,31 +1187,31 @@ int tty_check_change(struct tty_struct * tty)
|
|||
|
||||
EXPORT_SYMBOL(tty_check_change);
|
||||
|
||||
static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
|
||||
static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
|
||||
static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* No kernel lock held - none needed ;) */
|
||||
static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
|
||||
static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
|
||||
{
|
||||
return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
|
||||
}
|
||||
|
||||
static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
|
||||
static int hung_up_tty_ioctl(struct inode *inode, struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
|
||||
}
|
||||
|
||||
static long hung_up_tty_compat_ioctl(struct file * file,
|
||||
static long hung_up_tty_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
|
||||
|
|
@ -1281,8 +1283,8 @@ void tty_wakeup(struct tty_struct *tty)
|
|||
|
||||
if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
|
||||
ld = tty_ldisc_ref(tty);
|
||||
if(ld) {
|
||||
if(ld->write_wakeup)
|
||||
if (ld) {
|
||||
if (ld->write_wakeup)
|
||||
ld->write_wakeup(tty);
|
||||
tty_ldisc_deref(ld);
|
||||
}
|
||||
|
|
@ -1303,8 +1305,8 @@ EXPORT_SYMBOL_GPL(tty_wakeup);
|
|||
void tty_ldisc_flush(struct tty_struct *tty)
|
||||
{
|
||||
struct tty_ldisc *ld = tty_ldisc_ref(tty);
|
||||
if(ld) {
|
||||
if(ld->flush_buffer)
|
||||
if (ld) {
|
||||
if (ld->flush_buffer)
|
||||
ld->flush_buffer(tty);
|
||||
tty_ldisc_deref(ld);
|
||||
}
|
||||
|
|
@ -1355,7 +1357,7 @@ static void do_tty_hangup(struct work_struct *work)
|
|||
{
|
||||
struct tty_struct *tty =
|
||||
container_of(work, struct tty_struct, hangup_work);
|
||||
struct file * cons_filp = NULL;
|
||||
struct file *cons_filp = NULL;
|
||||
struct file *filp, *f = NULL;
|
||||
struct task_struct *p;
|
||||
struct tty_ldisc *ld;
|
||||
|
|
@ -1387,13 +1389,14 @@ static void do_tty_hangup(struct work_struct *work)
|
|||
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)
|
||||
|
|
@ -1404,20 +1407,18 @@ static void do_tty_hangup(struct work_struct *work)
|
|||
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);
|
||||
|
||||
|
|
@ -1462,12 +1463,12 @@ static void do_tty_hangup(struct work_struct *work)
|
|||
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);
|
||||
|
|
@ -1486,11 +1487,10 @@ static void do_tty_hangup(struct work_struct *work)
|
|||
* schedule a hangup sequence to run after this event.
|
||||
*/
|
||||
|
||||
void tty_hangup(struct tty_struct * tty)
|
||||
void tty_hangup(struct tty_struct *tty)
|
||||
{
|
||||
#ifdef TTY_DEBUG_HANGUP
|
||||
char buf[64];
|
||||
|
||||
printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
|
||||
#endif
|
||||
schedule_work(&tty->hangup_work);
|
||||
|
|
@ -1507,7 +1507,7 @@ EXPORT_SYMBOL(tty_hangup);
|
|||
* is complete. That guarantee is necessary for security reasons.
|
||||
*/
|
||||
|
||||
void tty_vhangup(struct tty_struct * tty)
|
||||
void tty_vhangup(struct tty_struct *tty)
|
||||
{
|
||||
#ifdef TTY_DEBUG_HANGUP
|
||||
char buf[64];
|
||||
|
|
@ -1516,6 +1516,7 @@ void tty_vhangup(struct tty_struct * tty)
|
|||
#endif
|
||||
do_tty_hangup(&tty->hangup_work);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(tty_vhangup);
|
||||
|
||||
/**
|
||||
|
|
@ -1526,7 +1527,7 @@ EXPORT_SYMBOL(tty_vhangup);
|
|||
* loss
|
||||
*/
|
||||
|
||||
int tty_hung_up_p(struct file * filp)
|
||||
int tty_hung_up_p(struct file *filp)
|
||||
{
|
||||
return (filp->f_op == &hung_up_tty_fops);
|
||||
}
|
||||
|
|
@ -1535,7 +1536,11 @@ EXPORT_SYMBOL(tty_hung_up_p);
|
|||
|
||||
/**
|
||||
* 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
|
||||
|
|
@ -1711,7 +1716,6 @@ void start_tty(struct tty_struct *tty)
|
|||
}
|
||||
if (tty->driver->start)
|
||||
(tty->driver->start)(tty);
|
||||
|
||||
/* If we have a running line discipline it may need kicking */
|
||||
tty_wakeup(tty);
|
||||
}
|
||||
|
|
@ -1735,11 +1739,11 @@ EXPORT_SYMBOL(start_tty);
|
|||
* in new code. Multiple read calls may be outstanding in parallel.
|
||||
*/
|
||||
|
||||
static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
|
||||
static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
|
||||
loff_t *ppos)
|
||||
{
|
||||
int i;
|
||||
struct tty_struct * tty;
|
||||
struct tty_struct *tty;
|
||||
struct inode *inode;
|
||||
struct tty_ldisc *ld;
|
||||
|
||||
|
|
@ -1755,7 +1759,7 @@ static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
|
|||
ld = tty_ldisc_ref_wait(tty);
|
||||
lock_kernel();
|
||||
if (ld->read)
|
||||
i = (ld->read)(tty,file,buf,count);
|
||||
i = (ld->read)(tty, file, buf, count);
|
||||
else
|
||||
i = -EIO;
|
||||
tty_ldisc_deref(ld);
|
||||
|
|
@ -1891,10 +1895,10 @@ out:
|
|||
* 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 tty_struct *tty;
|
||||
struct inode *inode = file->f_path.dentry->d_inode;
|
||||
ssize_t ret;
|
||||
struct tty_ldisc *ld;
|
||||
|
|
@ -1902,7 +1906,8 @@ static ssize_t tty_write(struct file * file, const char __user * buf, size_t cou
|
|||
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);
|
||||
|
|
@ -1914,8 +1919,8 @@ static ssize_t tty_write(struct file * file, const char __user * buf, size_t cou
|
|||
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;
|
||||
|
||||
|
|
@ -1932,7 +1937,6 @@ ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t
|
|||
fput(p);
|
||||
return res;
|
||||
}
|
||||
|
||||
return tty_write(file, buf, count, ppos);
|
||||
}
|
||||
|
||||
|
|
@ -2048,7 +2052,7 @@ static int init_dev(struct tty_driver *driver, int idx,
|
|||
ltp = o_ltp = NULL;
|
||||
|
||||
tty = alloc_tty_struct();
|
||||
if(!tty)
|
||||
if (!tty)
|
||||
goto fail_no_mem;
|
||||
initialize_tty_struct(tty);
|
||||
tty->driver = driver;
|
||||
|
|
@ -2109,9 +2113,8 @@ static int init_dev(struct tty_driver *driver, int idx,
|
|||
/*
|
||||
* 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)
|
||||
|
|
@ -2132,9 +2135,8 @@ static int init_dev(struct tty_driver *driver, int idx,
|
|||
* 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;
|
||||
|
|
@ -2198,7 +2200,7 @@ fast_track:
|
|||
tty->driver = driver; /* N.B. why do this every time?? */
|
||||
|
||||
/* FIXME */
|
||||
if(!test_bit(TTY_LDISC, &tty->flags))
|
||||
if (!test_bit(TTY_LDISC, &tty->flags))
|
||||
printk(KERN_ERR "init_dev but no ldisc\n");
|
||||
success:
|
||||
*ret_tty = tty;
|
||||
|
|
@ -2304,7 +2306,7 @@ static void release_tty(struct tty_struct *tty, int idx)
|
|||
* WSH 09/09/97: rewritten to avoid some nasty race conditions that could
|
||||
* lead to double frees or releasing memory still in use.
|
||||
*/
|
||||
static void release_dev(struct file * filp)
|
||||
static void release_dev(struct file *filp)
|
||||
{
|
||||
struct tty_struct *tty, *o_tty;
|
||||
int pty_master, tty_closing, o_tty_closing, do_sleep;
|
||||
|
|
@ -2314,7 +2316,8 @@ static void release_dev(struct file * filp)
|
|||
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");
|
||||
|
|
@ -2484,9 +2487,9 @@ static void release_dev(struct file * filp)
|
|||
* case of a pty we may have to wait around for the other side
|
||||
* to close, and TTY_CLOSING makes sure we can't be reopened.
|
||||
*/
|
||||
if(tty_closing)
|
||||
if (tty_closing)
|
||||
set_bit(TTY_CLOSING, &tty->flags);
|
||||
if(o_tty_closing)
|
||||
if (o_tty_closing)
|
||||
set_bit(TTY_CLOSING, &o_tty->flags);
|
||||
|
||||
/*
|
||||
|
|
@ -2531,8 +2534,7 @@ static void release_dev(struct file * filp)
|
|||
* 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);
|
||||
|
|
@ -2552,7 +2554,7 @@ static void release_dev(struct file * filp)
|
|||
* Switch the line discipline back
|
||||
*/
|
||||
tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
|
||||
tty_set_termios_ldisc(tty,N_TTY);
|
||||
tty_set_termios_ldisc(tty, N_TTY);
|
||||
if (o_tty) {
|
||||
/* FIXME: could o_tty be in setldisc here ? */
|
||||
clear_bit(TTY_LDISC, &o_tty->flags);
|
||||
|
|
@ -2560,7 +2562,7 @@ static void release_dev(struct file * filp)
|
|||
(o_tty->ldisc.close)(o_tty);
|
||||
tty_ldisc_put(o_tty->ldisc.num);
|
||||
tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
|
||||
tty_set_termios_ldisc(o_tty,N_TTY);
|
||||
tty_set_termios_ldisc(o_tty, N_TTY);
|
||||
}
|
||||
/*
|
||||
* The release_tty function takes care of the details of clearing
|
||||
|
|
@ -2600,7 +2602,7 @@ static void release_dev(struct file * filp)
|
|||
* ->siglock protects ->signal/->sighand
|
||||
*/
|
||||
|
||||
static int tty_open(struct inode * inode, struct file * filp)
|
||||
static int tty_open(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct tty_struct *tty;
|
||||
int noctty, retval;
|
||||
|
|
@ -2618,7 +2620,7 @@ retry_open:
|
|||
|
||||
mutex_lock(&tty_mutex);
|
||||
|
||||
if (device == MKDEV(TTYAUX_MAJOR,0)) {
|
||||
if (device == MKDEV(TTYAUX_MAJOR, 0)) {
|
||||
tty = get_current_tty();
|
||||
if (!tty) {
|
||||
mutex_unlock(&tty_mutex);
|
||||
|
|
@ -2631,7 +2633,7 @@ retry_open:
|
|||
goto got_driver;
|
||||
}
|
||||
#ifdef CONFIG_VT
|
||||
if (device == MKDEV(TTY_MAJOR,0)) {
|
||||
if (device == MKDEV(TTY_MAJOR, 0)) {
|
||||
extern struct tty_driver *console_driver;
|
||||
driver = console_driver;
|
||||
index = fg_console;
|
||||
|
|
@ -2639,7 +2641,7 @@ retry_open:
|
|||
goto got_driver;
|
||||
}
|
||||
#endif
|
||||
if (device == MKDEV(TTYAUX_MAJOR,1)) {
|
||||
if (device == MKDEV(TTYAUX_MAJOR, 1)) {
|
||||
driver = console_device(&index);
|
||||
if (driver) {
|
||||
/* Don't let /dev/console block */
|
||||
|
|
@ -2679,7 +2681,8 @@ got_driver:
|
|||
}
|
||||
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) {
|
||||
|
|
@ -2723,11 +2726,11 @@ got_driver:
|
|||
* 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
|
||||
*/
|
||||
|
||||
static int ptmx_open(struct inode * inode, struct file * filp)
|
||||
static int ptmx_open(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct tty_struct *tty;
|
||||
int retval;
|
||||
|
|
@ -2800,7 +2803,7 @@ out:
|
|||
* Takes bkl. See release_dev
|
||||
*/
|
||||
|
||||
static int tty_release(struct inode * inode, struct file * filp)
|
||||
static int tty_release(struct inode *inode, struct file *filp)
|
||||
{
|
||||
lock_kernel();
|
||||
release_dev(filp);
|
||||
|
|
@ -2820,9 +2823,9 @@ static int tty_release(struct inode * inode, struct file * filp)
|
|||
* may be re-entered freely by other callers.
|
||||
*/
|
||||
|
||||
static unsigned int tty_poll(struct file * filp, poll_table * wait)
|
||||
static unsigned int tty_poll(struct file *filp, poll_table *wait)
|
||||
{
|
||||
struct tty_struct * tty;
|
||||
struct tty_struct *tty;
|
||||
struct tty_ldisc *ld;
|
||||
int ret = 0;
|
||||
|
||||
|
|
@ -2837,9 +2840,9 @@ static unsigned int tty_poll(struct file * filp, poll_table * wait)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int tty_fasync(int fd, struct file * filp, int on)
|
||||
static int tty_fasync(int fd, struct file *filp, int on)
|
||||
{
|
||||
struct tty_struct * tty;
|
||||
struct tty_struct *tty;
|
||||
int retval;
|
||||
|
||||
tty = (struct tty_struct *)filp->private_data;
|
||||
|
|
@ -2915,7 +2918,7 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
|
|||
* is consistent.
|
||||
*/
|
||||
|
||||
static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
|
||||
static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
|
||||
{
|
||||
int err;
|
||||
|
||||
|
|
@ -2944,7 +2947,7 @@ static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
|
|||
*/
|
||||
|
||||
static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
|
||||
struct winsize __user * arg)
|
||||
struct winsize __user *arg)
|
||||
{
|
||||
struct winsize tmp_ws;
|
||||
|
||||
|
|
@ -3070,7 +3073,7 @@ static int tiocsctty(struct tty_struct *tty, int arg)
|
|||
* 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
|
||||
*/
|
||||
|
|
@ -3303,7 +3306,7 @@ static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int
|
|||
/*
|
||||
* Split this up, as gcc can choke on it otherwise..
|
||||
*/
|
||||
int tty_ioctl(struct inode * inode, struct file * file,
|
||||
int tty_ioctl(struct inode *inode, struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct tty_struct *tty, *real_tty;
|
||||
|
|
@ -3326,7 +3329,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
|
|||
* Break handling by driver
|
||||
*/
|
||||
if (!tty->driver->break_ctl) {
|
||||
switch(cmd) {
|
||||
switch (cmd) {
|
||||
case TIOCSBRK:
|
||||
case TIOCCBRK:
|
||||
if (tty->driver->ioctl)
|
||||
|
|
@ -3374,7 +3377,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
|
|||
case TIOCSWINSZ:
|
||||
return tiocswinsz(tty, real_tty, p);
|
||||
case TIOCCONS:
|
||||
return real_tty!=tty ? -EINVAL : tioccons(file);
|
||||
return real_tty != tty ? -EINVAL : tioccons(file);
|
||||
case FIONBIO:
|
||||
return fionbio(file, p);
|
||||
case TIOCEXCL:
|
||||
|
|
@ -3428,7 +3431,6 @@ int tty_ioctl(struct inode * inode, struct file * file,
|
|||
|
||||
case TIOCMGET:
|
||||
return tty_tiocmget(tty, file, p);
|
||||
|
||||
case TIOCMSET:
|
||||
case TIOCMBIC:
|
||||
case TIOCMBIS:
|
||||
|
|
@ -3460,7 +3462,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
|
|||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long tty_compat_ioctl(struct file * file, unsigned int cmd,
|
||||
static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
struct inode *inode = file->f_dentry->d_inode;
|
||||
|
|
@ -3552,7 +3554,7 @@ void __do_SAK(struct tty_struct *tty)
|
|||
*/
|
||||
spin_lock(&p->files->file_lock);
|
||||
fdt = files_fdtable(p->files);
|
||||
for (i=0; i < fdt->max_fds; i++) {
|
||||
for (i = 0; i < fdt->max_fds; i++) {
|
||||
filp = fcheck_files(p->files, i);
|
||||
if (!filp)
|
||||
continue;
|
||||
|
|
@ -3622,7 +3624,8 @@ static void flush_to_ldisc(struct work_struct *work)
|
|||
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;
|
||||
|
|
@ -3795,7 +3798,8 @@ struct device *tty_register_device(struct tty_driver *driver, unsigned index,
|
|||
|
||||
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);
|
||||
|
|
@ -3873,8 +3877,8 @@ int tty_register_driver(struct tty_driver *driver)
|
|||
}
|
||||
|
||||
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);
|
||||
|
|
@ -3891,7 +3895,8 @@ int tty_register_driver(struct tty_driver *driver)
|
|||
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;
|
||||
|
|
@ -3916,8 +3921,8 @@ int tty_register_driver(struct tty_driver *driver)
|
|||
list_add(&driver->tty_drivers, &tty_drivers);
|
||||
mutex_unlock(&tty_mutex);
|
||||
|
||||
if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
|
||||
for(i = 0; i < driver->num; i++)
|
||||
if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
|
||||
for (i = 0; i < driver->num; i++)
|
||||
tty_register_device(driver, i, NULL);
|
||||
}
|
||||
proc_tty_register_driver(driver);
|
||||
|
|
|
|||
Loading…
Reference in a new issue