accept system call 2 (inet_csk_accept)

이전 포스트: https://byeo.tistory.com/entry/accept-system-call-1-sysaccept4

accept system call 1 (__sys_accept4)

 

 

sock->ops->accept 함수는 inet_accept입니다.

 

 

 

5. inet_accept

// net/ipv4/af_inet.c/inet_accept() :738

int inet_accept(struct socket *sock, struct socket *newsock, int flags,
		bool kern)
{
	struct sock *sk1 = sock->sk;
	int err = -EINVAL;
	struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err, kern);

	if (!sk2)
		goto do_err;

	lock_sock(sk2);

	sock_rps_record_flow(sk2);
	WARN_ON(!((1 << sk2->sk_state) &
		  (TCPF_ESTABLISHED | TCPF_SYN_RECV |
		  TCPF_CLOSE_WAIT | TCPF_CLOSE)));

	sock_graft(sk2, newsock);

	newsock->state = SS_CONNECTED;
	err = 0;
	release_sock(sk2);
do_err:
	return err;
}

 

inet_accept의 parameter로는

• sock: 기존 struct socket*
• new_sock: 새로 할당받은 struct socket*
• flags: 기존 sock의 file flags와 accept system call flag의 bitwise or
• kern: false (user를 위해 처리중)

 

// net/ipv4/af_inet.c/inet_accept() :741

	struct sock *sk1 = sock->sk;
	int err = -EINVAL;
	struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err, kern);

 

sk1에는 struct socket*으로부터 struct sock*을 가져옵니다. 그리고 곧바로 sk1->sk_prot->accept를 호출하는데요, 이는 tcp_prot에 있는 accept 함수를 호출하는 것으로서, inet_csk_accept를 호출합니다.

 

6. inet_csk_accept

// net/ipv4/inet_connection_sock.c/inet_csk_accept() :468

/*
 * This will accept the next outstanding connection.
 */
struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	struct request_sock_queue *queue = &icsk->icsk_accept_queue;
	struct request_sock *req;
	struct sock *newsk;
	int error;

	lock_sock(sk);

	/* We need to make sure that this socket is listening,
	 * and that it has something pending.
	 */
	error = -EINVAL;
	if (sk->sk_state != TCP_LISTEN)
		goto out_err;

	/* Find already established connection */
	if (reqsk_queue_empty(queue)) {
		long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

		/* If this is a non blocking socket don't sleep */
		error = -EAGAIN;
		if (!timeo)
			goto out_err;

		error = inet_csk_wait_for_connect(sk, timeo);
		if (error)
			goto out_err;
	}
	req = reqsk_queue_remove(queue, sk);
	newsk = req->sk;

	if (sk->sk_protocol == IPPROTO_TCP &&
	    tcp_rsk(req)->tfo_listener) {
		spin_lock_bh(&queue->fastopenq.lock);
		if (tcp_rsk(req)->tfo_listener) {
			/* We are still waiting for the final ACK from 3WHS
			 * so can't free req now. Instead, we set req->sk to
			 * NULL to signify that the child socket is taken
			 * so reqsk_fastopen_remove() will free the req
			 * when 3WHS finishes (or is aborted).
			 */
			req->sk = NULL;
			req = NULL;
		}
		spin_unlock_bh(&queue->fastopenq.lock);
	}

out:
	release_sock(sk);
	if (newsk && mem_cgroup_sockets_enabled) {
		int amt;

		/* atomically get the memory usage, set and charge the
		 * newsk->sk_memcg.
		 */
		lock_sock(newsk);

		/* The socket has not been accepted yet, no need to look at
		 * newsk->sk_wmem_queued.
		 */
		amt = sk_mem_pages(newsk->sk_forward_alloc +
				   atomic_read(&newsk->sk_rmem_alloc));
		mem_cgroup_sk_alloc(newsk);
		if (newsk->sk_memcg && amt)
			mem_cgroup_charge_skmem(newsk->sk_memcg, amt,
						GFP_KERNEL | __GFP_NOFAIL);

		release_sock(newsk);
	}
	if (req)
		reqsk_put(req);
	return newsk;
out_err:
	newsk = NULL;
	req = NULL;
	*err = error;
	goto out;
}
EXPORT_SYMBOL(inet_csk_accept);

 

1) TCP state가 TCP_LISTEN인지 검사

가장 먼저, sk_state가 TCP_LISTEN인지 확인합니다. accept은 일반적으로 listen 이후에 호출되므로 TCP_LISTEN state가 정상입니다.

 

2) request socket이 비어있는지 검사

	if (reqsk_queue_empty(queue)) {
		long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

		/* If this is a non blocking socket don't sleep */
		error = -EAGAIN;
		if (!timeo)
			goto out_err;

		error = inet_csk_wait_for_connect(sk, timeo);
		if (error)
			goto out_err;
	}

 

reqsk_queue_empty는 icsk->icsk_accept_queue가 empty인지 확인하는 함수입니다.

// include/net/request_sock.h/reqsk_queue_empty() :193

