2 * Copyright (C) ST-Ericsson AB 2010
3 * Author: Sjur Brendeland sjur.brandeland@stericsson.com
4 * Per Sigmond per.sigmond@stericsson.com
5 * License terms: GNU General Public License (GPL) version 2
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/sched.h>
12 #include <linux/spinlock.h>
13 #include <linux/mutex.h>
14 #include <linux/list.h>
15 #include <linux/wait.h>
16 #include <linux/poll.h>
17 #include <linux/tcp.h>
18 #include <linux/uaccess.h>
19 #include <asm/atomic.h>
21 #include <linux/caif/caif_socket.h>
22 #include <net/caif/caif_layer.h>
23 #include <net/caif/caif_dev.h>
24 #include <net/caif/cfpkt.h>
26 MODULE_LICENSE("GPL");
28 #define CHNL_SKT_READ_QUEUE_HIGH 200
29 #define CHNL_SKT_READ_QUEUE_LOW 100
31 static int caif_sockbuf_size
= 40000;
32 static atomic_t caif_nr_socks
= ATOMIC_INIT(0);
34 #define CONN_STATE_OPEN_BIT 1
35 #define CONN_STATE_PENDING_BIT 2
36 #define CONN_STATE_PEND_DESTROY_BIT 3
37 #define CONN_REMOTE_SHUTDOWN_BIT 4
39 #define TX_FLOW_ON_BIT 1
40 #define RX_FLOW_ON_BIT 2
42 #define STATE_IS_OPEN(cf_sk) test_bit(CONN_STATE_OPEN_BIT,\
43 (void *) &(cf_sk)->conn_state)
44 #define STATE_IS_REMOTE_SHUTDOWN(cf_sk) test_bit(CONN_REMOTE_SHUTDOWN_BIT,\
45 (void *) &(cf_sk)->conn_state)
46 #define STATE_IS_PENDING(cf_sk) test_bit(CONN_STATE_PENDING_BIT,\
47 (void *) &(cf_sk)->conn_state)
48 #define STATE_IS_PENDING_DESTROY(cf_sk) test_bit(CONN_STATE_PEND_DESTROY_BIT,\
49 (void *) &(cf_sk)->conn_state)
51 #define SET_STATE_PENDING_DESTROY(cf_sk) set_bit(CONN_STATE_PEND_DESTROY_BIT,\
52 (void *) &(cf_sk)->conn_state)
53 #define SET_STATE_OPEN(cf_sk) set_bit(CONN_STATE_OPEN_BIT,\
54 (void *) &(cf_sk)->conn_state)
55 #define SET_STATE_CLOSED(cf_sk) clear_bit(CONN_STATE_OPEN_BIT,\
56 (void *) &(cf_sk)->conn_state)
57 #define SET_PENDING_ON(cf_sk) set_bit(CONN_STATE_PENDING_BIT,\
58 (void *) &(cf_sk)->conn_state)
59 #define SET_PENDING_OFF(cf_sk) clear_bit(CONN_STATE_PENDING_BIT,\
60 (void *) &(cf_sk)->conn_state)
61 #define SET_REMOTE_SHUTDOWN(cf_sk) set_bit(CONN_REMOTE_SHUTDOWN_BIT,\
62 (void *) &(cf_sk)->conn_state)
64 #define SET_REMOTE_SHUTDOWN_OFF(dev) clear_bit(CONN_REMOTE_SHUTDOWN_BIT,\
65 (void *) &(dev)->conn_state)
66 #define RX_FLOW_IS_ON(cf_sk) test_bit(RX_FLOW_ON_BIT,\
67 (void *) &(cf_sk)->flow_state)
68 #define TX_FLOW_IS_ON(cf_sk) test_bit(TX_FLOW_ON_BIT,\
69 (void *) &(cf_sk)->flow_state)
71 #define SET_RX_FLOW_OFF(cf_sk) clear_bit(RX_FLOW_ON_BIT,\
72 (void *) &(cf_sk)->flow_state)
73 #define SET_RX_FLOW_ON(cf_sk) set_bit(RX_FLOW_ON_BIT,\
74 (void *) &(cf_sk)->flow_state)
75 #define SET_TX_FLOW_OFF(cf_sk) clear_bit(TX_FLOW_ON_BIT,\
76 (void *) &(cf_sk)->flow_state)
77 #define SET_TX_FLOW_ON(cf_sk) set_bit(TX_FLOW_ON_BIT,\
78 (void *) &(cf_sk)->flow_state)
80 #define SKT_READ_FLAG 0x01
81 #define SKT_WRITE_FLAG 0x02
82 static struct dentry
*debugfsdir
;
83 #include <linux/debugfs.h>
85 #ifdef CONFIG_DEBUG_FS
86 struct debug_fs_counter
{
90 atomic_t num_init_resp
;
91 atomic_t num_init_fail_resp
;
93 atomic_t num_deinit_resp
;
94 atomic_t num_remote_shutdown_ind
;
95 atomic_t num_tx_flow_off_ind
;
96 atomic_t num_tx_flow_on_ind
;
97 atomic_t num_rx_flow_off
;
98 atomic_t num_rx_flow_on
;
103 static struct debug_fs_counter cnt
;
104 #define dbfs_atomic_inc(v) atomic_inc(v)
105 #define dbfs_atomic_dec(v) atomic_dec(v)
107 #define dbfs_atomic_inc(v)
108 #define dbfs_atomic_dec(v)
111 /* The AF_CAIF socket */
113 /* NOTE: sk has to be the first member */
115 struct cflayer layer
;
116 char name
[CAIF_LAYER_NAME_SZ
];
121 struct caif_connect_request conn_req
;
123 /* protect updates of read_queue_len */
124 spinlock_t read_queue_len_lock
;
125 struct dentry
*debugfs_socket_dir
;
128 static void drain_queue(struct caifsock
*cf_sk
);
130 /* Packet Receive Callback function called from CAIF Stack */
131 static int caif_sktrecv_cb(struct cflayer
*layr
, struct cfpkt
*pkt
)
133 struct caifsock
*cf_sk
;
135 cf_sk
= container_of(layr
, struct caifsock
, layer
);
137 if (!STATE_IS_OPEN(cf_sk
)) {
138 /*FIXME: This should be allowed finally!*/
139 pr_debug("CAIF: %s(): called after close request\n", __func__
);
143 /* NOTE: This function may be called in Tasklet context! */
145 /* The queue has its own lock */
146 cfpkt_queue(cf_sk
->pktq
, pkt
, 0);
148 spin_lock(&cf_sk
->read_queue_len_lock
);
149 cf_sk
->read_queue_len
++;
151 read_queue_high
= (cf_sk
->read_queue_len
> CHNL_SKT_READ_QUEUE_HIGH
);
152 spin_unlock(&cf_sk
->read_queue_len_lock
);
154 if (RX_FLOW_IS_ON(cf_sk
) && read_queue_high
) {
155 dbfs_atomic_inc(&cnt
.num_rx_flow_off
);
156 SET_RX_FLOW_OFF(cf_sk
);
158 /* Send flow off (NOTE: must not sleep) */
159 pr_debug("CAIF: %s():"
160 " sending flow OFF (queue len = %d)\n",
162 cf_sk
->read_queue_len
);
163 caif_assert(cf_sk
->layer
.dn
);
164 caif_assert(cf_sk
->layer
.dn
->ctrlcmd
);
166 (void) cf_sk
->layer
.dn
->modemcmd(cf_sk
->layer
.dn
,
167 CAIF_MODEMCMD_FLOW_OFF_REQ
);
170 /* Signal reader that data is available. */
172 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
177 /* Packet Flow Control Callback function called from CAIF */
178 static void caif_sktflowctrl_cb(struct cflayer
*layr
,
179 enum caif_ctrlcmd flow
,
182 struct caifsock
*cf_sk
;
184 /* NOTE: This function may be called in Tasklet context! */
185 pr_debug("CAIF: %s(): flowctrl func called: %s.\n",
187 flow
== CAIF_CTRLCMD_FLOW_ON_IND
? "ON" :
188 flow
== CAIF_CTRLCMD_FLOW_OFF_IND
? "OFF" :
189 flow
== CAIF_CTRLCMD_INIT_RSP
? "INIT_RSP" :
190 flow
== CAIF_CTRLCMD_DEINIT_RSP
? "DEINIT_RSP" :
191 flow
== CAIF_CTRLCMD_INIT_FAIL_RSP
? "INIT_FAIL_RSP" :
193 CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
? "REMOTE_SHUTDOWN" :
194 "UKNOWN CTRL COMMAND");
199 cf_sk
= container_of(layr
, struct caifsock
, layer
);
202 case CAIF_CTRLCMD_FLOW_ON_IND
:
203 dbfs_atomic_inc(&cnt
.num_tx_flow_on_ind
);
204 /* Signal reader that data is available. */
205 SET_TX_FLOW_ON(cf_sk
);
206 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
209 case CAIF_CTRLCMD_FLOW_OFF_IND
:
210 dbfs_atomic_inc(&cnt
.num_tx_flow_off_ind
);
211 SET_TX_FLOW_OFF(cf_sk
);
214 case CAIF_CTRLCMD_INIT_RSP
:
215 dbfs_atomic_inc(&cnt
.num_init_resp
);
216 /* Signal reader that data is available. */
217 caif_assert(STATE_IS_OPEN(cf_sk
));
218 SET_PENDING_OFF(cf_sk
);
219 SET_TX_FLOW_ON(cf_sk
);
220 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
223 case CAIF_CTRLCMD_DEINIT_RSP
:
224 dbfs_atomic_inc(&cnt
.num_deinit_resp
);
225 caif_assert(!STATE_IS_OPEN(cf_sk
));
226 SET_PENDING_OFF(cf_sk
);
227 if (!STATE_IS_PENDING_DESTROY(cf_sk
)) {
228 if (sk_sleep(&cf_sk
->sk
) != NULL
)
229 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
231 dbfs_atomic_inc(&cnt
.num_deinit
);
232 sock_put(&cf_sk
->sk
);
235 case CAIF_CTRLCMD_INIT_FAIL_RSP
:
236 dbfs_atomic_inc(&cnt
.num_init_fail_resp
);
237 caif_assert(STATE_IS_OPEN(cf_sk
));
238 SET_STATE_CLOSED(cf_sk
);
239 SET_PENDING_OFF(cf_sk
);
240 SET_TX_FLOW_OFF(cf_sk
);
241 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
244 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
:
245 dbfs_atomic_inc(&cnt
.num_remote_shutdown_ind
);
246 SET_REMOTE_SHUTDOWN(cf_sk
);
247 /* Use sk_shutdown to indicate remote shutdown indication */
248 cf_sk
->sk
.sk_shutdown
|= RCV_SHUTDOWN
;
249 cf_sk
->file_mode
= 0;
250 wake_up_interruptible(sk_sleep(&cf_sk
->sk
));
254 pr_debug("CAIF: %s(): Unexpected flow command %d\n",
259 static void skb_destructor(struct sk_buff
*skb
)
261 dbfs_atomic_inc(&cnt
.skb_free
);
262 dbfs_atomic_dec(&cnt
.skb_in_use
);
266 static int caif_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
267 struct msghdr
*m
, size_t buf_len
, int flags
)
270 struct sock
*sk
= sock
->sk
;
271 struct caifsock
*cf_sk
= container_of(sk
, struct caifsock
, sk
);
272 struct cfpkt
*pkt
= NULL
;
280 pr_debug("CAIF: %s(): private_data not set!\n",
286 /* Don't do multiple iovec entries yet */
287 if (m
->msg_iovlen
!= 1)
290 if (unlikely(!buf_len
))
293 lock_sock(&(cf_sk
->sk
));
295 caif_assert(cf_sk
->pktq
);
297 if (!STATE_IS_OPEN(cf_sk
)) {
298 /* Socket is closed or closing. */
299 if (!STATE_IS_PENDING(cf_sk
)) {
300 pr_debug("CAIF: %s(): socket is closed (by remote)\n",
304 pr_debug("CAIF: %s(): socket is closing..\n", __func__
);
309 /* Socket is open or opening. */
310 if (STATE_IS_PENDING(cf_sk
)) {
311 pr_debug("CAIF: %s(): socket is opening...\n", __func__
);
313 if (flags
& MSG_DONTWAIT
) {
314 /* We can't block. */
315 pr_debug("CAIF: %s():state pending and MSG_DONTWAIT\n",
322 * Blocking mode; state is pending and we need to wait
323 * for its conclusion.
325 release_sock(&cf_sk
->sk
);
328 wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
329 !STATE_IS_PENDING(cf_sk
));
331 lock_sock(&(cf_sk
->sk
));
333 if (result
== -ERESTARTSYS
) {
334 pr_debug("CAIF: %s(): wait_event_interruptible"
335 " woken by a signal (1)", __func__
);
341 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk
) ||
342 !STATE_IS_OPEN(cf_sk
) ||
343 STATE_IS_PENDING(cf_sk
)) {
345 pr_debug("CAIF: %s(): socket closed\n",
352 * Block if we don't have any received buffers.
353 * The queue has its own lock.
355 while ((pkt
= cfpkt_qpeek(cf_sk
->pktq
)) == NULL
) {
357 if (flags
& MSG_DONTWAIT
) {
358 pr_debug("CAIF: %s(): MSG_DONTWAIT\n", __func__
);
362 trace_printk("CAIF: %s() wait_event\n", __func__
);
364 /* Let writers in. */
365 release_sock(&cf_sk
->sk
);
367 /* Block reader until data arrives or socket is closed. */
368 if (wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
369 cfpkt_qpeek(cf_sk
->pktq
)
370 || STATE_IS_REMOTE_SHUTDOWN(cf_sk
)
371 || !STATE_IS_OPEN(cf_sk
)) ==
373 pr_debug("CAIF: %s():"
374 " wait_event_interruptible woken by "
375 "a signal, signal_pending(current) = %d\n",
377 signal_pending(current
));
381 trace_printk("CAIF: %s() awake\n", __func__
);
382 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk
)) {
383 pr_debug("CAIF: %s(): "
384 "received remote_shutdown indication\n",
387 goto read_error_no_unlock
;
390 /* I want to be alone on cf_sk (except status and queue). */
391 lock_sock(&(cf_sk
->sk
));
393 if (!STATE_IS_OPEN(cf_sk
)) {
394 /* Someone closed the link, report error. */
395 pr_debug("CAIF: %s(): remote end shutdown!\n",
402 /* The queue has its own lock. */
403 len
= cfpkt_getlen(pkt
);
405 /* Check max length that can be copied. */
407 pkt
= cfpkt_dequeue(cf_sk
->pktq
);
409 pr_debug("CAIF: %s(): user buffer too small (%ld,%ld)\n",
410 __func__
, (long) len
, (long) buf_len
);
411 if (sock
->type
== SOCK_SEQPACKET
) {
419 spin_lock(&cf_sk
->read_queue_len_lock
);
420 cf_sk
->read_queue_len
--;
421 read_queue_low
= (cf_sk
->read_queue_len
< CHNL_SKT_READ_QUEUE_LOW
);
422 spin_unlock(&cf_sk
->read_queue_len_lock
);
424 if (!RX_FLOW_IS_ON(cf_sk
) && read_queue_low
) {
425 dbfs_atomic_inc(&cnt
.num_rx_flow_on
);
426 SET_RX_FLOW_ON(cf_sk
);
429 pr_debug("CAIF: %s(): sending flow ON (queue len = %d)\n",
430 __func__
, cf_sk
->read_queue_len
);
431 caif_assert(cf_sk
->layer
.dn
);
432 caif_assert(cf_sk
->layer
.dn
->ctrlcmd
);
433 (void) cf_sk
->layer
.dn
->modemcmd(cf_sk
->layer
.dn
,
434 CAIF_MODEMCMD_FLOW_ON_REQ
);
436 caif_assert(cf_sk
->read_queue_len
>= 0);
439 skb
= cfpkt_tonative(pkt
);
440 result
= skb_copy_datagram_iovec(skb
, 0, m
->msg_iov
, len
);
444 pr_debug("CAIF: %s(): copy to_iovec failed\n", __func__
);
450 /* Free packet and remove from queue */
452 skb_free_datagram(sk
, skb
);
454 /* Let the others in. */
455 release_sock(&cf_sk
->sk
);
459 release_sock(&cf_sk
->sk
);
460 read_error_no_unlock
:
464 /* Send a signal as a consequence of sendmsg, sendto or caif_sendmsg. */
465 static int caif_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
466 struct msghdr
*msg
, size_t len
)
469 struct sock
*sk
= sock
->sk
;
470 struct caifsock
*cf_sk
= container_of(sk
, struct caifsock
, sk
);
471 size_t payload_size
= msg
->msg_iov
->iov_len
;
472 struct cfpkt
*pkt
= NULL
;
473 struct caif_payload_info info
;
474 unsigned char *txbuf
;
478 caif_assert(msg
->msg_iovlen
== 1);
481 pr_debug("CAIF: %s(): private_data not set!\n",
484 goto write_error_no_unlock
;
487 if (unlikely(msg
->msg_iov
->iov_base
== NULL
)) {
488 pr_warning("CAIF: %s(): Buffer is NULL.\n", __func__
);
490 goto write_error_no_unlock
;
493 if (payload_size
> CAIF_MAX_PAYLOAD_SIZE
) {
494 pr_debug("CAIF: %s(): buffer too long\n", __func__
);
495 if (sock
->type
== SOCK_SEQPACKET
) {
497 goto write_error_no_unlock
;
499 payload_size
= CAIF_MAX_PAYLOAD_SIZE
;
502 /* I want to be alone on cf_sk (except status and queue) */
503 lock_sock(&(cf_sk
->sk
));
505 caif_assert(cf_sk
->pktq
);
507 if (!STATE_IS_OPEN(cf_sk
)) {
508 /* Socket is closed or closing */
509 if (!STATE_IS_PENDING(cf_sk
)) {
510 pr_debug("CAIF: %s(): socket is closed (by remote)\n",
514 pr_debug("CAIF: %s(): socket is closing...\n",
521 /* Socket is open or opening */
522 if (STATE_IS_PENDING(cf_sk
)) {
523 pr_debug("CAIF: %s(): socket is opening...\n", __func__
);
525 if (msg
->msg_flags
& MSG_DONTWAIT
) {
527 trace_printk("CAIF: %s():state pending:"
528 "state=MSG_DONTWAIT\n", __func__
);
533 release_sock(&cf_sk
->sk
);
536 * Blocking mode; state is pending and we need to wait
537 * for its conclusion.
540 wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
541 !STATE_IS_PENDING(cf_sk
));
542 /* I want to be alone on cf_sk (except status and queue) */
543 lock_sock(&(cf_sk
->sk
));
545 if (result
== -ERESTARTSYS
) {
546 pr_debug("CAIF: %s(): wait_event_interruptible"
547 " woken by a signal (1)", __func__
);
552 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk
) ||
553 !STATE_IS_OPEN(cf_sk
) ||
554 STATE_IS_PENDING(cf_sk
)) {
556 pr_debug("CAIF: %s(): socket closed\n",
562 if (!TX_FLOW_IS_ON(cf_sk
)) {
564 /* Flow is off. Check non-block flag */
565 if (msg
->msg_flags
& MSG_DONTWAIT
) {
566 trace_printk("CAIF: %s(): MSG_DONTWAIT and tx flow off",
572 /* release lock before waiting */
573 release_sock(&cf_sk
->sk
);
575 /* Wait until flow is on or socket is closed */
576 if (wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
578 || !STATE_IS_OPEN(cf_sk
)
579 || STATE_IS_REMOTE_SHUTDOWN(cf_sk
)
581 pr_debug("CAIF: %s():"
582 " wait_event_interruptible woken by a signal",
585 goto write_error_no_unlock
;
588 /* I want to be alone on cf_sk (except status and queue) */
589 lock_sock(&(cf_sk
->sk
));
591 if (!STATE_IS_OPEN(cf_sk
)) {
592 /* someone closed the link, report error */
593 pr_debug("CAIF: %s(): remote end shutdown!\n",
599 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk
)) {
600 pr_debug("CAIF: %s(): "
601 "received remote_shutdown indication\n",
608 pkt
= cfpkt_create(payload_size
);
609 skb
= (struct sk_buff
*)pkt
;
610 skb
->destructor
= skb_destructor
;
612 dbfs_atomic_inc(&cnt
.skb_alloc
);
613 dbfs_atomic_inc(&cnt
.skb_in_use
);
614 if (cfpkt_raw_append(pkt
, (void **) &txbuf
, payload_size
) < 0) {
615 pr_debug("CAIF: %s(): cfpkt_raw_append failed\n", __func__
);
621 /* Copy data into buffer. */
622 if (copy_from_user(txbuf
, msg
->msg_iov
->iov_base
, payload_size
)) {
623 pr_debug("CAIF: %s(): copy_from_user returned non zero.\n",
629 memset(&info
, 0, sizeof(info
));
631 /* Send the packet down the stack. */
632 caif_assert(cf_sk
->layer
.dn
);
633 caif_assert(cf_sk
->layer
.dn
->transmit
);
636 ret
= cf_sk
->layer
.dn
->transmit(cf_sk
->layer
.dn
, pkt
);
638 if (likely((ret
>= 0) || (ret
!= -EAGAIN
)))
642 if (msg
->msg_flags
& MSG_DONTWAIT
) {
643 pr_debug("CAIF: %s(): NONBLOCK and transmit failed,"
644 " error = %ld\n", __func__
, (long) ret
);
650 release_sock(&cf_sk
->sk
);
652 /* Wait until flow is on or socket is closed */
653 if (wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
655 || !STATE_IS_OPEN(cf_sk
)
656 || STATE_IS_REMOTE_SHUTDOWN(cf_sk
)
658 pr_debug("CAIF: %s(): wait_event_interruptible"
659 " woken by a signal", __func__
);
661 goto write_error_no_unlock
;
664 /* I want to be alone on cf_sk (except status and queue) */
665 lock_sock(&(cf_sk
->sk
));
667 } while (ret
== -EAGAIN
);
671 pr_debug("CAIF: %s(): transmit failed, error = %ld\n",
672 __func__
, (long) ret
);
677 release_sock(&cf_sk
->sk
);
681 release_sock(&cf_sk
->sk
);
682 write_error_no_unlock
:
686 static unsigned int caif_poll(struct file
*file
, struct socket
*sock
,
689 struct sock
*sk
= sock
->sk
;
690 struct caifsock
*cf_sk
= container_of(sk
, struct caifsock
, sk
);
692 poll_wait(file
, sk_sleep(sk
), wait
);
693 lock_sock(&(cf_sk
->sk
));
694 if (!STATE_IS_OPEN(cf_sk
)) {
695 if (!STATE_IS_PENDING(cf_sk
))
698 if (cfpkt_qpeek(cf_sk
->pktq
) != NULL
)
699 mask
|= (POLLIN
| POLLRDNORM
);
700 if (TX_FLOW_IS_ON(cf_sk
))
701 mask
|= (POLLOUT
| POLLWRNORM
);
703 release_sock(&cf_sk
->sk
);
704 trace_printk("CAIF: %s(): poll mask=0x%04x\n",
709 static void drain_queue(struct caifsock
*cf_sk
)
711 struct cfpkt
*pkt
= NULL
;
713 /* Empty the queue */
715 /* The queue has its own lock */
719 pkt
= cfpkt_dequeue(cf_sk
->pktq
);
722 pr_debug("CAIF: %s(): freeing packet from read queue\n",
728 cf_sk
->read_queue_len
= 0;
731 static int setsockopt(struct socket
*sock
,
732 int lvl
, int opt
, char __user
*ov
, unsigned int ol
)
734 struct sock
*sk
= sock
->sk
;
735 struct caifsock
*cf_sk
= container_of(sk
, struct caifsock
, sk
);
739 if (STATE_IS_OPEN(cf_sk
)) {
740 pr_debug("CAIF: %s(): setsockopt "
741 "cannot be done on a connected socket\n",
746 case CAIFSO_LINK_SELECT
:
747 if (ol
< sizeof(int)) {
748 pr_debug("CAIF: %s(): setsockopt"
749 " CAIFSO_CHANNEL_CONFIG bad size\n", __func__
);
754 if (copy_from_user(&linksel
, ov
, sizeof(int)))
756 lock_sock(&(cf_sk
->sk
));
757 cf_sk
->conn_req
.link_selector
= linksel
;
758 release_sock(&cf_sk
->sk
);
762 if (lvl
!= SOL_SOCKET
)
764 if (ol
< sizeof(int)) {
765 pr_debug("CAIF: %s(): setsockopt"
766 " SO_PRIORITY bad size\n", __func__
);
769 if (copy_from_user(&prio
, ov
, sizeof(int)))
771 lock_sock(&(cf_sk
->sk
));
772 cf_sk
->conn_req
.priority
= prio
;
773 pr_debug("CAIF: %s(): Setting sockopt priority=%d\n", __func__
,
774 cf_sk
->conn_req
.priority
);
775 release_sock(&cf_sk
->sk
);
778 case SO_BINDTODEVICE
:
779 if (lvl
!= SOL_SOCKET
)
781 if (ol
< sizeof(struct ifreq
)) {
782 pr_debug("CAIF: %s(): setsockopt"
783 " SO_PRIORITY bad size\n", __func__
);
786 if (copy_from_user(&ifreq
, ov
, sizeof(ifreq
)))
788 lock_sock(&(cf_sk
->sk
));
789 strncpy(cf_sk
->conn_req
.link_name
, ifreq
.ifr_name
,
790 sizeof(cf_sk
->conn_req
.link_name
));
791 cf_sk
->conn_req
.link_name
792 [sizeof(cf_sk
->conn_req
.link_name
)-1] = 0;
793 release_sock(&cf_sk
->sk
);
796 case CAIFSO_REQ_PARAM
:
799 if (cf_sk
->sk
.sk_protocol
!= CAIFPROTO_UTIL
)
801 if (ol
> sizeof(cf_sk
->conn_req
.param
.data
))
802 goto req_param_bad_size
;
804 lock_sock(&(cf_sk
->sk
));
805 cf_sk
->conn_req
.param
.size
= ol
;
806 if (copy_from_user(&cf_sk
->conn_req
.param
.data
, ov
, ol
)) {
807 release_sock(&cf_sk
->sk
);
809 pr_debug("CAIF: %s(): setsockopt"
810 " CAIFSO_CHANNEL_CONFIG bad size\n", __func__
);
814 release_sock(&cf_sk
->sk
);
818 pr_debug("CAIF: %s(): unhandled option %d\n", __func__
, opt
);
824 pr_debug("CAIF: %s(): setsockopt bad level\n", __func__
);
829 static int caif_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
830 int sockaddr_len
, int flags
)
832 struct caifsock
*cf_sk
= NULL
;
836 struct sock
*sk
= sock
->sk
;
839 cf_sk
= container_of(sk
, struct caifsock
, sk
);
841 trace_printk("CAIF: %s(): cf_sk=%p OPEN=%d, TX_FLOW=%d, RX_FLOW=%d\n",
843 STATE_IS_OPEN(cf_sk
),
844 TX_FLOW_IS_ON(cf_sk
), RX_FLOW_IS_ON(cf_sk
));
847 if (sock
->type
== SOCK_SEQPACKET
|| sock
->type
== SOCK_STREAM
)
848 sock
->state
= SS_CONNECTING
;
852 /* I want to be alone on cf_sk (except status and queue) */
853 lock_sock(&(cf_sk
->sk
));
855 if (sockaddr_len
!= sizeof(struct sockaddr_caif
)) {
856 pr_debug("CAIF: %s(): Bad address len (%ld,%lu)\n",
857 __func__
, (long) sockaddr_len
,
858 (long unsigned) sizeof(struct sockaddr_caif
));
863 if (uservaddr
->sa_family
!= AF_CAIF
) {
864 pr_debug("CAIF: %s(): Bad address family (%d)\n",
865 __func__
, uservaddr
->sa_family
);
870 memcpy(&cf_sk
->conn_req
.sockaddr
, uservaddr
,
871 sizeof(struct sockaddr_caif
));
873 dbfs_atomic_inc(&cnt
.num_open
);
874 mode
= SKT_READ_FLAG
| SKT_WRITE_FLAG
;
876 /* If socket is not open, make sure socket is in fully closed state */
877 if (!STATE_IS_OPEN(cf_sk
)) {
878 /* Has link close response been received (if we ever sent it)?*/
879 if (STATE_IS_PENDING(cf_sk
)) {
881 * Still waiting for close response from remote.
882 * If opened non-blocking, report "would block"
884 if (flags
& O_NONBLOCK
) {
885 pr_debug("CAIF: %s(): O_NONBLOCK"
886 " && close pending\n", __func__
);
891 pr_debug("CAIF: %s(): Wait for close response"
892 " from remote...\n", __func__
);
894 release_sock(&cf_sk
->sk
);
897 * Blocking mode; close is pending and we need to wait
898 * for its conclusion.
901 wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
902 !STATE_IS_PENDING(cf_sk
));
904 lock_sock(&(cf_sk
->sk
));
905 if (result
== -ERESTARTSYS
) {
906 pr_debug("CAIF: %s(): wait_event_interruptible"
907 "woken by a signal (1)", __func__
);
914 /* socket is now either closed, pending open or open */
915 if (STATE_IS_OPEN(cf_sk
) && !STATE_IS_PENDING(cf_sk
)) {
917 pr_debug("CAIF: %s(): Socket is already opened (cf_sk=%p)"
918 " check access f_flags = 0x%x file_mode = 0x%x\n",
919 __func__
, cf_sk
, mode
, cf_sk
->file_mode
);
922 /* We are closed or pending open.
923 * If closed: send link setup
924 * If pending open: link setup already sent (we could have been
925 * interrupted by a signal last time)
927 if (!STATE_IS_OPEN(cf_sk
)) {
928 /* First opening of file; connect lower layers: */
929 /* Drain queue (very unlikely) */
932 cf_sk
->layer
.receive
= caif_sktrecv_cb
;
933 SET_STATE_OPEN(cf_sk
);
934 SET_PENDING_ON(cf_sk
);
936 /* Register this channel. */
938 caif_connect_client(&cf_sk
->conn_req
,
941 pr_debug("CAIF: %s(): can't register channel\n",
944 SET_STATE_CLOSED(cf_sk
);
945 SET_PENDING_OFF(cf_sk
);
948 dbfs_atomic_inc(&cnt
.num_init
);
951 /* If opened non-blocking, report "success".
953 if (flags
& O_NONBLOCK
) {
954 pr_debug("CAIF: %s(): O_NONBLOCK success\n",
957 cf_sk
->sk
.sk_err
= -EINPROGRESS
;
961 trace_printk("CAIF: %s(): Wait for connect response\n",
964 /* release lock before waiting */
965 release_sock(&cf_sk
->sk
);
968 wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
969 !STATE_IS_PENDING(cf_sk
));
971 lock_sock(&(cf_sk
->sk
));
973 if (result
== -ERESTARTSYS
) {
974 pr_debug("CAIF: %s(): wait_event_interruptible"
975 "woken by a signal (2)", __func__
);
980 if (!STATE_IS_OPEN(cf_sk
)) {
981 /* Lower layers said "no" */
982 pr_debug("CAIF: %s(): Closed received\n", __func__
);
987 trace_printk("CAIF: %s(): Connect received\n", __func__
);
990 cf_sk
->file_mode
|= mode
;
992 trace_printk("CAIF: %s(): Connected - file mode = %x\n",
993 __func__
, cf_sk
->file_mode
);
995 release_sock(&cf_sk
->sk
);
998 sock
->state
= SS_UNCONNECTED
;
999 release_sock(&cf_sk
->sk
);
1004 static int caif_shutdown(struct socket
*sock
, int how
)
1006 struct caifsock
*cf_sk
= NULL
;
1008 int tx_flow_state_was_on
;
1009 struct sock
*sk
= sock
->sk
;
1011 trace_printk("CAIF: %s(): enter\n", __func__
);
1012 pr_debug("f_flags=%x\n", sock
->file
->f_flags
);
1014 if (how
!= SHUT_RDWR
)
1017 cf_sk
= container_of(sk
, struct caifsock
, sk
);
1018 if (cf_sk
== NULL
) {
1019 pr_debug("CAIF: %s(): COULD NOT FIND SOCKET\n", __func__
);
1023 /* I want to be alone on cf_sk (except status queue) */
1024 lock_sock(&(cf_sk
->sk
));
1025 sock_hold(&cf_sk
->sk
);
1027 /* IS_CLOSED have double meaning:
1028 * 1) Spontanous Remote Shutdown Request.
1029 * 2) Ack on a channel teardown(disconnect)
1030 * Must clear bit in case we previously received
1031 * remote shudown request.
1033 if (STATE_IS_OPEN(cf_sk
) && !STATE_IS_PENDING(cf_sk
)) {
1034 SET_STATE_CLOSED(cf_sk
);
1035 SET_PENDING_ON(cf_sk
);
1036 tx_flow_state_was_on
= TX_FLOW_IS_ON(cf_sk
);
1037 SET_TX_FLOW_OFF(cf_sk
);
1039 /* Hold the socket until DEINIT_RSP is received */
1040 sock_hold(&cf_sk
->sk
);
1041 result
= caif_disconnect_client(&cf_sk
->layer
);
1044 pr_debug("CAIF: %s(): "
1045 "caif_disconnect_client() failed\n",
1047 SET_STATE_CLOSED(cf_sk
);
1048 SET_PENDING_OFF(cf_sk
);
1049 SET_TX_FLOW_OFF(cf_sk
);
1050 release_sock(&cf_sk
->sk
);
1051 sock_put(&cf_sk
->sk
);
1056 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk
)) {
1057 SET_PENDING_OFF(cf_sk
);
1058 SET_REMOTE_SHUTDOWN_OFF(cf_sk
);
1062 * Socket is no longer in state pending close,
1063 * and we can release the reference.
1066 dbfs_atomic_inc(&cnt
.num_close
);
1068 SET_RX_FLOW_ON(cf_sk
);
1069 cf_sk
->file_mode
= 0;
1070 sock_put(&cf_sk
->sk
);
1071 release_sock(&cf_sk
->sk
);
1072 if (!result
&& (sock
->file
->f_flags
& O_NONBLOCK
)) {
1073 pr_debug("nonblocking shutdown returing -EAGAIN\n");
1079 static ssize_t
caif_sock_no_sendpage(struct socket
*sock
,
1081 int offset
, size_t size
, int flags
)
1086 /* This function is called as part of close. */
1087 static int caif_release(struct socket
*sock
)
1089 struct sock
*sk
= sock
->sk
;
1090 struct caifsock
*cf_sk
= NULL
;
1092 caif_assert(sk
!= NULL
);
1093 cf_sk
= container_of(sk
, struct caifsock
, sk
);
1095 if (cf_sk
->debugfs_socket_dir
!= NULL
)
1096 debugfs_remove_recursive(cf_sk
->debugfs_socket_dir
);
1098 res
= caif_shutdown(sock
, SHUT_RDWR
);
1099 if (res
&& res
!= -EINPROGRESS
)
1103 * FIXME: Shutdown should probably be possible to do async
1104 * without flushing queues, allowing reception of frames while
1105 * waiting for DEINIT_IND.
1106 * Release should always block, to allow secure decoupling of
1109 if (!(sock
->file
->f_flags
& O_NONBLOCK
)) {
1110 res
= wait_event_interruptible(*sk_sleep(&cf_sk
->sk
),
1111 !STATE_IS_PENDING(cf_sk
));
1113 if (res
== -ERESTARTSYS
) {
1114 pr_debug("CAIF: %s(): wait_event_interruptible"
1115 "woken by a signal (1)", __func__
);
1118 lock_sock(&(cf_sk
->sk
));
1122 /* Detach the socket from its process context by making it orphan. */
1126 * Setting SHUTDOWN_MASK means that both send and receive are shutdown
1129 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1132 * Set the socket state to closed, the TCP_CLOSE macro is used when
1133 * closing any socket.
1136 /* Flush out this sockets receive queue. */
1139 /* Finally release the socket. */
1140 SET_STATE_PENDING_DESTROY(cf_sk
);
1142 release_sock(&cf_sk
->sk
);
1147 * The rest of the cleanup will be handled from the
1148 * caif_sock_destructor
1153 static const struct proto_ops caif_ops
= {
1155 .owner
= THIS_MODULE
,
1156 .release
= caif_release
,
1157 .bind
= sock_no_bind
,
1158 .connect
= caif_connect
,
1159 .socketpair
= sock_no_socketpair
,
1160 .accept
= sock_no_accept
,
1161 .getname
= sock_no_getname
,
1163 .ioctl
= sock_no_ioctl
,
1164 .listen
= sock_no_listen
,
1165 .shutdown
= caif_shutdown
,
1166 .setsockopt
= setsockopt
,
1167 .getsockopt
= sock_no_getsockopt
,
1168 .sendmsg
= caif_sendmsg
,
1169 .recvmsg
= caif_recvmsg
,
1170 .mmap
= sock_no_mmap
,
1171 .sendpage
= caif_sock_no_sendpage
,
1174 /* This function is called when a socket is finally destroyed. */
1175 static void caif_sock_destructor(struct sock
*sk
)
1177 struct caifsock
*cf_sk
= NULL
;
1178 cf_sk
= container_of(sk
, struct caifsock
, sk
);
1180 caif_assert(!atomic_read(&sk
->sk_wmem_alloc
));
1181 caif_assert(sk_unhashed(sk
));
1182 caif_assert(!sk
->sk_socket
);
1183 if (!sock_flag(sk
, SOCK_DEAD
)) {
1184 pr_debug("CAIF: %s(): 0x%p", __func__
, sk
);
1188 if (STATE_IS_OPEN(cf_sk
)) {
1189 pr_debug("CAIF: %s(): socket is opened (cf_sk=%p)"
1190 " file_mode = 0x%x\n", __func__
,
1191 cf_sk
, cf_sk
->file_mode
);
1197 trace_printk("CAIF: %s(): caif_sock_destructor: Removing socket %s\n",
1198 __func__
, cf_sk
->name
);
1199 atomic_dec(&caif_nr_socks
);
1202 static int caif_create(struct net
*net
, struct socket
*sock
, int protocol
,
1205 struct sock
*sk
= NULL
;
1206 struct caifsock
*cf_sk
= NULL
;
1208 static struct proto prot
= {.name
= "PF_CAIF",
1209 .owner
= THIS_MODULE
,
1210 .obj_size
= sizeof(struct caifsock
),
1214 * The sock->type specifies the socket type to use.
1215 * in SEQPACKET mode packet boundaries are enforced.
1217 if (sock
->type
!= SOCK_SEQPACKET
&& sock
->type
!= SOCK_STREAM
)
1218 return -ESOCKTNOSUPPORT
;
1220 if (net
!= &init_net
)
1221 return -EAFNOSUPPORT
;
1223 if (protocol
< 0 || protocol
>= CAIFPROTO_MAX
)
1224 return -EPROTONOSUPPORT
;
1226 * Set the socket state to unconnected. The socket state is really
1227 * not used at all in the net/core or socket.c but the
1228 * initialization makes sure that sock->state is not uninitialized.
1230 sock
->state
= SS_UNCONNECTED
;
1232 sk
= sk_alloc(net
, PF_CAIF
, GFP_KERNEL
, &prot
);
1236 cf_sk
= container_of(sk
, struct caifsock
, sk
);
1238 /* Store the protocol */
1239 sk
->sk_protocol
= (unsigned char) protocol
;
1241 spin_lock_init(&cf_sk
->read_queue_len_lock
);
1243 /* Fill in some information concerning the misc socket. */
1244 snprintf(cf_sk
->name
, sizeof(cf_sk
->name
), "cf_sk%d",
1245 atomic_read(&caif_nr_socks
));
1248 * Lock in order to try to stop someone from opening the socket
1251 lock_sock(&(cf_sk
->sk
));
1253 /* Initialize the nozero default sock structure data. */
1254 sock_init_data(sock
, sk
);
1255 sock
->ops
= &caif_ops
;
1256 sk
->sk_destruct
= caif_sock_destructor
;
1257 sk
->sk_sndbuf
= caif_sockbuf_size
;
1258 sk
->sk_rcvbuf
= caif_sockbuf_size
;
1260 cf_sk
->pktq
= cfpktq_create();
1263 pr_err("CAIF: %s(): queue create failed.\n", __func__
);
1265 release_sock(&cf_sk
->sk
);
1268 cf_sk
->layer
.ctrlcmd
= caif_sktflowctrl_cb
;
1269 SET_STATE_CLOSED(cf_sk
);
1270 SET_PENDING_OFF(cf_sk
);
1271 SET_TX_FLOW_OFF(cf_sk
);
1272 SET_RX_FLOW_ON(cf_sk
);
1274 /* Set default options on configuration */
1275 cf_sk
->conn_req
.priority
= CAIF_PRIO_NORMAL
;
1276 cf_sk
->conn_req
.link_selector
= CAIF_LINK_HIGH_BANDW
;
1277 cf_sk
->conn_req
.protocol
= protocol
;
1278 /* Increase the number of sockets created. */
1279 atomic_inc(&caif_nr_socks
);
1280 if (!IS_ERR(debugfsdir
)) {
1281 cf_sk
->debugfs_socket_dir
=
1282 debugfs_create_dir(cf_sk
->name
, debugfsdir
);
1283 debugfs_create_u32("conn_state", S_IRUSR
| S_IWUSR
,
1284 cf_sk
->debugfs_socket_dir
, &cf_sk
->conn_state
);
1285 debugfs_create_u32("flow_state", S_IRUSR
| S_IWUSR
,
1286 cf_sk
->debugfs_socket_dir
, &cf_sk
->flow_state
);
1287 debugfs_create_u32("read_queue_len", S_IRUSR
| S_IWUSR
,
1288 cf_sk
->debugfs_socket_dir
,
1289 (u32
*) &cf_sk
->read_queue_len
);
1290 debugfs_create_u32("identity", S_IRUSR
| S_IWUSR
,
1291 cf_sk
->debugfs_socket_dir
,
1292 (u32
*) &cf_sk
->layer
.id
);
1294 release_sock(&cf_sk
->sk
);
1301 static struct net_proto_family caif_family_ops
= {
1303 .create
= caif_create
,
1304 .owner
= THIS_MODULE
,
1307 static int af_caif_init(void)
1310 err
= sock_register(&caif_family_ops
);
1318 static int __init
caif_sktinit_module(void)
1321 #ifdef CONFIG_DEBUG_FS
1322 debugfsdir
= debugfs_create_dir("chnl_skt", NULL
);
1323 if (!IS_ERR(debugfsdir
)) {
1324 debugfs_create_u32("skb_inuse", S_IRUSR
| S_IWUSR
,
1326 (u32
*) &cnt
.skb_in_use
);
1327 debugfs_create_u32("skb_alloc", S_IRUSR
| S_IWUSR
,
1329 (u32
*) &cnt
.skb_alloc
);
1330 debugfs_create_u32("skb_free", S_IRUSR
| S_IWUSR
,
1332 (u32
*) &cnt
.skb_free
);
1333 debugfs_create_u32("num_sockets", S_IRUSR
| S_IWUSR
,
1335 (u32
*) &caif_nr_socks
);
1336 debugfs_create_u32("num_open", S_IRUSR
| S_IWUSR
,
1338 (u32
*) &cnt
.num_open
);
1339 debugfs_create_u32("num_close", S_IRUSR
| S_IWUSR
,
1341 (u32
*) &cnt
.num_close
);
1342 debugfs_create_u32("num_init", S_IRUSR
| S_IWUSR
,
1344 (u32
*) &cnt
.num_init
);
1345 debugfs_create_u32("num_init_resp", S_IRUSR
| S_IWUSR
,
1347 (u32
*) &cnt
.num_init_resp
);
1348 debugfs_create_u32("num_init_fail_resp", S_IRUSR
| S_IWUSR
,
1350 (u32
*) &cnt
.num_init_fail_resp
);
1351 debugfs_create_u32("num_deinit", S_IRUSR
| S_IWUSR
,
1353 (u32
*) &cnt
.num_deinit
);
1354 debugfs_create_u32("num_deinit_resp", S_IRUSR
| S_IWUSR
,
1356 (u32
*) &cnt
.num_deinit_resp
);
1357 debugfs_create_u32("num_remote_shutdown_ind",
1358 S_IRUSR
| S_IWUSR
, debugfsdir
,
1359 (u32
*) &cnt
.num_remote_shutdown_ind
);
1360 debugfs_create_u32("num_tx_flow_off_ind", S_IRUSR
| S_IWUSR
,
1362 (u32
*) &cnt
.num_tx_flow_off_ind
);
1363 debugfs_create_u32("num_tx_flow_on_ind", S_IRUSR
| S_IWUSR
,
1365 (u32
*) &cnt
.num_tx_flow_on_ind
);
1366 debugfs_create_u32("num_rx_flow_off", S_IRUSR
| S_IWUSR
,
1368 (u32
*) &cnt
.num_rx_flow_off
);
1369 debugfs_create_u32("num_rx_flow_on", S_IRUSR
| S_IWUSR
,
1371 (u32
*) &cnt
.num_rx_flow_on
);
1374 stat
= af_caif_init();
1376 pr_err("CAIF: %s(): Failed to initialize CAIF socket layer.",
1383 static void __exit
caif_sktexit_module(void)
1385 sock_unregister(PF_CAIF
);
1386 if (debugfsdir
!= NULL
)
1387 debugfs_remove_recursive(debugfsdir
);
1390 module_init(caif_sktinit_module
);
1391 module_exit(caif_sktexit_module
);