首先我们先要创建一个用于通信的结构unix_proto_data ，并初始化某些字段

static int unix_proto_create(struct socket *sock, int protocol)
{
	struct unix_proto_data *upd;

	/*
	 *	No funny SOCK_RAW stuff
	 */
	 
	if (protocol != 0) 
	{
		return(-EINVAL);
	}
	// 分配一个unix_proto_data结构体
	if (!(upd = unix_data_alloc())) 
	{
		printk("UNIX: create: can't allocate buffern");
		return(-ENOMEM);
	}
	// 给unix_proto_data的buf字段分配一个页大小的内存
	if (!(upd->buf = (char*) get_free_page(GFP_USER))) 
	{
		printk("UNIX: create: can't get page!n");
		unix_data_deref(upd);
		return(-ENOMEM);
	}
	upd->protocol = protocol;
	// 关联unix_proto_data对应的socket结构
	upd->socket = sock;
	// socket的data字段指向unix_proto_data结构
	UN_DATA(sock) = upd;
	// 标记unix_proto_data已被使用
	upd->refcnt = 1;	/* Now it's complete - bgm */
	return(0);
}

接着给这个结构绑定"地址信息"，一个文件路径。bind函数主要是根据传进来的路径创建一个文件，如果已经存在则报错。否则新建成功后把inode节点，路径名等信息存在unix_proto_data 结构

// 把sockaddr的内容存在unix_proto_data中，并创建一个文件
static int unix_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
		int sockaddr_len)
{
	char fname[UNIX_PATH_MAX + 1];
	struct unix_proto_data *upd = UN_DATA(sock);
	unsigned long old_fs;
	int i;

	if (sockaddr_len <= UN_PATH_OFFSET ||
		sockaddr_len > sizeof(struct sockaddr_un)) 
	{
		return(-EINVAL);
	}
	if (upd->sockaddr_len || upd->inode) 
	{
		/*printk("UNIX: bind: already bound!n");*/
		return(-EINVAL);
	}
	// sockaddr_un兼容sockaddr结构
	memcpy(&upd->sockaddr_un, umyaddr, sockaddr_len);
	/*
		UN_PATH_OFFSET为sun_path在sockaddr_un结构中的偏移，
		sockaddr_len-UN_PATH_OFFSET等于sun_path的最后一个字符+1的位置
	*/
	upd->sockaddr_un.sun_path[sockaddr_len-UN_PATH_OFFSET] = '';
	if (upd->sockaddr_un.sun_family != AF_UNIX) 
	{
		return(-EINVAL);
	}
	// 把sun_path的值放到fname中
	memcpy(fname, upd->sockaddr_un.sun_path, sockaddr_len-UN_PATH_OFFSET);
	fname[sockaddr_len-UN_PATH_OFFSET] = '';
	old_fs = get_fs();
	set_fs(get_ds());
	// 新建一个inode节点，文件名是fname，标记是一个socket类型
	i = do_mknod(fname, S_IFSOCK | S_IRWXUGO, 0);

	if (i == 0) 
		i = open_namei(fname, 0, S_IFSOCK, &upd->inode, NULL); // &upd->inode保存打开文件对应的inode节点
	set_fs(old_fs);
	if (i < 0) 
	{
/*		printk("UNIX: bind: can't open socket %sn", fname);*/
		if(i==-EEXIST)
			i=-EADDRINUSE;
		return(i);
	}
	upd->sockaddr_len = sockaddr_len;	/* now it's legal */
	
	return(0);
}

有了地址后，我们可以作为服务端或客户端，下面分开说，我们先说作为服务端
由于该版本没有支持listen函数。调用socket.c的listen函数时，unix没有对应的操作。所以我们可以直接调accept。通过代码我们知道调用socket.c的accept函数的时候，首先创建了一个新的socket结构，用于accept返回的时候，然后在该函数里面首先调用了另一个函数dup。该函数主要是创建比socket结构还底层的一个结构，然后和socket结构关联起来。所以我们先看看unix域层的dup函数。

