linux ttyS设备的close

1，从close系统调用开始

从用户层close系统调用进到内核层，linux系统调用用一些列宏来定义，close位于fs/open.c

SYSCALL_DEFINE1(close, unsigned int, fd)
{
	int retval = __close_fd(current->files, fd);

	/* can't restart close syscall because file table entry was cleared */
	if (unlikely(retval == -ERESTARTSYS ||
		     retval == -ERESTARTNOINTR ||
		     retval == -ERESTARTNOHAND ||
		     retval == -ERESTART_RESTARTBLOCK))
		retval = -EINTR;

	return retval;
}

int __close_fd(struct files_struct *files, unsigned fd)
{
	struct file *file;
	struct fdtable *fdt;

	spin_lock(&files->file_lock);
	fdt = files_fdtable(files);
	if (fd >= fdt->max_fds)
		goto out_unlock;
	file = fdt->fd[fd];
	if (!file)
		goto out_unlock;
	rcu_assign_pointer(fdt->fd[fd], NULL);
	__clear_close_on_exec(fd, fdt);
	__put_unused_fd(files, fd);
	spin_unlock(&files->file_lock);
	return filp_close(file, files);

out_unlock:
	spin_unlock(&files->file_lock);
	return -EBADF;
}

传递了两个参数给__close_fd函数，第一个参数current即当前进程指向的一个file_struct结构体，定义如下

/* * Open file table structure */struct files_struct {  /*   * read mostly part   */atomic_t count;struct fdtable __rcu *fdt;struct fdtable fdtab;  /*   * written part on a separate cache line in SMP   */spinlock_t file_lock ____cacheline_aligned_in_smp;int next_fd;unsigned long close_on_exec_init[1];unsigned long open_fds_init[1];struct file __rcu * fd_array[NR_OPEN_DEFAULT];};

每个进程打开的file都用这个结构体管理。 其中*fdt和fdtab是fdtable结构体，此结构体里有一个成员struct file __rcu **fd; 就是当前进程打开的文件结构体组成的数组

struct fdtable { unsigned int max_fds; struct file __rcu **fd;      /* current fd array */ unsigned long *close_on_exec; unsigned long *open_fds; struct rcu_head rcu;};

所以通过这两条代码可以获取到实际要close的文件的struct file

fdt = files_fdtable(files);

file = fdt->fd[fd];

接下来调用关系就是filp_close()----->fput()---->__fput()------>file->f_op->release(). 就来到了tty层的release

2，从tty层到uart driver的clsoe

/**
 *	tty_release		-	vfs callback for close
 *	@inode: inode of tty
 *	@filp: file pointer for handle to tty
 *
 *	Called the last time each file handle is closed that references
 *	this tty. There may however be several such references.
 *
 *	Locking:
 *		Takes bkl. See tty_release_dev
 *
 * Even releasing the tty structures is a tricky business.. We have
 * to be very careful that the structures are all released at the
 * same time, as interrupts might otherwise get the wrong pointers.
 *
 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
 * lead to double frees or releasing memory still in use.
 */

int tty_release(struct inode *inode, struct file *filp)
{
	struct tty_struct *tty = file_tty(filp);
	.......
	if (tty->ops->close)
		tty->ops->close(tty, filp);

	.......
	return 0;
}

大段代码略去不看，大部分是清理一些标记，和释放一些结构体。直接从filep获取tty_struct.，然后调用ops->close.tty_struct是tty层核心结构体. 这里只关注tty->ops->close.

那么这个close具体是在哪里实现？是怎么初始化到tty_struct结构体呢？

tty_struct的初始化时在tty_open中不是在tty driver的register中。

/drivers/tty/tty_io.c

tty_open()----->tty_init_dev()---->initialize_tty_struct()  

tty->ops = driver->ops;  

tty_struct 的ops即tty_driver的ops。 

tty_driver这边是在serial层注册的，就是uart驱动初始化时，注册一个tty_driver,并分配ops

int uart_register_driver(struct uart_driver *drv)
{
	struct tty_driver *normal;
	int i, retval;

	BUG_ON(drv->state);

	/*
	 * Maybe we should be using a slab cache for this, especially if
	 * we have a large number of ports to handle.
	 */
	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
	if (!drv->state)
		goto out;

	normal = alloc_tty_driver(drv->nr);
	if (!normal)
		goto out_kfree;

	drv->tty_driver = normal;

	normal->driver_name	= drv->driver_name;
	normal->name		= drv->dev_name;
	normal->major		= drv->major;
	normal->minor_start	= drv->minor;
	normal->type		= TTY_DRIVER_TYPE_SERIAL;
	normal->subtype		= SERIAL_TYPE_NORMAL;
	normal->init_termios	= tty_std_termios;
	normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
	normal->flags		= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
	normal->driver_state    = drv;
	tty_set_operations(normal, &uart_ops);

	/*
	 * Initialise the UART state(s).
	 */
	for (i = 0; i < drv->nr; i++) {
		struct uart_state *state = drv->state + i;
		struct tty_port *port = &state->port;

		tty_port_init(port);
		port->ops = &uart_port_ops;
		port->close_delay     = HZ / 2;	/* .5 seconds */
		port->closing_wait    = 30 * HZ;/* 30 seconds */
	}

	retval = tty_register_driver(normal);
	if (retval >= 0)
		return retval;

	for (i = 0; i < drv->nr; i++)
		tty_port_destroy(&drv->state[i].port);
	put_tty_driver(normal);
out_kfree:
	kfree(drv->state);
out:
	return -ENOMEM;
}

这个ops即 uart_ops.  这样，这个close已经从tty层到了serial层。在drivers/tty/serial/serial_core.c

然后就比较清晰了。

uart_close()----->uart_shutdown()----->uport->ops->shutdown()

static void uart_port_shutdown(struct tty_port *port)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport = state->uart_port;

	/*
	 * clear delta_msr_wait queue to avoid mem leaks: we may free
	 * the irq here so the queue might never be woken up.  Note
	 * that we won't end up waiting on delta_msr_wait again since
	 * any outstanding file descriptors should be pointing at
	 * hung_up_tty_fops now.
	 */
	wake_up_interruptible(&port->delta_msr_wait);

	/*
	 * Free the IRQ and disable the port.
	 */
	uport->ops->shutdown(uport);

	/*
	 * Ensure that the IRQ handler isn't running on another CPU.
	 */
	synchronize_irq(uport->irq);
}

这里又出现了struct uart_port .uart_port实际对应的是每一个uart硬件接口。 tty_struct 则是更高层次的抽象。

这里的uport->ops 即uart实际驱动层的struct_ops .由于tty层其实和serial层已经做了大部分工作，到驱动层只剩下很少的硬件相关操作。