/* Semaphore to protect creating and releasing a tty. This is shared with
vt.c for deeply disgusting hack reasons */
-DEFINE_MUTEX(tty_mutex);
-
-int console_use_vt = 1;
+DECLARE_MUTEX(tty_sem);
#ifdef CONFIG_UNIX98_PTYS
extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
spin_unlock_irqrestore(&tty->buf.lock, flags);
return size;
}
+
EXPORT_SYMBOL_GPL(tty_buffer_request_room);
-int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
- size_t size)
+int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size)
{
int copied = 0;
do {
tb->used += space;
copied += space;
chars += space;
+/* printk("Flip insert %d.\n", space); */
}
/* There is a small chance that we need to split the data over
several buffers. If this is the case we must loop */
while (unlikely(size > copied));
return copied;
}
-EXPORT_SYMBOL(tty_insert_flip_string);
-int tty_insert_flip_string_flags(struct tty_struct *tty,
- const unsigned char *chars, const char *flags, size_t size)
+EXPORT_SYMBOL_GPL(tty_insert_flip_string);
+
+int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size)
{
int copied = 0;
do {
while (unlikely(size > copied));
return copied;
}
-EXPORT_SYMBOL(tty_insert_flip_string_flags);
-void tty_schedule_flip(struct tty_struct *tty)
-{
- unsigned long flags;
- spin_lock_irqsave(&tty->buf.lock, flags);
- if (tty->buf.tail != NULL) {
- tty->buf.tail->active = 0;
- tty->buf.tail->commit = tty->buf.tail->used;
- }
- spin_unlock_irqrestore(&tty->buf.lock, flags);
- schedule_delayed_work(&tty->buf.work, 1);
-}
-EXPORT_SYMBOL(tty_schedule_flip);
+EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
+
/*
* Prepare a block of space in the buffer for data. Returns the length
struct tty_ldisc *ld;
unsigned long flags;
- BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
+ if (disc < N_TTY || disc >= NR_LDISCS)
+ BUG();
spin_lock_irqsave(&tty_ldisc_lock, flags);
ld = &tty_ldiscs[disc];
- BUG_ON(ld->refcount == 0);
- ld->refcount--;
+ if(ld->refcount == 0)
+ BUG();
+ ld->refcount --;
module_put(ld->owner);
spin_unlock_irqrestore(&tty_ldisc_lock, flags);
}
{
unsigned long flags;
- BUG_ON(ld == NULL);
+ if(ld == NULL)
+ BUG();
spin_lock_irqsave(&tty_ldisc_lock, flags);
if(ld->refcount == 0)
p->signal->tty = NULL;
if (!p->signal->leader)
continue;
- group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
- group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
+ send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
+ send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
if (tty->pgrp > 0)
p->signal->tty_old_pgrp = tty->pgrp;
} while_each_task_pid(tty->session, PIDTYPE_SID, p);
lock_kernel();
- mutex_lock(&tty_mutex);
+ down(&tty_sem);
tty = current->signal->tty;
if (tty) {
tty_pgrp = tty->pgrp;
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
tty_vhangup(tty);
} else {
kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
}
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
unlock_kernel();
return;
}
}
/* Must lock changes to tty_old_pgrp */
- mutex_lock(&tty_mutex);
+ down(&tty_sem);
current->signal->tty_old_pgrp = 0;
tty->session = 0;
tty->pgrp = -1;
p->signal->tty = NULL;
} while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
read_unlock(&tasklist_lock);
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
unlock_kernel();
}
ssize_t ret = 0, written = 0;
unsigned int chunk;
- if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
+ if (down_interruptible(&tty->atomic_write)) {
return -ERESTARTSYS;
}
if (count < chunk)
chunk = count;
- /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
+ /* write_buf/write_cnt is protected by the atomic_write semaphore */
if (tty->write_cnt < chunk) {
unsigned char *buf;
buf = kmalloc(chunk, GFP_KERNEL);
if (!buf) {
- mutex_unlock(&tty->atomic_write_lock);
+ up(&tty->atomic_write);
return -ENOMEM;
}
kfree(tty->write_buf);
inode->i_mtime = current_fs_time(inode->i_sb);
ret = written;
}
- mutex_unlock(&tty->atomic_write_lock);
+ up(&tty->atomic_write);
return ret;
}
/*
* WSH 06/09/97: Rewritten to remove races and properly clean up after a
- * failed open. The new code protects the open with a mutex, so it's
- * really quite straightforward. The mutex locking can probably be
+ * failed open. The new code protects the open with a semaphore, so it's
+ * really quite straightforward. The semaphore locking can probably be
* relaxed for the (most common) case of reopening a tty.
*/
static int init_dev(struct tty_driver *driver, int idx,
success:
*ret_tty = tty;
- /* All paths come through here to release the mutex */
+ /* All paths come through here to release the semaphore */
end_init:
return retval;
{
struct tty_struct *tty, *o_tty;
int pty_master, tty_closing, o_tty_closing, do_sleep;
- int devpts;
+ int devpts_master, devpts;
int idx;
char buf[64];
unsigned long flags;
pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
tty->driver->subtype == PTY_TYPE_MASTER);
devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
+ devpts_master = pty_master && devpts;
o_tty = tty->link;
#ifdef TTY_PARANOIA_CHECK
/* Guard against races with tty->count changes elsewhere and
opens on /dev/tty */
- mutex_lock(&tty_mutex);
+ down(&tty_sem);
tty_closing = tty->count <= 1;
o_tty_closing = o_tty &&
(o_tty->count <= (pty_master ? 1 : 0));
printk(KERN_WARNING "release_dev: %s: read/write wait queue "
"active!\n", tty_name(tty, buf));
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
schedule();
}
read_unlock(&tasklist_lock);
}
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
/* check whether both sides are closing ... */
if (!tty_closing || (o_tty && !o_tty_closing))
index = -1;
retval = 0;
- mutex_lock(&tty_mutex);
+ down(&tty_sem);
if (device == MKDEV(TTYAUX_MAJOR,0)) {
if (!current->signal->tty) {
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
return -ENXIO;
}
driver = current->signal->tty->driver;
goto got_driver;
}
#ifdef CONFIG_VT
- if (console_use_vt && (device == MKDEV(TTY_MAJOR,0))) {
+ if (device == MKDEV(TTY_MAJOR,0)) {
extern struct tty_driver *console_driver;
driver = console_driver;
index = fg_console;
noctty = 1;
goto got_driver;
}
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
return -ENODEV;
}
driver = get_tty_driver(device, &index);
if (!driver) {
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
return -ENODEV;
}
got_driver:
retval = init_dev(driver, index, &tty);
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
if (retval)
return retval;
}
up(&allocated_ptys_lock);
- mutex_lock(&tty_mutex);
+ down(&tty_sem);
retval = init_dev(ptm_driver, index, &tty);
- mutex_unlock(&tty_mutex);
+ up(&tty_sem);
if (retval)
goto out;
return 0;
out1:
release_dev(filp);
- return retval;
out:
down(&allocated_ptys_lock);
idr_remove(&allocated_ptys, index);
tty_hangup(tty);
#else
struct tty_struct *tty = arg;
- struct task_struct *g, *p;
+ struct task_struct *p;
int session;
int i;
struct file *filp;
tty->driver->flush_buffer(tty);
read_lock(&tasklist_lock);
- /* Kill the entire session */
do_each_task_pid(session, PIDTYPE_SID, p) {
- printk(KERN_NOTICE "SAK: killed process %d"
- " (%s): p->signal->session==tty->session\n",
- p->pid, p->comm);
- send_sig(SIGKILL, p, 1);
- } while_each_task_pid(session, PIDTYPE_SID, p);
- /* Now kill any processes that happen to have the
- * tty open.
- */
- do_each_thread(g, p) {
- if (p->signal->tty == tty) {
+ if (p->signal->tty == tty || session > 0) {
printk(KERN_NOTICE "SAK: killed process %d"
" (%s): p->signal->session==tty->session\n",
p->pid, p->comm);
printk(KERN_NOTICE "SAK: killed process %d"
" (%s): fd#%d opened to the tty\n",
p->pid, p->comm, i);
- force_sig(SIGKILL, p);
+ send_sig(SIGKILL, p, 1);
break;
}
}
spin_unlock(&p->files->file_lock);
}
task_unlock(p);
- } while_each_thread(g, p);
+ } while_each_task_pid(session, PIDTYPE_SID, p);
read_unlock(&tasklist_lock);
#endif
}
init_waitqueue_head(&tty->write_wait);
init_waitqueue_head(&tty->read_wait);
INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
- mutex_init(&tty->atomic_read_lock);
- mutex_init(&tty->atomic_write_lock);
+ sema_init(&tty->atomic_read, 1);
+ sema_init(&tty->atomic_write, 1);
spin_lock_init(&tty->read_lock);
INIT_LIST_HEAD(&tty->tty_files);
INIT_WORK(&tty->SAK_work, NULL, NULL);
#endif
#ifdef CONFIG_VT
- if (!console_use_vt)
- goto out_vt;
cdev_init(&vc0_cdev, &console_fops);
if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
vty_init();
- out_vt:
#endif
return 0;
}
git://git.onelab.eu / linux-2.6.git / blobdiff