net: sk_sleep() helper
[linux-2.6.git] / net / caif / caif_socket.c
1 /*
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
6  */
7
8 #include <linux/fs.h>
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>
20
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>
25
26 MODULE_LICENSE("GPL");
27
28 #define CHNL_SKT_READ_QUEUE_HIGH 200
29 #define CHNL_SKT_READ_QUEUE_LOW 100
30
31 static int caif_sockbuf_size = 40000;
32 static atomic_t caif_nr_socks = ATOMIC_INIT(0);
33
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
38
39 #define TX_FLOW_ON_BIT                1
40 #define RX_FLOW_ON_BIT                2
41
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)
50
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)
63
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)
70
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)
79
80 #define SKT_READ_FLAG 0x01
81 #define SKT_WRITE_FLAG 0x02
82 static struct dentry *debugfsdir;
83 #include <linux/debugfs.h>
84
85 #ifdef CONFIG_DEBUG_FS
86 struct debug_fs_counter {
87         atomic_t num_open;
88         atomic_t num_close;
89         atomic_t num_init;
90         atomic_t num_init_resp;
91         atomic_t num_init_fail_resp;
92         atomic_t num_deinit;
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;
99         atomic_t skb_in_use;
100         atomic_t skb_alloc;
101         atomic_t skb_free;
102 };
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)
106 #else
107 #define dbfs_atomic_inc(v)
108 #define dbfs_atomic_dec(v)
109 #endif
110
111 /* The AF_CAIF socket */
112 struct caifsock {
113         /* NOTE: sk has to be the first member */
114         struct sock sk;
115         struct cflayer layer;
116         char name[CAIF_LAYER_NAME_SZ];
117         u32 conn_state;
118         u32 flow_state;
119         struct cfpktq *pktq;
120         int file_mode;
121         struct caif_connect_request conn_req;
122         int read_queue_len;
123         /* protect updates of read_queue_len */
124         spinlock_t read_queue_len_lock;
125         struct dentry *debugfs_socket_dir;
126 };
127
128 static void drain_queue(struct caifsock *cf_sk);
129
130 /* Packet Receive Callback function called from CAIF Stack */
131 static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
132 {
133         struct caifsock *cf_sk;
134         int read_queue_high;
135         cf_sk = container_of(layr, struct caifsock, layer);
136
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__);
140                 cfpkt_destroy(pkt);
141                 return 0;
142         }
143         /* NOTE: This function may be called in Tasklet context! */
144
145         /* The queue has its own lock */
146         cfpkt_queue(cf_sk->pktq, pkt, 0);
147
148         spin_lock(&cf_sk->read_queue_len_lock);
149         cf_sk->read_queue_len++;
150
151         read_queue_high = (cf_sk->read_queue_len > CHNL_SKT_READ_QUEUE_HIGH);
152         spin_unlock(&cf_sk->read_queue_len_lock);
153
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);
157
158                 /* Send flow off (NOTE: must not sleep) */
159                 pr_debug("CAIF: %s():"
160                         " sending flow OFF (queue len = %d)\n",
161                         __func__,
162                      cf_sk->read_queue_len);
163                 caif_assert(cf_sk->layer.dn);
164                 caif_assert(cf_sk->layer.dn->ctrlcmd);
165
166                 (void) cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
167                                                CAIF_MODEMCMD_FLOW_OFF_REQ);
168         }
169
170         /* Signal reader that data is available. */
171
172         wake_up_interruptible(cf_sk->sk.sk_sleep);
173
174         return 0;
175 }
176
177 /* Packet Flow Control Callback function called from CAIF */
178 static void caif_sktflowctrl_cb(struct cflayer *layr,
179                                 enum caif_ctrlcmd flow,
180                                 int phyid)
181 {
182         struct caifsock *cf_sk;
183
184         /* NOTE: This function may be called in Tasklet context! */
185         pr_debug("CAIF: %s(): flowctrl func called: %s.\n",
186                       __func__,
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" :
192                       flow ==
193                       CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ? "REMOTE_SHUTDOWN" :
194                       "UKNOWN CTRL COMMAND");
195
196         if (layr == NULL)
197                 return;
198
199         cf_sk = container_of(layr, struct caifsock, layer);
200
201         switch (flow) {
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(cf_sk->sk.sk_sleep);
207                 break;
208
209         case CAIF_CTRLCMD_FLOW_OFF_IND:
210                 dbfs_atomic_inc(&cnt.num_tx_flow_off_ind);
211                 SET_TX_FLOW_OFF(cf_sk);
212                 break;
213
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(cf_sk->sk.sk_sleep);
221                 break;
222
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 (cf_sk->sk.sk_sleep != NULL)
229                                 wake_up_interruptible(cf_sk->sk.sk_sleep);
230                 }
231                 dbfs_atomic_inc(&cnt.num_deinit);
232                 sock_put(&cf_sk->sk);
233                 break;
234
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(cf_sk->sk.sk_sleep);
242                 break;
243
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(cf_sk->sk.sk_sleep);
251                 break;
252
253         default:
254                 pr_debug("CAIF: %s(): Unexpected flow command %d\n",
255                               __func__, flow);
256         }
257 }
258
259 static void skb_destructor(struct sk_buff *skb)
260 {
261         dbfs_atomic_inc(&cnt.skb_free);
262         dbfs_atomic_dec(&cnt.skb_in_use);
263 }
264
265
266 static int caif_recvmsg(struct kiocb *iocb, struct socket *sock,
267                                 struct msghdr *m, size_t buf_len, int flags)
268
269 {
270         struct sock *sk = sock->sk;
271         struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
272         struct cfpkt *pkt = NULL;
273         size_t len;
274         int result;
275         struct sk_buff *skb;
276         ssize_t ret = -EIO;
277         int read_queue_low;
278
279         if (cf_sk == NULL) {
280                 pr_debug("CAIF: %s(): private_data not set!\n",
281                               __func__);
282                 ret = -EBADFD;
283                 goto read_error;
284         }
285
286         /* Don't do multiple iovec entries yet */
287         if (m->msg_iovlen != 1)
288                 return -EOPNOTSUPP;
289
290         if (unlikely(!buf_len))
291                 return -EINVAL;
292
293         lock_sock(&(cf_sk->sk));
294
295         caif_assert(cf_sk->pktq);
296
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",
301                                  __func__);
302                         ret = -EPIPE;
303                 } else {
304                         pr_debug("CAIF: %s(): socket is closing..\n", __func__);
305                         ret = -EBADF;
306                 }
307                 goto read_error;
308         }
309         /* Socket is open or opening. */
310         if (STATE_IS_PENDING(cf_sk)) {
311                 pr_debug("CAIF: %s(): socket is opening...\n", __func__);
312
313                 if (flags & MSG_DONTWAIT) {
314                         /* We can't block. */
315                         pr_debug("CAIF: %s():state pending and MSG_DONTWAIT\n",
316                                  __func__);
317                         ret = -EAGAIN;
318                         goto read_error;
319                 }
320
321                 /*
322                  * Blocking mode; state is pending and we need to wait
323                  * for its conclusion.
324                  */
325                 release_sock(&cf_sk->sk);
326
327                 result =
328                     wait_event_interruptible(*cf_sk->sk.sk_sleep,
329                                              !STATE_IS_PENDING(cf_sk));
330
331                 lock_sock(&(cf_sk->sk));
332
333                 if (result == -ERESTARTSYS) {
334                         pr_debug("CAIF: %s(): wait_event_interruptible"
335                                  " woken by a signal (1)", __func__);
336                         ret = -ERESTARTSYS;
337                         goto read_error;
338                 }
339         }
340
341         if (STATE_IS_REMOTE_SHUTDOWN(cf_sk) ||
342                 !STATE_IS_OPEN(cf_sk) ||
343                 STATE_IS_PENDING(cf_sk)) {
344
345                 pr_debug("CAIF: %s(): socket closed\n",
346                         __func__);
347                 ret = -ESHUTDOWN;
348                 goto read_error;
349         }
350
351         /*
352          * Block if we don't have any received buffers.
353          * The queue has its own lock.
354          */
355         while ((pkt = cfpkt_qpeek(cf_sk->pktq)) == NULL) {
356
357                 if (flags & MSG_DONTWAIT) {
358                         pr_debug("CAIF: %s(): MSG_DONTWAIT\n", __func__);
359                         ret = -EAGAIN;
360                         goto read_error;
361                 }
362                 trace_printk("CAIF: %s() wait_event\n", __func__);
363
364                 /* Let writers in. */
365                 release_sock(&cf_sk->sk);
366
367                 /* Block reader until data arrives or socket is closed. */
368                 if (wait_event_interruptible(*cf_sk->sk.sk_sleep,
369                                         cfpkt_qpeek(cf_sk->pktq)
370                                         || STATE_IS_REMOTE_SHUTDOWN(cf_sk)
371                                         || !STATE_IS_OPEN(cf_sk)) ==
372                     -ERESTARTSYS) {
373                         pr_debug("CAIF: %s():"
374                                 " wait_event_interruptible woken by "
375                                 "a signal, signal_pending(current) = %d\n",
376                                 __func__,
377                                 signal_pending(current));
378                         return -ERESTARTSYS;
379                 }
380
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",
385                                  __func__);
386                         ret = -ESHUTDOWN;
387                         goto read_error_no_unlock;
388                 }
389
390                 /* I want to be alone on cf_sk (except status and queue). */
391                 lock_sock(&(cf_sk->sk));
392
393                 if (!STATE_IS_OPEN(cf_sk)) {
394                         /* Someone closed the link, report error. */
395                         pr_debug("CAIF: %s(): remote end shutdown!\n",
396                                       __func__);
397                         ret = -EPIPE;
398                         goto read_error;
399                 }
400         }
401
402         /* The queue has its own lock. */
403         len = cfpkt_getlen(pkt);
404
405         /* Check max length that can be copied. */
406         if (len <= buf_len)
407                 pkt = cfpkt_dequeue(cf_sk->pktq);
408         else {
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) {
412                         ret = -EMSGSIZE;
413                         goto read_error;
414                 }
415                 len = buf_len;
416         }
417
418
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);
423
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);
427
428                 /* Send flow on. */
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);
435
436                 caif_assert(cf_sk->read_queue_len >= 0);
437         }
438
439         skb = cfpkt_tonative(pkt);
440         result = skb_copy_datagram_iovec(skb, 0, m->msg_iov, len);
441         skb_pull(skb, len);
442
443         if (result) {
444                 pr_debug("CAIF: %s(): copy to_iovec failed\n", __func__);
445                 cfpkt_destroy(pkt);
446                 ret = -EFAULT;
447                 goto read_error;
448         }
449
450         /* Free packet and remove from queue */
451         if (skb->len == 0)
452                 skb_free_datagram(sk, skb);
453
454         /* Let the others in. */
455         release_sock(&cf_sk->sk);
456         return len;
457
458 read_error:
459         release_sock(&cf_sk->sk);
460 read_error_no_unlock:
461         return ret;
462 }
463
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)
467 {
468
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;
475         ssize_t ret = -EIO;
476         int result;
477         struct sk_buff *skb;
478         caif_assert(msg->msg_iovlen == 1);
479
480         if (cf_sk == NULL) {
481                 pr_debug("CAIF: %s(): private_data not set!\n",
482                               __func__);
483                 ret = -EBADFD;
484                 goto write_error_no_unlock;
485         }
486
487         if (unlikely(msg->msg_iov->iov_base == NULL)) {
488                 pr_warning("CAIF: %s(): Buffer is NULL.\n", __func__);
489                 ret = -EINVAL;
490                 goto write_error_no_unlock;
491         }
492
493         if (payload_size > CAIF_MAX_PAYLOAD_SIZE) {
494                 pr_debug("CAIF: %s(): buffer too long\n", __func__);
495                 if (sock->type == SOCK_SEQPACKET) {
496                         ret = -EINVAL;
497                         goto write_error_no_unlock;
498                 }
499                 payload_size = CAIF_MAX_PAYLOAD_SIZE;
500         }
501
502         /* I want to be alone on cf_sk (except status and queue) */
503         lock_sock(&(cf_sk->sk));
504
505         caif_assert(cf_sk->pktq);
506
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",
511                                  __func__);
512                         ret = -EPIPE;
513                 } else {
514                         pr_debug("CAIF: %s(): socket is closing...\n",
515                                  __func__);
516                         ret = -EBADF;
517                 }
518                 goto write_error;
519         }
520
521         /* Socket is open or opening */
522         if (STATE_IS_PENDING(cf_sk)) {
523                 pr_debug("CAIF: %s(): socket is opening...\n", __func__);
524
525                 if (msg->msg_flags & MSG_DONTWAIT) {
526                         /* We can't block */
527                         trace_printk("CAIF: %s():state pending:"
528                                      "state=MSG_DONTWAIT\n", __func__);
529                         ret = -EAGAIN;
530                         goto write_error;
531                 }
532                 /* Let readers in */
533                 release_sock(&cf_sk->sk);
534
535                 /*
536                  * Blocking mode; state is pending and we need to wait
537                  * for its conclusion.
538                  */
539                 result =
540                     wait_event_interruptible(*cf_sk->sk.sk_sleep,
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));
544
545                 if (result == -ERESTARTSYS) {
546                         pr_debug("CAIF: %s(): wait_event_interruptible"
547                                  " woken by a signal (1)", __func__);
548                         ret = -ERESTARTSYS;
549                         goto write_error;
550                 }
551         }
552         if (STATE_IS_REMOTE_SHUTDOWN(cf_sk) ||
553                 !STATE_IS_OPEN(cf_sk) ||
554                 STATE_IS_PENDING(cf_sk)) {
555
556                 pr_debug("CAIF: %s(): socket closed\n",
557                         __func__);
558                 ret = -ESHUTDOWN;
559                 goto write_error;
560         }
561
562         if (!TX_FLOW_IS_ON(cf_sk)) {
563
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",
567                                  __func__);
568                         ret = -EAGAIN;
569                         goto write_error;
570                 }
571
572                 /* release lock before waiting */
573                 release_sock(&cf_sk->sk);
574
575                 /* Wait until flow is on or socket is closed */
576                 if (wait_event_interruptible(*cf_sk->sk.sk_sleep,
577                                         TX_FLOW_IS_ON(cf_sk)
578                                         || !STATE_IS_OPEN(cf_sk)
579                                         || STATE_IS_REMOTE_SHUTDOWN(cf_sk)
580                                         ) == -ERESTARTSYS) {
581                         pr_debug("CAIF: %s():"
582                                  " wait_event_interruptible woken by a signal",
583                                  __func__);
584                         ret = -ERESTARTSYS;
585                         goto write_error_no_unlock;
586                 }
587
588                 /* I want to be alone on cf_sk (except status and queue) */
589                 lock_sock(&(cf_sk->sk));
590
591                 if (!STATE_IS_OPEN(cf_sk)) {
592                         /* someone closed the link, report error */
593                         pr_debug("CAIF: %s(): remote end shutdown!\n",
594                                       __func__);
595                         ret = -EPIPE;
596                         goto write_error;
597                 }
598
599                 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk)) {
600                         pr_debug("CAIF: %s(): "
601                                  "received remote_shutdown indication\n",
602                                  __func__);
603                         ret = -ESHUTDOWN;
604                         goto write_error;
605                 }
606         }
607
608         pkt = cfpkt_create(payload_size);
609         skb = (struct sk_buff *)pkt;
610         skb->destructor = skb_destructor;
611         skb->sk = sk;
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__);
616                 cfpkt_destroy(pkt);
617                 ret = -EINVAL;
618                 goto write_error;
619         }
620
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",
624                          __func__);
625                 cfpkt_destroy(pkt);
626                 ret = -EINVAL;
627                 goto write_error;
628         }
629         memset(&info, 0, sizeof(info));
630
631         /* Send the packet down the stack. */
632         caif_assert(cf_sk->layer.dn);
633         caif_assert(cf_sk->layer.dn->transmit);
634
635         do {
636                 ret = cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
637
638                 if (likely((ret >= 0) || (ret != -EAGAIN)))
639                         break;
640
641                 /* EAGAIN - retry */
642                 if (msg->msg_flags & MSG_DONTWAIT) {
643                         pr_debug("CAIF: %s(): NONBLOCK and transmit failed,"
644                                  " error = %ld\n", __func__, (long) ret);
645                         ret = -EAGAIN;
646                         goto write_error;
647                 }
648
649                 /* Let readers in */
650                 release_sock(&cf_sk->sk);
651
652                 /* Wait until flow is on or socket is closed */
653                 if (wait_event_interruptible(*cf_sk->sk.sk_sleep,
654                                         TX_FLOW_IS_ON(cf_sk)
655                                         || !STATE_IS_OPEN(cf_sk)
656                                         || STATE_IS_REMOTE_SHUTDOWN(cf_sk)
657                                         ) == -ERESTARTSYS) {
658                         pr_debug("CAIF: %s(): wait_event_interruptible"
659                                  " woken by a signal", __func__);
660                         ret = -ERESTARTSYS;
661                         goto write_error_no_unlock;
662                 }
663
664                 /* I want to be alone on cf_sk (except status and queue) */
665                 lock_sock(&(cf_sk->sk));
666
667         } while (ret == -EAGAIN);
668
669         if (ret < 0) {
670                 cfpkt_destroy(pkt);
671                 pr_debug("CAIF: %s(): transmit failed, error = %ld\n",
672                          __func__, (long) ret);
673
674                 goto write_error;
675         }
676
677         release_sock(&cf_sk->sk);
678         return payload_size;
679
680 write_error:
681         release_sock(&cf_sk->sk);
682 write_error_no_unlock:
683         return ret;
684 }
685
686 static unsigned int caif_poll(struct file *file, struct socket *sock,
687                                                 poll_table *wait)
688 {
689         struct sock *sk = sock->sk;
690         struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
691         u32 mask = 0;
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))
696                         mask |= POLLHUP;
697         } else {
698                 if (cfpkt_qpeek(cf_sk->pktq) != NULL)
699                         mask |= (POLLIN | POLLRDNORM);
700                 if (TX_FLOW_IS_ON(cf_sk))
701                         mask |= (POLLOUT | POLLWRNORM);
702         }
703         release_sock(&cf_sk->sk);
704         trace_printk("CAIF: %s(): poll mask=0x%04x\n",
705                       __func__, mask);
706         return mask;
707 }
708
709 static void drain_queue(struct caifsock *cf_sk)
710 {
711         struct cfpkt *pkt = NULL;
712
713         /* Empty the queue */
714         do {
715                 /* The queue has its own lock */
716                 if (!cf_sk->pktq)
717                         break;
718
719                 pkt = cfpkt_dequeue(cf_sk->pktq);
720                 if (!pkt)
721                         break;
722                 pr_debug("CAIF: %s(): freeing packet from read queue\n",
723                          __func__);
724                 cfpkt_destroy(pkt);
725
726         } while (1);
727
728         cf_sk->read_queue_len = 0;
729 }
730
731 static int setsockopt(struct socket *sock,
732                         int lvl, int opt, char __user *ov, unsigned int ol)
733 {
734         struct sock *sk = sock->sk;
735         struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
736         int prio, linksel;
737         struct ifreq ifreq;
738
739         if (STATE_IS_OPEN(cf_sk)) {
740                 pr_debug("CAIF: %s(): setsockopt "
741                          "cannot be done on a connected socket\n",
742                          __func__);
743                 return -ENOPROTOOPT;
744         }
745         switch (opt) {
746         case CAIFSO_LINK_SELECT:
747                 if (ol < sizeof(int)) {
748                         pr_debug("CAIF: %s(): setsockopt"
749                                  " CAIFSO_CHANNEL_CONFIG bad size\n", __func__);
750                         return -EINVAL;
751                 }
752                 if (lvl != SOL_CAIF)
753                         goto bad_sol;
754                 if (copy_from_user(&linksel, ov, sizeof(int)))
755                         return -EINVAL;
756                 lock_sock(&(cf_sk->sk));
757                 cf_sk->conn_req.link_selector = linksel;
758                 release_sock(&cf_sk->sk);
759                 return 0;
760
761         case SO_PRIORITY:
762                 if (lvl != SOL_SOCKET)
763                         goto bad_sol;
764                 if (ol < sizeof(int)) {
765                         pr_debug("CAIF: %s(): setsockopt"
766                                  " SO_PRIORITY bad size\n", __func__);
767                         return -EINVAL;
768                 }
769                 if (copy_from_user(&prio, ov, sizeof(int)))
770                         return -EINVAL;
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);
776                 return 0;
777
778         case SO_BINDTODEVICE:
779                 if (lvl != SOL_SOCKET)
780                         goto bad_sol;
781                 if (ol < sizeof(struct ifreq)) {
782                         pr_debug("CAIF: %s(): setsockopt"
783                                  " SO_PRIORITY bad size\n", __func__);
784                         return -EINVAL;
785                 }
786                 if (copy_from_user(&ifreq, ov, sizeof(ifreq)))
787                         return -EFAULT;
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);
794                 return 0;
795
796         case CAIFSO_REQ_PARAM:
797                 if (lvl != SOL_CAIF)
798                         goto bad_sol;
799                 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
800                         return -ENOPROTOOPT;
801                 if (ol > sizeof(cf_sk->conn_req.param.data))
802                         goto req_param_bad_size;
803
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);
808 req_param_bad_size:
809                         pr_debug("CAIF: %s(): setsockopt"
810                                  " CAIFSO_CHANNEL_CONFIG bad size\n", __func__);
811                         return -EINVAL;
812                 }
813
814                 release_sock(&cf_sk->sk);
815                 return 0;
816
817         default:
818                 pr_debug("CAIF: %s(): unhandled option %d\n", __func__, opt);
819                 return -EINVAL;
820         }
821
822         return 0;
823 bad_sol:
824         pr_debug("CAIF: %s(): setsockopt bad level\n", __func__);
825         return -ENOPROTOOPT;
826
827 }
828
829 static int caif_connect(struct socket *sock, struct sockaddr *uservaddr,
830                int sockaddr_len, int flags)
831 {
832         struct caifsock *cf_sk = NULL;
833         int result = -1;
834         int mode = 0;
835         int ret = -EIO;
836         struct sock *sk = sock->sk;
837         BUG_ON(sk == NULL);
838
839         cf_sk = container_of(sk, struct caifsock, sk);
840
841         trace_printk("CAIF: %s(): cf_sk=%p OPEN=%d, TX_FLOW=%d, RX_FLOW=%d\n",
842                  __func__, cf_sk,
843                 STATE_IS_OPEN(cf_sk),
844                 TX_FLOW_IS_ON(cf_sk), RX_FLOW_IS_ON(cf_sk));
845
846
847         if (sock->type == SOCK_SEQPACKET || sock->type == SOCK_STREAM)
848                 sock->state     = SS_CONNECTING;
849         else
850                 goto out;
851
852         /* I want to be alone on cf_sk (except status and queue) */
853         lock_sock(&(cf_sk->sk));
854
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));
859                 ret = -EINVAL;
860                 goto open_error;
861         }
862
863         if (uservaddr->sa_family != AF_CAIF) {
864                 pr_debug("CAIF: %s(): Bad address family (%d)\n",
865                          __func__, uservaddr->sa_family);
866                 ret = -EAFNOSUPPORT;
867                 goto open_error;
868         }
869
870         memcpy(&cf_sk->conn_req.sockaddr, uservaddr,
871                 sizeof(struct sockaddr_caif));
872
873         dbfs_atomic_inc(&cnt.num_open);
874         mode = SKT_READ_FLAG | SKT_WRITE_FLAG;
875
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)) {
880                         /*
881                          * Still waiting for close response from remote.
882                          * If opened non-blocking, report "would block"
883                          */
884                         if (flags & O_NONBLOCK) {
885                                 pr_debug("CAIF: %s(): O_NONBLOCK"
886                                         " && close pending\n", __func__);
887                                 ret = -EAGAIN;
888                                 goto open_error;
889                         }
890
891                         pr_debug("CAIF: %s(): Wait for close response"
892                                  " from remote...\n", __func__);
893
894                         release_sock(&cf_sk->sk);
895
896                         /*
897                          * Blocking mode; close is pending and we need to wait
898                          * for its conclusion.
899                          */
900                         result =
901                             wait_event_interruptible(*cf_sk->sk.sk_sleep,
902                                                      !STATE_IS_PENDING(cf_sk));
903
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__);
908                                 ret = -ERESTARTSYS;
909                                 goto open_error;
910                         }
911                 }
912         }
913
914         /* socket is now either closed, pending open or open */
915         if (STATE_IS_OPEN(cf_sk) && !STATE_IS_PENDING(cf_sk)) {
916                 /* Open */
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);
920
921         } else {
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)
926                  */
927                 if (!STATE_IS_OPEN(cf_sk)) {
928                         /* First opening of file; connect lower layers: */
929                         /* Drain queue (very unlikely) */
930                         drain_queue(cf_sk);
931
932                         cf_sk->layer.receive = caif_sktrecv_cb;
933                         SET_STATE_OPEN(cf_sk);
934                         SET_PENDING_ON(cf_sk);
935
936                         /* Register this channel. */
937                         result =
938                                 caif_connect_client(&cf_sk->conn_req,
939                                                         &cf_sk->layer);
940                         if (result < 0) {
941                                 pr_debug("CAIF: %s(): can't register channel\n",
942                                         __func__);
943                                 ret = -EIO;
944                                 SET_STATE_CLOSED(cf_sk);
945                                 SET_PENDING_OFF(cf_sk);
946                                 goto open_error;
947                         }
948                         dbfs_atomic_inc(&cnt.num_init);
949                 }
950
951                 /* If opened non-blocking, report "success".
952                  */
953                 if (flags & O_NONBLOCK) {
954                         pr_debug("CAIF: %s(): O_NONBLOCK success\n",
955                                  __func__);
956                         ret = -EINPROGRESS;
957                         cf_sk->sk.sk_err = -EINPROGRESS;
958                         goto open_error;
959                 }
960
961                 trace_printk("CAIF: %s(): Wait for connect response\n",
962                              __func__);
963
964                 /* release lock before waiting */
965                 release_sock(&cf_sk->sk);
966
967                 result =
968                     wait_event_interruptible(*cf_sk->sk.sk_sleep,
969                                              !STATE_IS_PENDING(cf_sk));
970
971                 lock_sock(&(cf_sk->sk));
972
973                 if (result == -ERESTARTSYS) {
974                         pr_debug("CAIF: %s(): wait_event_interruptible"
975                                  "woken by a signal (2)", __func__);
976                         ret = -ERESTARTSYS;
977                         goto open_error;
978                 }
979
980                 if (!STATE_IS_OPEN(cf_sk)) {
981                         /* Lower layers said "no" */
982                         pr_debug("CAIF: %s(): Closed received\n", __func__);
983                         ret = -EPIPE;
984                         goto open_error;
985                 }
986
987                 trace_printk("CAIF: %s(): Connect received\n", __func__);
988         }
989         /* Open is ok */
990         cf_sk->file_mode |= mode;
991
992         trace_printk("CAIF: %s(): Connected - file mode = %x\n",
993                   __func__, cf_sk->file_mode);
994
995         release_sock(&cf_sk->sk);
996         return 0;
997 open_error:
998         sock->state     = SS_UNCONNECTED;
999         release_sock(&cf_sk->sk);
1000 out:
1001         return ret;
1002 }
1003
1004 static int caif_shutdown(struct socket *sock, int how)
1005 {
1006         struct caifsock *cf_sk = NULL;
1007         int result = 0;
1008         int tx_flow_state_was_on;
1009         struct sock *sk = sock->sk;
1010
1011         trace_printk("CAIF: %s(): enter\n", __func__);
1012         pr_debug("f_flags=%x\n", sock->file->f_flags);
1013
1014         if (how != SHUT_RDWR)
1015                 return -EOPNOTSUPP;
1016
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__);
1020                 return -EBADF;
1021         }
1022
1023         /* I want to be alone on cf_sk (except status queue) */
1024         lock_sock(&(cf_sk->sk));
1025         sock_hold(&cf_sk->sk);
1026
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.
1032          */
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);
1038
1039                 /* Hold the socket until DEINIT_RSP is received */
1040                 sock_hold(&cf_sk->sk);
1041                 result = caif_disconnect_client(&cf_sk->layer);
1042
1043                 if (result < 0) {
1044                         pr_debug("CAIF: %s(): "
1045                                         "caif_disconnect_client() failed\n",
1046                                          __func__);
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);
1052                         return -EIO;
1053                 }
1054
1055         }
1056         if (STATE_IS_REMOTE_SHUTDOWN(cf_sk)) {
1057                 SET_PENDING_OFF(cf_sk);
1058                 SET_REMOTE_SHUTDOWN_OFF(cf_sk);
1059         }
1060
1061         /*
1062          * Socket is no longer in state pending close,
1063          * and we can release the reference.
1064          */
1065
1066         dbfs_atomic_inc(&cnt.num_close);
1067         drain_queue(cf_sk);
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");
1074                 return -EAGAIN;
1075         } else
1076                 return result;
1077 }
1078
1079 static ssize_t caif_sock_no_sendpage(struct socket *sock,
1080                                      struct page *page,
1081                                      int offset, size_t size, int flags)
1082 {
1083         return -EOPNOTSUPP;
1084 }
1085
1086 /* This function is called as part of close. */
1087 static int caif_release(struct socket *sock)
1088 {
1089         struct sock *sk = sock->sk;
1090         struct caifsock *cf_sk = NULL;
1091         int res;
1092         caif_assert(sk != NULL);
1093         cf_sk = container_of(sk, struct caifsock, sk);
1094
1095         if (cf_sk->debugfs_socket_dir != NULL)
1096                 debugfs_remove_recursive(cf_sk->debugfs_socket_dir);
1097
1098         res = caif_shutdown(sock, SHUT_RDWR);
1099         if (res && res != -EINPROGRESS)
1100                 return res;
1101
1102         /*
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
1107          * CAIF stack.
1108          */
1109         if (!(sock->file->f_flags & O_NONBLOCK)) {
1110                 res = wait_event_interruptible(*cf_sk->sk.sk_sleep,
1111                                                 !STATE_IS_PENDING(cf_sk));
1112
1113                 if (res == -ERESTARTSYS) {
1114                         pr_debug("CAIF: %s(): wait_event_interruptible"
1115                                 "woken by a signal (1)", __func__);
1116                 }
1117         }
1118         lock_sock(&(cf_sk->sk));
1119
1120         sock->sk = NULL;
1121
1122         /* Detach the socket from its process context by making it orphan. */
1123         sock_orphan(sk);
1124
1125         /*
1126          * Setting SHUTDOWN_MASK means that both send and receive are shutdown
1127          * for the socket.
1128          */
1129         sk->sk_shutdown = SHUTDOWN_MASK;
1130
1131         /*
1132          * Set the socket state to closed, the TCP_CLOSE macro is used when
1133          * closing any socket.
1134          */
1135
1136         /* Flush out this sockets receive queue. */
1137         drain_queue(cf_sk);
1138
1139         /* Finally release the socket. */
1140         SET_STATE_PENDING_DESTROY(cf_sk);
1141
1142         release_sock(&cf_sk->sk);
1143
1144         sock_put(sk);
1145
1146         /*
1147          * The rest of the cleanup will be handled from the
1148          * caif_sock_destructor
1149          */
1150         return res;
1151 }
1152
1153 static const struct proto_ops caif_ops = {
1154         .family = PF_CAIF,
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,
1162         .poll = caif_poll,
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,
1172 };
1173
1174 /* This function is called when a socket is finally destroyed. */
1175 static void caif_sock_destructor(struct sock *sk)
1176 {
1177         struct caifsock *cf_sk = NULL;
1178         cf_sk = container_of(sk, struct caifsock, sk);
1179         /* Error checks. */
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);
1185                 return;
1186         }
1187
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);
1192                 return;
1193         }
1194         drain_queue(cf_sk);
1195         kfree(cf_sk->pktq);
1196
1197         trace_printk("CAIF: %s(): caif_sock_destructor: Removing socket %s\n",
1198                 __func__, cf_sk->name);
1199         atomic_dec(&caif_nr_socks);
1200 }
1201
1202 static int caif_create(struct net *net, struct socket *sock, int protocol,
1203                        int kern)
1204 {
1205         struct sock *sk = NULL;
1206         struct caifsock *cf_sk = NULL;
1207         int result = 0;
1208         static struct proto prot = {.name = "PF_CAIF",
1209                 .owner = THIS_MODULE,
1210                 .obj_size = sizeof(struct caifsock),
1211         };
1212
1213         /*
1214          * The sock->type specifies the socket type to use.
1215          * in SEQPACKET mode packet boundaries are enforced.
1216          */
1217         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
1218                 return -ESOCKTNOSUPPORT;
1219
1220         if (net != &init_net)
1221                 return -EAFNOSUPPORT;
1222
1223         if (protocol < 0 || protocol >= CAIFPROTO_MAX)
1224                 return -EPROTONOSUPPORT;
1225         /*
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.
1229          */
1230         sock->state = SS_UNCONNECTED;
1231
1232         sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot);
1233         if (!sk)
1234                 return -ENOMEM;
1235
1236         cf_sk = container_of(sk, struct caifsock, sk);
1237
1238         /* Store the protocol */
1239         sk->sk_protocol = (unsigned char) protocol;
1240
1241         spin_lock_init(&cf_sk->read_queue_len_lock);
1242
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));
1246
1247         /*
1248          * Lock in order to try to stop someone from opening the socket
1249          * too early.
1250          */
1251         lock_sock(&(cf_sk->sk));
1252
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;
1259
1260         cf_sk->pktq = cfpktq_create();
1261
1262         if (!cf_sk->pktq) {
1263                 pr_err("CAIF: %s(): queue create failed.\n", __func__);
1264                 result = -ENOMEM;
1265                 release_sock(&cf_sk->sk);
1266                 goto err_failed;
1267         }
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);
1273
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);
1293         }
1294         release_sock(&cf_sk->sk);
1295         return 0;
1296 err_failed:
1297         sk_free(sk);
1298         return result;
1299 }
1300
1301 static struct net_proto_family caif_family_ops = {
1302         .family = PF_CAIF,
1303         .create = caif_create,
1304         .owner = THIS_MODULE,
1305 };
1306
1307 static int af_caif_init(void)
1308 {
1309         int err;
1310         err = sock_register(&caif_family_ops);
1311
1312         if (!err)
1313                 return err;
1314
1315         return 0;
1316 }
1317
1318 static int __init caif_sktinit_module(void)
1319 {
1320         int stat;
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,
1325                                 debugfsdir,
1326                                 (u32 *) &cnt.skb_in_use);
1327                 debugfs_create_u32("skb_alloc", S_IRUSR | S_IWUSR,
1328                                 debugfsdir,
1329                                 (u32 *) &cnt.skb_alloc);
1330                 debugfs_create_u32("skb_free", S_IRUSR | S_IWUSR,
1331                                 debugfsdir,
1332                                 (u32 *) &cnt.skb_free);
1333                 debugfs_create_u32("num_sockets", S_IRUSR | S_IWUSR,
1334                                 debugfsdir,
1335                                 (u32 *) &caif_nr_socks);
1336                 debugfs_create_u32("num_open", S_IRUSR | S_IWUSR,
1337                                 debugfsdir,
1338                                 (u32 *) &cnt.num_open);
1339                 debugfs_create_u32("num_close", S_IRUSR | S_IWUSR,
1340                                 debugfsdir,
1341                                 (u32 *) &cnt.num_close);
1342                 debugfs_create_u32("num_init", S_IRUSR | S_IWUSR,
1343                                 debugfsdir,
1344                                 (u32 *) &cnt.num_init);
1345                 debugfs_create_u32("num_init_resp", S_IRUSR | S_IWUSR,
1346                                 debugfsdir,
1347                                 (u32 *) &cnt.num_init_resp);
1348                 debugfs_create_u32("num_init_fail_resp", S_IRUSR | S_IWUSR,
1349                                 debugfsdir,
1350                                 (u32 *) &cnt.num_init_fail_resp);
1351                 debugfs_create_u32("num_deinit", S_IRUSR | S_IWUSR,
1352                                 debugfsdir,
1353                                 (u32 *) &cnt.num_deinit);
1354                 debugfs_create_u32("num_deinit_resp", S_IRUSR | S_IWUSR,
1355                                 debugfsdir,
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,
1361                                 debugfsdir,
1362                                 (u32 *) &cnt.num_tx_flow_off_ind);
1363                 debugfs_create_u32("num_tx_flow_on_ind", S_IRUSR | S_IWUSR,
1364                                 debugfsdir,
1365                                 (u32 *) &cnt.num_tx_flow_on_ind);
1366                 debugfs_create_u32("num_rx_flow_off", S_IRUSR | S_IWUSR,
1367                                 debugfsdir,
1368                                 (u32 *) &cnt.num_rx_flow_off);
1369                 debugfs_create_u32("num_rx_flow_on", S_IRUSR | S_IWUSR,
1370                                 debugfsdir,
1371                                 (u32 *) &cnt.num_rx_flow_on);
1372         }
1373 #endif
1374         stat = af_caif_init();
1375         if (stat) {
1376                 pr_err("CAIF: %s(): Failed to initialize CAIF socket layer.",
1377                        __func__);
1378                 return stat;
1379         }
1380         return 0;
1381 }
1382
1383 static void __exit caif_sktexit_module(void)
1384 {
1385         sock_unregister(PF_CAIF);
1386         if (debugfsdir != NULL)
1387                 debugfs_remove_recursive(debugfsdir);
1388 }
1389
1390 module_init(caif_sktinit_module);
1391 module_exit(caif_sktexit_module);