static inline bool reqsk_queue_empty(const struct request_sock_queue *queue)
{
	return READ_ONCE(queue->rskq_accept_head) == NULL;
}

 

icsk_accept_queue는 listen system call에서 초기화가 되었었죠. 이 queue에 data를 넣는 것은 3-way handshake를 처리하는 과정에서 이루어질 것으로 보입니다. 여기서는 상황에 따라 if를 탈 수도, 타지않을 수도 있을 것으로 보이네요.

 

 

6-1) request socks queue is empty

먼저, accept_queue가 비어있는 상황을 보도록 하겠습니다.

 

		long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

 

해당 함수는 timeout value를 반환합니다.

// include/net/sock.h/sock_rcvtimeo() :2441

static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
{
	return noblock ? 0 : sk->sk_rcvtimeo;
}

 

현재 blocking 상태를 가정하고 있고, sk->sk_rcvtimeo는 socket 생성 시에 -1로 지정되어있음에 따라 -1을 반환하게 됩니다.

 

• nonblocking의 경우에는 timeo 값이 0이 되고, 그에 따라 goto out_err에 걸려 inet_csk_accept를 빠져나가게 됩니다. return value는 -EAGAIN입니다. NONBLOCK을 설정한 상태에서 데이터가 없으면 마주하게 되는 에러코드이죠.
• blocking의 경우에는 inet_csk_wait_for_conenct를 호출합니다.

 

6-1-1) inet_csk_wait_for_connect

blocking과 가장 관련이 깊어보이는 함수입니다.

 

// net/ipv4/inet_connection_sock.c/inet_csk_wait_for_connect() :419

/*
 * Wait for an incoming connection, avoid race conditions. This must be called
 * with the socket locked.
 */
static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	DEFINE_WAIT(wait);
	int err;

	/*
	 * True wake-one mechanism for incoming connections: only
	 * one process gets woken up, not the 'whole herd'.
	 * Since we do not 'race & poll' for established sockets
	 * anymore, the common case will execute the loop only once.
	 *
	 * Subtle issue: "add_wait_queue_exclusive()" will be added
	 * after any current non-exclusive waiters, and we know that
	 * it will always _stay_ after any new non-exclusive waiters
	 * because all non-exclusive waiters are added at the
	 * beginning of the wait-queue. As such, it's ok to "drop"
	 * our exclusiveness temporarily when we get woken up without
	 * having to remove and re-insert us on the wait queue.
	 */
	for (;;) {
		prepare_to_wait_exclusive(sk_sleep(sk), &wait,
					  TASK_INTERRUPTIBLE);
		release_sock(sk);
		if (reqsk_queue_empty(&icsk->icsk_accept_queue))
			timeo = schedule_timeout(timeo);
		sched_annotate_sleep();
		lock_sock(sk);
		err = 0;
		if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
			break;
		err = -EINVAL;
		if (sk->sk_state != TCP_LISTEN)
			break;
		err = sock_intr_errno(timeo);
		if (signal_pending(current))
			break;
		err = -EAGAIN;
		if (!timeo)
			break;
	}
	finish_wait(sk_sleep(sk), &wait);
	return err;
}

 

 

wait과 더불어 prepare_to_wait_exclusive 함수와 관련해서는 makeliunx 사이트의 linux device driver 책이 설명을 잘 정리해주고 있었습니다: https://www.makelinux.net/ldd3/chp-6-sect-2.shtml

 

 그리고 이 blocking 함수의 작성 원리를 https://byeo.tistory.com/entry/Linux-Kernel-Blocking-IO에 작성하였으니 참고부탁드립니다.

[Linux Kernel] Blocking I/O

 

DEFINE_WAIT은 wait_queue_entry를 선언하고 초기화 하는 매크로입니다.

 

prepare_to_wait_exclusive는 sk의 wait queue와 wait_queue_entry를 제공받아서 잠들기 위한 준비를 시작합니다. 이 때 exclusive는 we_entry->flags에 WQ_FLAG_EXCLUSIVE를 마크함에 따라, 추후에 잠든 process 여러개 중에서 하나만 깨어나도록 설정합니다.

 

		if (reqsk_queue_empty(&icsk->icsk_accept_queue))
			timeo = schedule_timeout(timeo);

이제 잠들기 전, 진짜로 마지막 조건을 체크합니다.

 

이미 inet_csk_wait_for_connect 함수에 들어올 때 동일한 조건을 한 번 체크했을텐데 왜 또 체크할까요?

