套接字之close系统调用

close系统调用用于关闭文件描述符，其系统调用实现如下所示；

 /
  * Careful here! We test whether the file pointer is NULL before
  * releasing the fd. This ensures that one clone task can't release
  * an fd while another clone is opening it.
  */
 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;
 }
 EXPORT_SYMBOL(sys_close);

本文重点在于分析套接字的的close部分，所以简要列出close系统调用通用流程的函数调用关系，如下；

补充：其中重点注意下fput函数，该函数会先现将文件的引用计数-1，然后判断是否为0，为0的时候才会进行继续的流程，也就是说当socket存在多个引用的时候，只有最后一个close才会触发后面的调度销毁流程，也是close与shutdown不同的一个地方；

 /**
  * close系统调用函数调用关系
  *__close_fd
  *  |-->filp_close
  *     |-->fput 将file加入到delayed_fput_list链表
  *         |-->schedule_delayed_work 调度延迟执行队列处理链表
  *             |-->delayed_fput
  *                 |-->__fput
  *                    |-->file->f_op->release 调用文件的release操作
  */

可见，在close系统调用中会调用文件的release操作，所以我们本文重点分析socket的release操作实现；

socket实现的文件操作结构如下所示，其中本文讨论的release函数实现为sock_close；

 /* socket文件操作函数 */
 static const struct file_operations socket_file_ops = {
     .owner =    THIS_MODULE,
     .llseek =    no_llseek,
     .read_iter =    sock_read_iter,
     .write_iter =    sock_write_iter,
     .poll =        sock_poll,
     .unlocked_ioctl = sock_ioctl,
 #ifdef CONFIG_COMPAT
     .compat_ioctl = compat_sock_ioctl,
 #endif
     .mmap =        sock_mmap,
     .release =    sock_close,
     .fasync =    sock_fasync,
     .sendpage =    sock_sendpage,
     .splice_write = generic_splice_sendpage,
     .splice_read =    sock_splice_read,
 };

在socket_release函数中，会调用socket操作函数release，ipv4对应inet_release;

 /* 关闭socket */
 static int sock_close(struct inode *inode, struct file *filp)
 {
     /* socket关闭 */
     sock_release(SOCKET_I(inode));
     return ;
 }

 /**
  *    sock_release    -    close a socket
  *    @sock: socket to close
  *
  *    The socket is released from the protocol stack if it has a release
  *    callback, and the inode is then released if the socket is bound to
  *    an inode not a file.
  */

 void sock_release(struct socket *sock)
 {
     if (sock->ops) {
         struct module *owner = sock->ops->owner;

         /* 调用socket操作中的release */
         sock->ops->release(sock);
         sock->ops = NULL;
         module_put(owner);
     }

     if (rcu_dereference_protected(sock->wq, )->fasync_list)
         pr_err("%s: fasync list not empty!\n", __func__);

     /* 减少cpu的套接口数量 */
     this_cpu_sub(sockets_in_use, );

     /* 容错处理 */
     if (!sock->file) {
         iput(SOCK_INODE(sock));
         return;
     }

     /* 套接口完成关闭，继续执行close系统调用其他流程 */
     sock->file = NULL;
 }

inet_release负责退出组播组，根据是否开启linger标记来设置延迟关闭时间，并且调用传输层的close函数，对于tcp来说，其调用的为tcp_close；

 /*
  *    The peer socket should always be NULL (or else). When we call this
  *    function we are destroying the object and from then on nobody
  *    should refer to it.
  */
 int inet_release(struct socket *sock)
 {
     struct sock *sk = sock->sk;

     if (sk) {
         long timeout;

         /* Applications forget to leave groups before exiting */
         /* 退出组播组 */
         ip_mc_drop_socket(sk);

         /* If linger is set, we don't return until the close
          * is complete.  Otherwise we return immediately. The
          * actually closing is done the same either way.
          *
          * If the close is due to the process exiting, we never
          * linger..
          */
         timeout = ;

         /*
             设置了linger标记，进程未在退出，
             则设置lingertime延迟关闭时间
         */
         if (sock_flag(sk, SOCK_LINGER) &&
             !(current->flags & PF_EXITING))
             timeout = sk->sk_lingertime;
         sock->sk = NULL;

         /* 调用传输层的close函数 */
         sk->sk_prot->close(sk, timeout);
     }
     return ;
 }

tcp_close分析请移步另外一篇文章<TCP层close系统调用的实现分析>；