tty: Refactor tty_open()

Extract the driver lookup and reopen-or-initialize logic into helper
function tty_open_by_driver(). No functional change.
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/tty/tty_io.c

@@ -1995,62 +1995,41 @@ static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
 }
 
 /**
- *	tty_open		-	open a tty device
+ *	tty_open_by_driver	-	open a tty device
+ *	@device: dev_t of device to open
  *	@inode: inode of device file
  *	@filp: file pointer to tty
  *
- *	tty_open and tty_release keep up the tty count that contains the
- *	number of opens done on a tty. We cannot use the inode-count, as
- *	different inodes might point to the same tty.
- *
- *	Open-counting is needed for pty masters, as well as for keeping
- *	track of serial lines: DTR is dropped when the last close happens.
- *	(This is not done solely through tty->count, now.  - Ted 1/27/92)
+ *	Performs the driver lookup, checks for a reopen, or otherwise
+ *	performs the first-time tty initialization.
  *
- *	The termios state of a pty is reset on first open so that
- *	settings don't persist across reuse.
+ *	Returns the locked initialized or re-opened &tty_struct
  *
- *	Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
- *		 tty->count should protect the rest.
- *		 ->siglock protects ->signal/->sighand
- *
- *	Note: the tty_unlock/lock cases without a ref are only safe due to
- *	tty_mutex
+ *	Claims the global tty_mutex to serialize:
+ *	  - concurrent first-time tty initialization
+ *	  - concurrent tty driver removal w/ lookup
+ *	  - concurrent tty removal from driver table
  */
-
-static int tty_open(struct inode *inode, struct file *filp)
+static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
+					     struct file *filp)
 {
 	struct tty_struct *tty;
-	int noctty, retval;
 	struct tty_driver *driver = NULL;
-	int index;
-	dev_t device = inode->i_rdev;
-	unsigned saved_flags = filp->f_flags;
-
-	nonseekable_open(inode, filp);
-
-retry_open:
-	retval = tty_alloc_file(filp);
-	if (retval)
-		return -ENOMEM;
-
-	index  = -1;
-	retval = 0;
+	int index = -1;
+	int retval;
 
-	tty = tty_open_current_tty(device, filp);
-	if (!tty) {
 	mutex_lock(&tty_mutex);
 	driver = tty_lookup_driver(device, filp, &index);
 	if (IS_ERR(driver)) {
-			retval = PTR_ERR(driver);
-			goto err_unlock;
+		mutex_unlock(&tty_mutex);
+		return ERR_CAST(driver);
 	}
 
 	/* check whether we're reopening an existing tty */
 	tty = tty_driver_lookup_tty(driver, inode, index);
 	if (IS_ERR(tty)) {
-			retval = PTR_ERR(tty);
-			goto err_unlock;
+		mutex_unlock(&tty_mutex);
+		goto out;
 	}
 
 	if (tty) {
@@ -2059,7 +2038,8 @@ static int tty_open(struct inode *inode, struct file *filp)
 		if (retval) {
 			if (retval == -EINTR)
 				retval = -ERESTARTSYS;
-				goto err_unref;
+			tty = ERR_PTR(retval);
+			goto out;
 		}
 		/* safe to drop the kref from tty_driver_lookup_tty() */
 		tty_kref_put(tty);
@@ -2072,15 +2052,58 @@ static int tty_open(struct inode *inode, struct file *filp)
 		tty = tty_init_dev(driver, index);
 		mutex_unlock(&tty_mutex);
 	}
-
+out:
 	tty_driver_kref_put(driver);
-	}
+	return tty;
+}
+
+/**
+ *	tty_open		-	open a tty device
+ *	@inode: inode of device file
+ *	@filp: file pointer to tty
+ *
+ *	tty_open and tty_release keep up the tty count that contains the
+ *	number of opens done on a tty. We cannot use the inode-count, as
+ *	different inodes might point to the same tty.
+ *
+ *	Open-counting is needed for pty masters, as well as for keeping
+ *	track of serial lines: DTR is dropped when the last close happens.
+ *	(This is not done solely through tty->count, now.  - Ted 1/27/92)
+ *
+ *	The termios state of a pty is reset on first open so that
+ *	settings don't persist across reuse.
+ *
+ *	Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
+ *		 tty->count should protect the rest.
+ *		 ->siglock protects ->signal/->sighand
+ *
+ *	Note: the tty_unlock/lock cases without a ref are only safe due to
+ *	tty_mutex
+ */
+
+static int tty_open(struct inode *inode, struct file *filp)
+{
+	struct tty_struct *tty;
+	int noctty, retval;
+	dev_t device = inode->i_rdev;
+	unsigned saved_flags = filp->f_flags;
+
+	nonseekable_open(inode, filp);
+
+retry_open:
+	retval = tty_alloc_file(filp);
+	if (retval)
+		return -ENOMEM;
+
+	tty = tty_open_current_tty(device, filp);
+	if (!tty)
+		tty = tty_open_by_driver(device, inode, filp);
 
 	if (IS_ERR(tty)) {
+		tty_free_file(filp);
 		retval = PTR_ERR(tty);
 		if (retval != -EAGAIN || signal_pending(current))
-			goto err_file;
-		tty_free_file(filp);
+			return retval;
 		schedule();
 		goto retry_open;
 	}
@@ -2151,15 +2174,6 @@ static int tty_open(struct inode *inode, struct file *filp)
 	read_unlock(&tasklist_lock);
 	tty_unlock(tty);
 	return 0;
-err_unlock:
-	mutex_unlock(&tty_mutex);
-err_unref:
-	/* after locks to avoid deadlock */
-	if (!IS_ERR_OR_NULL(driver))
-		tty_driver_kref_put(driver);
-err_file:
-	tty_free_file(filp);
-	return retval;
 }