/* 
	创建一个新的unix_proto_data结构和socket关联,newsock由上层新创建的，即首先创建了一个新的socket结构，
	根据oldsock的协议类型，创建了一个新的unix_proto_data和newsock关联
*/
static int unix_proto_dup(struct socket *newsock, struct socket *oldsock)
{
	struct unix_proto_data *upd = UN_DATA(oldsock);
	return(unix_proto_create(newsock, upd->protocol));
}

接着调accept，该函数主要是从socket的连接队列上不断地摘取连接节点，然后唤醒客户端，如果没有连接则阻塞自己，等待有连接的时候被唤醒。unix域中建立连接的本质是客户端和服务端的数据结构互相关联。从而完成通信。

static int unix_proto_accept(struct socket *sock, struct socket *newsock, int flags)
{
	struct socket *clientsock;

/*
 * If there aren't any sockets awaiting connection,
 * then wait for one, unless nonblocking.
 */
	// sock为服务端socket，iconn是连接队列，先判断是否有连接
	while(!(clientsock = sock->iconn)) 
	{	
		// 为空并且设置了非阻塞直接返回
		if (flags & O_NONBLOCK) 
			return(-EAGAIN);
		// 设置等待连接标记
		sock->flags |= SO_WAITDATA;
		// 阻塞，有有人connect的时候被唤醒
		interruptible_sleep_on(sock->wait);
		// 清除等待连接标记
		sock->flags &= ~SO_WAITDATA;
		if (current->signal & ~current->blocked) 
		{
			return(-ERESTARTSYS);
		}
	}
/*
 * Great. Finish the connection relative to server and client,
 * wake up the client and return the new fd to the server.
 */
	// 更新服务端的连接队列，摘下了第一个节点
	sock->iconn = clientsock->next;
	clientsock->next = NULL;
	// 新生成的socket结构，对端指向客户端
	newsock->conn = clientsock;
	// 互相引用，设置状态为已连接
	clientsock->conn = newsock;
	clientsock->state = SS_CONNECTED;
	newsock->state = SS_CONNECTED;
	// unix_proto_data结构的引用数加1
	unix_data_ref(UN_DATA(clientsock));
	// 把unix_proto_data的数据复制到sock结构中，保存客户端的路径信息
	UN_DATA(newsock)->peerupd	     = UN_DATA(clientsock);
	UN_DATA(newsock)->sockaddr_un        = UN_DATA(sock)->sockaddr_un;
	UN_DATA(newsock)->sockaddr_len       = UN_DATA(sock)->sockaddr_len;
	// 唤醒被阻塞的客户端队列
	wake_up_interruptible(clientsock->wait);
	sock_wake_async(clientsock, 0);
	return(0);
}

接下来我们看connect函数，connect函数主要是把自客户端的追加到服务端的连接队列，阻塞自己，等待服务端进行处理，然后被唤醒，期间不断完成数据的互相关联。

	memcpy(fname, sockun.sun_path, sockaddr_len-UN_PATH_OFFSET);
	fname[sockaddr_len-UN_PATH_OFFSET] = '';
	old_fs = get_fs();
	set_fs(get_ds());
	// 根据传入的路径打开该文件，把inode存在inode变量里
	i = open_namei(fname, 2, S_IFSOCK, &inode, NULL);
	set_fs(old_fs);
	if (i < 0) 
	{
		return(i);
	}
	// 从unix_proto_data表中找到服务端对应的unix_proto_data结构  
	serv_upd = unix_data_lookup(&sockun, sockaddr_len, inode);
	iput(inode);
	// 没有则说明服务端不存在
	if (!serv_upd) 
	{
		return(-EINVAL);
	}
	// 把客户端追加到服务端的连接队列，阻塞自己，等待服务器处理后唤醒
	if ((i = sock_awaitconn(sock, serv_upd->socket, flags)) < 0) 
	{
		return(i);
	}
	// conn为服务端socket
	if (sock->conn) 
	{	// 服务端unix_proto_data结构引用数加一，并指向服务端unix_proto_data结构
		unix_data_ref(UN_DATA(sock->conn));
		UN_DATA(sock)->peerupd = UN_DATA(sock->conn); /* ref server */
	}
	return(0);
}

