Lines Matching refs:sk
48 struct sock sk; /* must be first member */
87 static void caif_read_lock(struct sock *sk)
90 cf_sk = container_of(sk, struct caifsock, sk);
94 static void caif_read_unlock(struct sock *sk)
97 cf_sk = container_of(sk, struct caifsock, sk);
104 return cf_sk->sk.sk_rcvbuf / 4;
107 static void caif_flow_ctrl(struct sock *sk, int mode)
110 cf_sk = container_of(sk, struct caifsock, sk);
119 static void caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
123 struct sk_buff_head *list = &sk->sk_receive_queue;
124 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
127 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
128 (unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
130 atomic_read(&cf_sk->sk.sk_rmem_alloc),
133 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
136 err = sk_filter(sk, skb);
140 if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {
143 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
146 skb_set_owner_r(skb, sk);
148 queued = !sock_flag(sk, SOCK_DEAD);
154 sk->sk_data_ready(sk);
168 if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
172 caif_queue_rcv_skb(&cf_sk->sk, skb);
179 sock_hold(&cf_sk->sk);
185 sock_put(&cf_sk->sk);
198 cf_sk->sk.sk_state_change(&cf_sk->sk);
204 cf_sk->sk.sk_state_change(&cf_sk->sk);
211 cf_sk->sk.sk_state = CAIF_CONNECTED;
213 cf_sk->sk.sk_shutdown = 0;
214 cf_sk->sk.sk_state_change(&cf_sk->sk);
219 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
220 cf_sk->sk.sk_state_change(&cf_sk->sk);
225 cf_sk->sk.sk_err = ECONNREFUSED;
226 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
227 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
233 cf_sk->sk.sk_state_change(&cf_sk->sk);
238 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
239 cf_sk->sk.sk_err = ECONNRESET;
241 sk_error_report(&cf_sk->sk);
249 static void caif_check_flow_release(struct sock *sk)
251 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
256 if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
258 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ);
270 struct sock *sk = sock->sk;
279 skb = skb_recv_datagram(sk, flags, &ret);
294 skb_free_datagram(sk, skb);
295 caif_check_flow_release(sk);
304 static long caif_stream_data_wait(struct sock *sk, long timeo)
307 lock_sock(sk);
310 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
312 if (!skb_queue_empty(&sk->sk_receive_queue) ||
313 sk->sk_err ||
314 sk->sk_state != CAIF_CONNECTED ||
315 sock_flag(sk, SOCK_DEAD) ||
316 (sk->sk_shutdown & RCV_SHUTDOWN) ||
321 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
322 release_sock(sk);
324 lock_sock(sk);
326 if (sock_flag(sk, SOCK_DEAD))
329 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
332 finish_wait(sk_sleep(sk), &wait);
333 release_sock(sk);
345 struct sock *sk = sock->sk;
360 if (sk->sk_state == CAIF_CONNECTING)
363 caif_read_lock(sk);
364 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
365 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
371 lock_sock(sk);
372 if (sock_flag(sk, SOCK_DEAD)) {
376 skb = skb_dequeue(&sk->sk_receive_queue);
377 caif_check_flow_release(sk);
385 err = sock_error(sk);
389 if (sk->sk_shutdown & RCV_SHUTDOWN)
393 if (sk->sk_state != CAIF_CONNECTED)
395 if (sock_flag(sk, SOCK_DEAD))
398 release_sock(sk);
404 caif_read_unlock(sk);
406 timeo = caif_stream_data_wait(sk, timeo);
412 caif_read_lock(sk);
415 release_sock(sk);
418 release_sock(sk);
421 skb_queue_head(&sk->sk_receive_queue, skb);
435 skb_queue_head(&sk->sk_receive_queue, skb);
445 skb_queue_head(&sk->sk_receive_queue, skb);
449 caif_read_unlock(sk);
462 struct sock *sk = &cf_sk->sk;
467 (!wait_writeable || sock_writeable(&cf_sk->sk)))
475 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
477 if (sk->sk_shutdown & SHUTDOWN_MASK)
479 *err = -sk->sk_err;
480 if (sk->sk_err)
483 if (cf_sk->sk.sk_state != CAIF_CONNECTED)
487 finish_wait(sk_sleep(sk), &wait);
502 cfpkt_set_prio(pkt, cf_sk->sk.sk_priority);
516 struct sock *sk = sock->sk;
517 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
524 ret = sock_error(sk);
538 timeo = sock_sndtimeo(sk, noblock);
539 timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
545 if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
546 sock_flag(sk, SOCK_DEAD) ||
547 (sk->sk_shutdown & RCV_SHUTDOWN))
552 if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM)
558 skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
588 struct sock *sk = sock->sk;
589 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
602 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
605 if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
616 if (size > ((sk->sk_sndbuf >> 1) - 64))
617 size = (sk->sk_sndbuf >> 1) - 64;
622 skb = sock_alloc_send_skb(sk,
667 struct sock *sk = sock->sk;
668 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
671 if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
682 lock_sock(&(cf_sk->sk));
684 release_sock(&cf_sk->sk);
690 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
692 lock_sock(&(cf_sk->sk));
695 release_sock(&cf_sk->sk);
699 release_sock(&cf_sk->sk);
739 struct sock *sk = sock->sk;
740 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
747 lock_sock(sk);
760 caif_assert(sk->sk_state == CAIF_DISCONNECTED);
763 switch (sk->sk_state) {
779 caif_assert(sk->sk_state == CAIF_CONNECTED ||
780 sk->sk_state == CAIF_DISCONNECTED);
781 if (sk->sk_shutdown & SHUTDOWN_MASK) {
783 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
795 sk->sk_state = CAIF_DISCONNECTED;
797 sk_stream_kill_queues(&cf_sk->sk);
808 sk->sk_state = CAIF_CONNECTING;
812 if (cf_sk->sk.sk_priority > CAIF_PRIO_MAX)
814 else if (cf_sk->sk.sk_priority < CAIF_PRIO_MIN)
817 cf_sk->conn_req.priority = cf_sk->sk.sk_priority;
820 cf_sk->conn_req.ifindex = cf_sk->sk.sk_bound_dev_if;
824 err = caif_connect_client(sock_net(sk), &cf_sk->conn_req,
828 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
829 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
835 dev = dev_get_by_index_rcu(sock_net(sk), ifindex);
855 if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
858 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
860 release_sock(sk);
862 timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
863 sk->sk_state != CAIF_CONNECTING,
865 lock_sock(sk);
870 if (timeo == 0 && sk->sk_state != CAIF_CONNECTED)
872 if (sk->sk_state != CAIF_CONNECTED) {
874 err = sock_error(sk);
882 release_sock(sk);
892 struct sock *sk = sock->sk;
893 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
895 if (!sk)
905 spin_lock_bh(&sk->sk_receive_queue.lock);
906 sock_set_flag(sk, SOCK_DEAD);
907 spin_unlock_bh(&sk->sk_receive_queue.lock);
908 sock->sk = NULL;
913 lock_sock(&(cf_sk->sk));
914 sk->sk_state = CAIF_DISCONNECTED;
915 sk->sk_shutdown = SHUTDOWN_MASK;
917 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
918 cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
919 wake_up_interruptible_poll(sk_sleep(sk), EPOLLERR|EPOLLHUP);
921 sock_orphan(sk);
922 sk_stream_kill_queues(&cf_sk->sk);
923 release_sock(sk);
924 sock_put(sk);
932 struct sock *sk = sock->sk;
934 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
940 if (sk->sk_err)
942 if (sk->sk_shutdown == SHUTDOWN_MASK)
944 if (sk->sk_shutdown & RCV_SHUTDOWN)
948 if (!skb_queue_empty_lockless(&sk->sk_receive_queue) ||
949 (sk->sk_shutdown & RCV_SHUTDOWN))
956 if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
1001 static void caif_sock_destructor(struct sock *sk)
1003 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1004 caif_assert(!refcount_read(&sk->sk_wmem_alloc));
1005 caif_assert(sk_unhashed(sk));
1006 caif_assert(!sk->sk_socket);
1007 if (!sock_flag(sk, SOCK_DEAD)) {
1008 pr_debug("Attempt to release alive CAIF socket: %p\n", sk);
1011 sk_stream_kill_queues(&cf_sk->sk);
1012 WARN_ON_ONCE(sk->sk_forward_alloc);
1019 struct sock *sk = NULL;
1050 sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot, kern);
1051 if (!sk)
1054 cf_sk = container_of(sk, struct caifsock, sk);
1057 sk->sk_protocol = (unsigned char) protocol;
1062 sk->sk_priority = TC_PRIO_CONTROL;
1065 sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
1068 sk->sk_priority = TC_PRIO_BESTEFFORT;
1075 lock_sock(&(cf_sk->sk));
1078 sock_init_data(sock, sk);
1079 sk->sk_destruct = caif_sock_destructor;
1083 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
1084 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
1092 release_sock(&cf_sk->sk);