Lines Matching refs:sk
47 struct sock sk; /* must be first member */
92 static void caif_read_lock(struct sock *sk)
95 cf_sk = container_of(sk, struct caifsock, sk);
99 static void caif_read_unlock(struct sock *sk)
102 cf_sk = container_of(sk, struct caifsock, sk);
109 return cf_sk->sk.sk_rcvbuf / 4;
112 static void caif_flow_ctrl(struct sock *sk, int mode)
115 cf_sk = container_of(sk, struct caifsock, sk);
124 static void caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
128 struct sk_buff_head *list = &sk->sk_receive_queue;
129 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
132 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
133 (unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
135 atomic_read(&cf_sk->sk.sk_rmem_alloc),
138 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
141 err = sk_filter(sk, skb);
145 if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {
148 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
151 skb_set_owner_r(skb, sk);
153 queued = !sock_flag(sk, SOCK_DEAD);
159 sk->sk_data_ready(sk);
173 if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
177 caif_queue_rcv_skb(&cf_sk->sk, skb);
184 sock_hold(&cf_sk->sk);
190 sock_put(&cf_sk->sk);
203 cf_sk->sk.sk_state_change(&cf_sk->sk);
209 cf_sk->sk.sk_state_change(&cf_sk->sk);
216 cf_sk->sk.sk_state = CAIF_CONNECTED;
218 cf_sk->sk.sk_shutdown = 0;
219 cf_sk->sk.sk_state_change(&cf_sk->sk);
224 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
225 cf_sk->sk.sk_state_change(&cf_sk->sk);
230 cf_sk->sk.sk_err = ECONNREFUSED;
231 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
232 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
238 cf_sk->sk.sk_state_change(&cf_sk->sk);
243 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
244 cf_sk->sk.sk_err = ECONNRESET;
246 cf_sk->sk.sk_error_report(&cf_sk->sk);
254 static void caif_check_flow_release(struct sock *sk)
256 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
261 if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
263 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ);
275 struct sock *sk = sock->sk;
284 skb = skb_recv_datagram(sk, flags, 0 , &ret);
299 skb_free_datagram(sk, skb);
300 caif_check_flow_release(sk);
309 static long caif_stream_data_wait(struct sock *sk, long timeo)
312 lock_sock(sk);
315 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
317 if (!skb_queue_empty(&sk->sk_receive_queue) ||
318 sk->sk_err ||
319 sk->sk_state != CAIF_CONNECTED ||
320 sock_flag(sk, SOCK_DEAD) ||
321 (sk->sk_shutdown & RCV_SHUTDOWN) ||
326 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
327 release_sock(sk);
329 lock_sock(sk);
331 if (sock_flag(sk, SOCK_DEAD))
334 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
337 finish_wait(sk_sleep(sk), &wait);
338 release_sock(sk);
350 struct sock *sk = sock->sk;
365 if (sk->sk_state == CAIF_CONNECTING)
368 caif_read_lock(sk);
369 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
370 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
376 lock_sock(sk);
377 if (sock_flag(sk, SOCK_DEAD)) {
381 skb = skb_dequeue(&sk->sk_receive_queue);
382 caif_check_flow_release(sk);
390 err = sock_error(sk);
394 if (sk->sk_shutdown & RCV_SHUTDOWN)
398 if (sk->sk_state != CAIF_CONNECTED)
400 if (sock_flag(sk, SOCK_DEAD))
403 release_sock(sk);
409 caif_read_unlock(sk);
411 timeo = caif_stream_data_wait(sk, timeo);
417 caif_read_lock(sk);
420 release_sock(sk);
423 release_sock(sk);
426 skb_queue_head(&sk->sk_receive_queue, skb);
440 skb_queue_head(&sk->sk_receive_queue, skb);
450 skb_queue_head(&sk->sk_receive_queue, skb);
454 caif_read_unlock(sk);
467 struct sock *sk = &cf_sk->sk;
472 (!wait_writeable || sock_writeable(&cf_sk->sk)))
480 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
482 if (sk->sk_shutdown & SHUTDOWN_MASK)
484 *err = -sk->sk_err;
485 if (sk->sk_err)
488 if (cf_sk->sk.sk_state != CAIF_CONNECTED)
492 finish_wait(sk_sleep(sk), &wait);
507 cfpkt_set_prio(pkt, cf_sk->sk.sk_priority);
521 struct sock *sk = sock->sk;
522 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
529 ret = sock_error(sk);
547 timeo = sock_sndtimeo(sk, noblock);
548 timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
554 if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
555 sock_flag(sk, SOCK_DEAD) ||
556 (sk->sk_shutdown & RCV_SHUTDOWN))
561 if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM)
567 skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
597 struct sock *sk = sock->sk;
598 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
611 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
614 if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
625 if (size > ((sk->sk_sndbuf >> 1) - 64))
626 size = (sk->sk_sndbuf >> 1) - 64;
631 skb = sock_alloc_send_skb(sk,
676 struct sock *sk = sock->sk;
677 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
680 if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
691 lock_sock(&(cf_sk->sk));
693 release_sock(&cf_sk->sk);
699 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
701 lock_sock(&(cf_sk->sk));
704 release_sock(&cf_sk->sk);
708 release_sock(&cf_sk->sk);
748 struct sock *sk = sock->sk;
749 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
756 lock_sock(sk);
769 caif_assert(sk->sk_state == CAIF_DISCONNECTED);
772 switch (sk->sk_state) {
788 caif_assert(sk->sk_state == CAIF_CONNECTED ||
789 sk->sk_state == CAIF_DISCONNECTED);
790 if (sk->sk_shutdown & SHUTDOWN_MASK) {
792 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
804 sk->sk_state = CAIF_DISCONNECTED;
806 sk_stream_kill_queues(&cf_sk->sk);
817 sk->sk_state = CAIF_CONNECTING;
821 if (cf_sk->sk.sk_priority > CAIF_PRIO_MAX)
823 else if (cf_sk->sk.sk_priority < CAIF_PRIO_MIN)
826 cf_sk->conn_req.priority = cf_sk->sk.sk_priority;
829 cf_sk->conn_req.ifindex = cf_sk->sk.sk_bound_dev_if;
833 err = caif_connect_client(sock_net(sk), &cf_sk->conn_req,
837 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
838 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
844 dev = dev_get_by_index_rcu(sock_net(sk), ifindex);
864 if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
867 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
869 release_sock(sk);
871 timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
872 sk->sk_state != CAIF_CONNECTING,
874 lock_sock(sk);
879 if (timeo == 0 && sk->sk_state != CAIF_CONNECTED)
881 if (sk->sk_state != CAIF_CONNECTED) {
883 err = sock_error(sk);
891 release_sock(sk);
901 struct sock *sk = sock->sk;
902 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
904 if (!sk)
914 spin_lock_bh(&sk->sk_receive_queue.lock);
915 sock_set_flag(sk, SOCK_DEAD);
916 spin_unlock_bh(&sk->sk_receive_queue.lock);
917 sock->sk = NULL;
922 lock_sock(&(cf_sk->sk));
923 sk->sk_state = CAIF_DISCONNECTED;
924 sk->sk_shutdown = SHUTDOWN_MASK;
926 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
927 cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
928 wake_up_interruptible_poll(sk_sleep(sk), EPOLLERR|EPOLLHUP);
930 sock_orphan(sk);
931 sk_stream_kill_queues(&cf_sk->sk);
932 release_sock(sk);
933 sock_put(sk);
941 struct sock *sk = sock->sk;
943 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
949 if (sk->sk_err)
951 if (sk->sk_shutdown == SHUTDOWN_MASK)
953 if (sk->sk_shutdown & RCV_SHUTDOWN)
957 if (!skb_queue_empty_lockless(&sk->sk_receive_queue) ||
958 (sk->sk_shutdown & RCV_SHUTDOWN))
965 if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
1012 static void caif_sock_destructor(struct sock *sk)
1014 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1015 caif_assert(!refcount_read(&sk->sk_wmem_alloc));
1016 caif_assert(sk_unhashed(sk));
1017 caif_assert(!sk->sk_socket);
1018 if (!sock_flag(sk, SOCK_DEAD)) {
1019 pr_debug("Attempt to release alive CAIF socket: %p\n", sk);
1022 sk_stream_kill_queues(&cf_sk->sk);
1023 WARN_ON(sk->sk_forward_alloc);
1030 struct sock *sk = NULL;
1061 sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot, kern);
1062 if (!sk)
1065 cf_sk = container_of(sk, struct caifsock, sk);
1068 sk->sk_protocol = (unsigned char) protocol;
1073 sk->sk_priority = TC_PRIO_CONTROL;
1076 sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
1079 sk->sk_priority = TC_PRIO_BESTEFFORT;
1086 lock_sock(&(cf_sk->sk));
1089 sock_init_data(sock, sk);
1090 sk->sk_destruct = caif_sock_destructor;
1094 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
1095 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
1103 release_sock(&cf_sk->sk);