1 files changed, 25 insertions, 25 deletions

diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 53d3d066554e..76592ee1fb38 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -130,7 +130,7 @@ LIST_HEAD(tty_drivers);			/* linked list of tty drivers */
 
 /* Semaphore to protect creating and releasing a tty. This is shared with
    vt.c for deeply disgusting hack reasons */
-DECLARE_MUTEX(tty_sem);
+DEFINE_MUTEX(tty_mutex);
 
 #ifdef CONFIG_UNIX98_PTYS
 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
@@ -1188,11 +1188,11 @@ void disassociate_ctty(int on_exit)
 
         lock_kernel();
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         tty = current->signal->tty;
         if (tty) {
                 tty_pgrp = tty->pgrp;
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
                         tty_vhangup(tty);
         } else {
@@ -1200,7 +1200,7 @@ void disassociate_ctty(int on_exit)
                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 unlock_kernel();        
                 return;
         }
@@ -1211,7 +1211,7 @@ void disassociate_ctty(int on_exit)
         }
 
         /* Must lock changes to tty_old_pgrp */
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         current->signal->tty_old_pgrp = 0;
         tty->session = 0;
         tty->pgrp = -1;
@@ -1222,7 +1222,7 @@ void disassociate_ctty(int on_exit)
                 p->signal->tty = NULL;
         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
         read_unlock(&tasklist_lock);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         unlock_kernel();
 }
 
@@ -1306,7 +1306,7 @@ static inline ssize_t do_tty_write(
         ssize_t ret = 0, written = 0;
         unsigned int chunk;
         
-        if (down_interruptible(&tty->atomic_write)) {
+        if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
                 return -ERESTARTSYS;
         }
 
@@ -1329,7 +1329,7 @@ static inline ssize_t do_tty_write(
         if (count < chunk)
                 chunk = count;
 
-        /* write_buf/write_cnt is protected by the atomic_write semaphore */
+        /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
         if (tty->write_cnt < chunk) {
                 unsigned char *buf;
 
@@ -1338,7 +1338,7 @@ static inline ssize_t do_tty_write(
 
                 buf = kmalloc(chunk, GFP_KERNEL);
                 if (!buf) {
-                        up(&tty->atomic_write);
+                        mutex_unlock(&tty->atomic_write_lock);
                         return -ENOMEM;
                 }
                 kfree(tty->write_buf);
@@ -1374,7 +1374,7 @@ static inline ssize_t do_tty_write(
                 inode->i_mtime = current_fs_time(inode->i_sb);
                 ret = written;
         }
-        up(&tty->atomic_write);
+        mutex_unlock(&tty->atomic_write_lock);
         return ret;
 }
 
@@ -1442,8 +1442,8 @@ static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
 
 /*
  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
- * failed open.  The new code protects the open with a semaphore, so it's
- * really quite straightforward.  The semaphore locking can probably be
+ * failed open.  The new code protects the open with a mutex, so it's
+ * really quite straightforward.  The mutex locking can probably be
  * relaxed for the (most common) case of reopening a tty.
  */
 static int init_dev(struct tty_driver *driver, int idx,
@@ -1640,7 +1640,7 @@ fast_track:
 success:
         *ret_tty = tty;
         
-        /* All paths come through here to release the semaphore */
+        /* All paths come through here to release the mutex */
 end_init:
         return retval;
 
@@ -1837,7 +1837,7 @@ static void release_dev(struct file * filp)
                 /* Guard against races with tty->count changes elsewhere and
                    opens on /dev/tty */
                    
-                down(&tty_sem);
+                mutex_lock(&tty_mutex);
                 tty_closing = tty->count <= 1;
                 o_tty_closing = o_tty &&
                         (o_tty->count <= (pty_master ? 1 : 0));
@@ -1868,7 +1868,7 @@ static void release_dev(struct file * filp)
 
                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
                                     "active!\n", tty_name(tty, buf));
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 schedule();
         }       
 
@@ -1934,7 +1934,7 @@ static void release_dev(struct file * filp)
                 read_unlock(&tasklist_lock);
         }
 
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
 
         /* check whether both sides are closing ... */
         if (!tty_closing || (o_tty && !o_tty_closing))
@@ -2040,11 +2040,11 @@ retry_open:
         index  = -1;
         retval = 0;
         
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
 
         if (device == MKDEV(TTYAUX_MAJOR,0)) {
                 if (!current->signal->tty) {
-                        up(&tty_sem);
+                        mutex_unlock(&tty_mutex);
                         return -ENXIO;
                 }
                 driver = current->signal->tty->driver;
@@ -2070,18 +2070,18 @@ retry_open:
                         noctty = 1;
                         goto got_driver;
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 
         driver = get_tty_driver(device, &index);
         if (!driver) {
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 got_driver:
         retval = init_dev(driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         if (retval)
                 return retval;
 
@@ -2167,9 +2167,9 @@ static int ptmx_open(struct inode * inode, struct file * filp)
         }
         up(&allocated_ptys_lock);
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         retval = init_dev(ptm_driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         
         if (retval)
                 goto out;
@@ -2915,8 +2915,8 @@ static void initialize_tty_struct(struct tty_struct *tty)
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
-        sema_init(&tty->atomic_read, 1);
-        sema_init(&tty->atomic_write, 1);
+        mutex_init(&tty->atomic_read_lock);
+        mutex_init(&tty->atomic_write_lock);
         spin_lock_init(&tty->read_lock);
         INIT_LIST_HEAD(&tty->tty_files);
         INIT_WORK(&tty->SAK_work, NULL, NULL);