// 把客户端socket追加到服务端的队列结尾，设置客户端的的对端是服务端的socket，唤醒服务端处理请求，当前进程阻塞，等待唤醒	
int sock_awaitconn(struct socket *mysock, struct socket *servsock, int flags)
{
	struct socket *last;

	/*
	 *	We must be listening
	 */
	// 调用listen的时候设置的
	if (!(servsock->flags & SO_ACCEPTCON)) 
	{
		return(-EINVAL);
	}

  	/*
  	 *	Put ourselves on the server's incomplete connection queue. 
  	 */
  	 
	mysock->next = NULL;
	cli();
	// 把客服端socket加到服务端的连接队列
	if (!(last = servsock->iconn)) // 队列为空，则当前客户端为第一个连接节点 
		servsock->iconn = mysock; 
	else 
	{	// 找到队尾，然后追加到队尾
		while (last->next) 
			last = last->next;
		last->next = mysock;
	}
	mysock->state = SS_CONNECTING;
	// 设置客户端的对端
	mysock->conn = servsock;
	sti();

	/*
	 * Wake up server, then await connection. server will set state to
	 * SS_CONNECTED if we're connected.
	 */
	// 有连接到来，唤醒服务端
	wake_up_interruptible(servsock->wait);
	sock_wake_async(servsock, 0);
	
	if (mysock->state != SS_CONNECTED) 
	{	
		// 此时state为SS_CONNECTING，非阻塞则直接返回
		if (flags & O_NONBLOCK)
			return -EINPROGRESS;
		// 否则阻塞当前发起连接的进程，等待服务端处理连接，设置state为SS_CONNECTED，然后唤醒客户端
		interruptible_sleep_on(mysock->wait);
		// 状态不对，删除该客户端
		if (mysock->state != SS_CONNECTED &&
		    mysock->state != SS_DISCONNECTING) 
		{
		/*
		 * if we're not connected we could have been
		 * 1) interrupted, so we need to remove ourselves
		 *    from the server list
		 * 2) rejected (mysock->conn == NULL), and have
		 *    already been removed from the list
		 */
			if (mysock->conn == servsock) 
			{
				cli();
				// 服务端连接队列只有一个节点
				if ((last = servsock->iconn) == mysock)
					servsock->iconn = mysock->next;
				else 
				{	// 找到mysock的前一个节点，删除mysock
					while (last->next != mysock) 
						last = last->next;
					last->next = mysock->next;
				}
				sti();
			}
			return(mysock->conn ? -EINTR : -EACCES);
		}
	}
	return(0);
}

到这里，我们完成了建立连接的过程。接下来我们可以进行全双工的通信了。讲数据通信之前首先要讲一下可回环的缓冲区，他本质是一个一定大小的数组，数据写到最后一个索引后，如果前面的索引对应的元素是空，则可以往回开始写。unix域里主要是一个一页大小的字节数组作为通信的缓冲区。然后他有两个头尾指针，分别代码可写空间的起始索引和结束索引。当一端向另一端写数据的时候，直接写到对端的缓冲区去，然后对端就可以读了。初始化的时候head和tail都是0，可写空间是缓冲区大小，因为head要追上tail需要移动一页大小，当对端往里面写10个字节的时候，head往后移动10位，这时候可写字节数等于一页-10，而本端则通过tail指针可知道从哪里是可读的数据。head-tail知道还有多少空间可写，再和一页进行计算，就知道有多少空间可读，读指针是tail。

 
static int unix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
{
	struct unix_proto_data *upd;
	int todo, avail;

	if ((todo = size) <= 0) 
		return(0);

	upd = UN_DATA(sock);
	// 看buf中有多少数据可读
	while(!(avail = UN_BUF_AVAIL(upd))) 
	{
		if (sock->state != SS_CONNECTED) 
		{
			return((sock->state == SS_DISCONNECTING) ? 0 : -EINVAL);
		}
		// 没有数据，但是以非阻塞模式，直接返回
		if (nonblock) 
			return(-EAGAIN);
		// 阻塞等待数据
		sock->flags |= SO_WAITDATA;
		interruptible_sleep_on(sock->wait);
		// 唤醒后清除等待标记位
		sock->flags &= ~SO_WAITDATA;
		if (current->signal & ~current->blocked) 
		{
			return(-ERESTARTSYS);
		}
	}

/*
 *	Copy from the read buffer into the user's buffer,
 *	watching for wraparound. Then we wake up the writer.
 */
    // 加锁
	unix_lock(upd);
	do 
	{
		int part, cando;

		if (avail <= 0) 
		{
			printk("UNIX: read: AVAIL IS NEGATIVE!!!n");
			send_sig(SIGKILL, current, 1);
			return(-EPIPE);
		}
		// 要读的比可读的多，则要读的为可读的数量
		if ((cando = todo) > avail) 
			cando = avail;
		// 有一部分数据在队尾，一部分在队头，则先读队尾的,bp_tail表示可写空间的最后一个字节加1，即可读的第一个字节
		if (cando >(part = BUF_SIZE - upd->bp_tail)) 
			cando = part;
		memcpy_tofs(ubuf, upd->buf + upd->bp_tail, cando);
		// 更新bp_tail，可写空间增加
		upd->bp_tail =(upd->bp_tail + cando) &(BUF_SIZE-1);
		// 更新用户的buf指针
		ubuf += cando;
		// 还需要读的字节数
		todo -= cando;
		if (sock->state == SS_CONNECTED)
		{
			wake_up_interruptible(sock->conn->wait);
			sock_wake_async(sock->conn, 2);
		}
		avail = UN_BUF_AVAIL(upd);
	} 
	while(todo && avail);// 还有数据并且还没读完则继续
	unix_unlock(upd);
	return(size - todo);// 要读的减去读了的
}


