自学教程：C++ sock_intr_errno函数代码示例

/** * sk_stream_wait_connect - Wait for a socket to get into the connected state * @sk: sock to wait on * @timeo_p: for how long to wait * * Must be called with the socket locked. */int sk_stream_wait_connect(struct sock *sk, long *timeo_p){	struct task_struct *tsk = current;	DEFINE_WAIT(wait);	int done;	do {		int err = sock_error(sk);		if (err)			return err;		if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))			return -EPIPE;		if (!*timeo_p)			return -EAGAIN;		if (signal_pending(tsk))			return sock_intr_errno(*timeo_p);		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);		sk->sk_write_pending++;		done = sk_wait_event(sk, timeo_p,				     !sk->sk_err &&				     !((1 << sk->sk_state) &				       ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));		finish_wait(sk_sleep(sk), &wait);		sk->sk_write_pending--;	} while (!done);	return 0;}

static int pep_wait_connreq(struct sock *sk, int noblock){	struct task_struct *tsk = current;	struct pep_sock *pn = pep_sk(sk);	long timeo = sock_rcvtimeo(sk, noblock);	for (;;) {		DEFINE_WAIT(wait);		if (sk->sk_state != TCP_LISTEN)			return -EINVAL;		if (!hlist_empty(&pn->ackq))			break;		if (!timeo)			return -EWOULDBLOCK;		if (signal_pending(tsk))			return sock_intr_errno(timeo);		prepare_to_wait_exclusive(sk_sleep(sk), &wait,						TASK_INTERRUPTIBLE);		release_sock(sk);		timeo = schedule_timeout(timeo);		lock_sock(sk);		finish_wait(sk_sleep(sk), &wait);	}	return 0;}

/* * wait for space to appear in the transmit/ACK window * - caller holds the socket locked */static int rxrpc_wait_for_tx_window(struct rxrpc_sock *rx,				    struct rxrpc_call *call,				    long *timeo){	DECLARE_WAITQUEUE(myself, current);	int ret;	_enter(",{%d},%ld",	       CIRC_SPACE(call->acks_head, call->acks_tail, call->acks_winsz),	       *timeo);	add_wait_queue(&call->tx_waitq, &myself);	for (;;) {		set_current_state(TASK_INTERRUPTIBLE);		ret = 0;		if (CIRC_SPACE(call->acks_head, call->acks_tail,			       call->acks_winsz) > 0)			break;		if (signal_pending(current)) {			ret = sock_intr_errno(*timeo);			break;		}		release_sock(&rx->sk);		*timeo = schedule_timeout(*timeo);		lock_sock(&rx->sk);	}	remove_wait_queue(&call->tx_waitq, &myself);	set_current_state(TASK_RUNNING);	_leave(" = %d", ret);	return ret;}

int sk_stream_wait_memory(struct sock *sk, long *timeo_p){	int err = 0;	long vm_wait = 0;	long current_timeo = *timeo_p;	DEFINE_WAIT(wait);	if (sk_stream_memory_free(sk))		current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;	while (1) {		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);		if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))			goto do_error;		if (!*timeo_p)			goto do_nonblock;		if (signal_pending(current))			goto do_interrupted;		clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);		if (sk_stream_memory_free(sk) && !vm_wait)			break;		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);		sk->sk_write_pending++;		sk_wait_event(sk, &current_timeo, sk->sk_err ||						  (sk->sk_shutdown & SEND_SHUTDOWN) ||						  (sk_stream_memory_free(sk) &&						  !vm_wait));		sk->sk_write_pending--;		if (vm_wait) {			vm_wait -= current_timeo;			current_timeo = *timeo_p;			if (current_timeo != MAX_SCHEDULE_TIMEOUT &&			    (current_timeo -= vm_wait) < 0)				current_timeo = 0;			vm_wait = 0;		}		*timeo_p = current_timeo;	}out:	finish_wait(sk_sleep(sk), &wait);	return err;do_error:	err = -EPIPE;	goto out;do_nonblock:	err = -EAGAIN;	goto out;do_interrupted:	err = sock_intr_errno(*timeo_p);	goto out;}