이는 inet_csk_wait_for_connect함수 시작 ~ prepare_to_wait_exclusive 사이에서, SYN이 유입되어 accept queue가 하나 찼을수도 있기 때문입니다. 만약 그렇게 된다면 이미 데이터가 있음에도 불구하고 다시 오래 blocking에 빠질 수 있는 위험이 있기 때문이죠. (https://byeo.tistory.com/entry/Linux-Kernel-Blocking-IO)

 

이후 SYN이 도착했다면, SYN을 받은 thread가 sk->sk_wq에서 task state를 TASK_RUNNING으로 바꿀 것이고, scheduling함에 따라 schedule_timeout이 return될 것입니다! (나중에 별도 포스트에서 확인예정)

 

 if (!reqsk_queue_emtpy): 깨어났을 때에는 어떠한 상태도 가정할 수 없습니다. 따라서 먼저 icsk_accept_queue가 제대로 있는지 확인합니다. 비었다면 다시 for문을 돌게 되긴 할 것입니다. 

 if (sk->sk_state != TCP_LISTEN): 일어났는데 TCP_STATE가 LISTEN이 아닐 수 있습니다. (별도의 thread에서 listen socket에 대해 close를 해버렸다던가..)

 if (signal_pending(current)): 그리고 task_interruptible이기 때문에, signal에 의해서 깬 것인지 condition 만족에 의해서 깬 것인지 체크를 한 번 해야합니다.

 

finish_wait은 wqit_queue에서 wqit_queue_entry를 제거합니다. 

 

6-2) request socks queue is not empty

 이제 blocking을 끝났든, 처음부터 비어있지 않았든 inet_csk_accept의 다음 부분을 실행합니다.

	req = reqsk_queue_remove(queue, sk);
	newsk = req->sk;

 

reqsk_queue_remove는 다음과 같이 생겼습니다.

 

// include/net/request_sock.h/reqsk_queue_remove() :198

static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue,
						      struct sock *parent)
{
	struct request_sock *req;

	spin_lock_bh(&queue->rskq_lock);
	req = queue->rskq_accept_head;
	if (req) {
		sk_acceptq_removed(parent);
		WRITE_ONCE(queue->rskq_accept_head, req->dl_next);
		if (queue->rskq_accept_head == NULL)
			queue->rskq_accept_tail = NULL;
	}
	spin_unlock_bh(&queue->rskq_lock);
	return req;
}

 

해당 함수는 resq_accept_head의 첫 번째 entry를 가져와서 반환합니다. if안에 있는 sk_acceptq_removed는 listen socket의 backlog를 1 감소킵니다.

 

// include/net/sock.h/sk_acceptq_removed() :934

static inline void sk_acceptq_removed(struct sock *sk)
{
	WRITE_ONCE(sk->sk_ack_backlog, sk->sk_ack_backlog - 1);
}

 

그리고 밑의 WRITE_ONCE(queue->rskq_accept_head, req->dl_next)부터는 linked list에서 head에 있는 entry를 하나 제거해주는 과정이라고 보면 되죠.

 

그 다음으로 (newsk = req->sk;), struct sock에 request_sock 자료구조를 저장합니다. 현재 추측하는 내용으로는 request_sock과 sock 구조체를 SYN이 도착할 때 할당받아 데이터를 채워주고 있을 것으로 보입니다.

 

 

	if (sk->sk_protocol == IPPROTO_TCP &&
	    tcp_rsk(req)->tfo_listener) {
		spin_lock_bh(&queue->fastopenq.lock);
		if (tcp_rsk(req)->tfo_listener) {
			/* We are still waiting for the final ACK from 3WHS
			 * so can't free req now. Instead, we set req->sk to
			 * NULL to signify that the child socket is taken
			 * so reqsk_fastopen_remove() will free the req
			 * when 3WHS finishes (or is aborted).
			 */
			req->sk = NULL;
			req = NULL;
		}
		spin_unlock_bh(&queue->fastopenq.lock);
	}

 

그 아래는 이제 tcp fast open과 관련된 처리를 하는 것으로 보입니다. tcp fast open은 현재 out of scope로 남겨두고 넘어가겠습니다.

 

	if (newsk && mem_cgroup_sockets_enabled) {
		int amt;

		/* atomically get the memory usage, set and charge the
		 * newsk->sk_memcg.
		 */
		lock_sock(newsk);

		/* The socket has not been accepted yet, no need to look at
		 * newsk->sk_wmem_queued.
		 */
		amt = sk_mem_pages(newsk->sk_forward_alloc +
				   atomic_read(&newsk->sk_rmem_alloc));
		mem_cgroup_sk_alloc(newsk);
		if (newsk->sk_memcg && amt)
			mem_cgroup_charge_skmem(newsk->sk_memcg, amt,
						GFP_KERNEL | __GFP_NOFAIL);

		release_sock(newsk);
	}

 

그 다음은, memcg와 관련된 내용입니다. kernel compile시 CONFIG_MEMCG가 set상태라면 실행됩니다. 그렇지 않다면 건너 뜁니다.

 

memcg와 관련된 내용은 다음 사이트를 참조하면 좋을 듯 합니다.

• https://lwn.net/Articles/828909/
• https://junorionblog.co.kr/cgroup-memory-%ec%84%9c%eb%b8%8c%ec%8b%9c%ec%8a%a4%ed%85%9c/\

 

마지막으로 request_sock에 대한 reference count를 1 감소시키고 이 함수를 종료합니다.

 

return value는 request sock에서 보관하고 있던 struct sock *sk를 return합니다.

 

 

현재까지 흐름도