/*
 *	We write to our peer's buf. When we connected we ref'd this
 *	peer so we are safe that the buffer remains, even after the
 *	peer has disconnected, which we check other ways.
 */
 
static int unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
{
	struct unix_proto_data *pupd;
	int todo, space;

	if ((todo = size) <= 0)
		return(0);
	if (sock->state != SS_CONNECTED) 
	{
		if (sock->state == SS_DISCONNECTING) 
		{
			send_sig(SIGPIPE, current, 1);
			return(-EPIPE);
		}
		return(-EINVAL);
	}
	// 获取对端的unix_proto_data字段
	pupd = UN_DATA(sock)->peerupd;	/* safer than sock->conn */
	// 还有多少空间可写
	while(!(space = UN_BUF_SPACE(pupd))) 
	{
		sock->flags |= SO_NOSPACE;
		if (nonblock) 
			return(-EAGAIN);
		sock->flags &= ~SO_NOSPACE;
		interruptible_sleep_on(sock->wait);
		if (current->signal & ~current->blocked) 
		{
			return(-ERESTARTSYS);
		}
		if (sock->state == SS_DISCONNECTING) 
		{
			send_sig(SIGPIPE, current, 1);
			return(-EPIPE);
		}
	}

/*
 *	Copy from the user's buffer to the write buffer,
 *	watching for wraparound. Then we wake up the reader.
 */
   
	unix_lock(pupd);

	do 
	{
		int part, cando;

		if (space <= 0) 
		{
			printk("UNIX: write: SPACE IS NEGATIVE!!!n");
			send_sig(SIGKILL, current, 1);
			return(-EPIPE);
		}

		/*
		 *	We may become disconnected inside this loop, so watch
		 *	for it (peerupd is safe until we close).
		 */
		 
		if (sock->state == SS_DISCONNECTING) 
		{
			send_sig(SIGPIPE, current, 1);
			unix_unlock(pupd);
			return(-EPIPE);
		}
		// 需要写的比能写的多
		if ((cando = todo) > space) 
			cando = space;
		// 可写空间一部分在队头一部分在队尾，则先写队尾的，再写队头的
		if (cando >(part = BUF_SIZE - pupd->bp_head))
			cando = part;
	
		memcpy_fromfs(pupd->buf + pupd->bp_head, ubuf, cando);
		// 更新可写地址，可写空间减少，处理回环情况
		pupd->bp_head =(pupd->bp_head + cando) &(BUF_SIZE-1);
		// 更新用户的buf指针
		ubuf += cando;
		// 还需要写多少个字
		todo -= cando;
		if (sock->state == SS_CONNECTED)
		{
			wake_up_interruptible(sock->conn->wait);
			sock_wake_async(sock->conn, 1);
		}
		space = UN_BUF_SPACE(pupd);
	}
	while(todo && space);

	unix_unlock(pupd);
	return(size - todo);
}