static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,			     int flags){	DEFINE_WAIT_FUNC(wait, woken_wake_function);	struct sock *sk = sock->sk, *nsk;	long timeo;	int err = 0;	lock_sock_nested(sk, L2CAP_NESTING_PARENT);	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);	BT_DBG("sk %p timeo %ld", sk, timeo);	/* Wait for an incoming connection. (wake-one). */	add_wait_queue_exclusive(sk_sleep(sk), &wait);	while (1) {		if (sk->sk_state != BT_LISTEN) {			err = -EBADFD;			break;		}		nsk = bt_accept_dequeue(sk, newsock);		if (nsk)			break;		if (!timeo) {			err = -EAGAIN;			break;		}		if (signal_pending(current)) {			err = sock_intr_errno(timeo);			break;		}		release_sock(sk);		timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);		lock_sock_nested(sk, L2CAP_NESTING_PARENT);	}	remove_wait_queue(sk_sleep(sk), &wait);	if (err)		goto done;	newsock->state = SS_CONNECTED;	BT_DBG("new socket %p", nsk);done:	release_sock(sk);	return err;}

/* * Wrapper for the above, for allocs of data skbs. We try and get the * whole size thats been asked for (plus 11 bytes of header). If this * fails, then we try for any size over 16 bytes for SOCK_STREAMS. */struct sk_buff *dn_alloc_send_skb(struct sock *sk, size_t *size, int noblock, long timeo, int *err){	int space;	int len;	struct sk_buff *skb = NULL;	*err = 0;	while(skb == NULL) {		if (signal_pending(current)) {			*err = sock_intr_errno(timeo);			break;		}		if (sk->sk_shutdown & SEND_SHUTDOWN) {			*err = EINVAL;			break;		}		if (sk->sk_err)			break;		len = *size + 11;		space = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);		if (space < len) {			if ((sk->sk_socket->type == SOCK_STREAM) &&			    (space >= (16 + 11)))				len = space;		}		if (space < len) {			set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);			if (noblock) {				*err = EWOULDBLOCK;				break;			}			clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);			SOCK_SLEEP_PRE(sk)			if ((sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc)) <			    len)				schedule();			SOCK_SLEEP_POST(sk)			continue;		}		if ((skb = dn_alloc_skb(sk, len, sk->sk_allocation)) == NULL)			continue;		*size = len - 11;	}

/* * Wait for a packet.. */static int wait_for_packet(struct sock *sk, int *err, long *timeo_p){	int error;	DEFINE_WAIT_FUNC(wait, receiver_wake_function);    /*      前面的操作都是初始化wait，为将socket加入wait队列作准备，这部分代码牵涉到进程调度。关于进程调度，我      只是知道一些皮毛，留在以后学习。这里只需要将其看作是一些加入wait队列的准备工作即可，并不影响理解代码      。     */	prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);	/* Socket errors? */	error = sock_error(sk);	if (error)		goto out_err;    /* 一个完备检测。在决定wait和调用wait之间，有数据包到了，那么就不需要wait，所以这里再次检查socket      的队列是否为空 */	if (!skb_queue_empty(&sk->sk_receive_queue))		goto out;	/* Socket shut down? */	/* 完备检测。也许socket无数据包读取，因为socket已经被另外的线程关闭了。这样可以保证关闭socket的时      候，不会导致其他的socket的读写操作被阻塞。*/	if (sk->sk_shutdown & RCV_SHUTDOWN)		goto out_noerr;	/* Sequenced packets can come disconnected.	 * If so we report the problem	 *//* 对于面向连接的socket进行检查。如果是面向连接的socket，如果不是已经建立连接或者正在监听状态的so       cket是不可能有数据包的。不然即出错*/	error = -ENOTCONN;	if (connection_based(sk) &&	    !(sk->sk_state == TCP_ESTABLISHED || sk->sk_state == TCP_LISTEN))		goto out_err;	/* handle signals */	if (signal_pending(current))/* 检查是否有pending的signal，保证阻塞时，进程可以被signal唤醒 */		goto interrupted;	error = 0;	*timeo_p = schedule_timeout(*timeo_p); /* sleep本进程，直至满足唤醒条件或者被信号唤醒
C++ sock_kfree_s函数代码示例
C++ sock_init_data函数代码示例