aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/linux/caif/caif_socket.h5
-rw-r--r--net/caif/caif_socket.c1795
2 files changed, 831 insertions, 969 deletions
diff --git a/include/linux/caif/caif_socket.h b/include/linux/caif/caif_socket.h
index 8e5c8444a3f4..2a61eb1beb85 100644
--- a/include/linux/caif/caif_socket.h
+++ b/include/linux/caif/caif_socket.h
@@ -16,7 +16,6 @@
16#include <sys/socket.h> 16#include <sys/socket.h>
17#endif 17#endif
18 18
19
20/** 19/**
21 * enum caif_link_selector - Physical Link Selection. 20 * enum caif_link_selector - Physical Link Selection.
22 * @CAIF_LINK_HIGH_BANDW: Physical interface for high-bandwidth 21 * @CAIF_LINK_HIGH_BANDW: Physical interface for high-bandwidth
@@ -59,7 +58,7 @@ enum caif_channel_priority {
59/** 58/**
60 * enum caif_protocol_type - CAIF Channel type. 59 * enum caif_protocol_type - CAIF Channel type.
61 * @CAIFPROTO_AT: Classic AT channel. 60 * @CAIFPROTO_AT: Classic AT channel.
62 * @CAIFPROTO_DATAGRAM: Datagram channel. 61 * @CAIFPROTO_DATAGRAM: Datagram channel.
63 * @CAIFPROTO_DATAGRAM_LOOP: Datagram loopback channel, used for testing. 62 * @CAIFPROTO_DATAGRAM_LOOP: Datagram loopback channel, used for testing.
64 * @CAIFPROTO_UTIL: Utility (Psock) channel. 63 * @CAIFPROTO_UTIL: Utility (Psock) channel.
65 * @CAIFPROTO_RFM: Remote File Manager 64 * @CAIFPROTO_RFM: Remote File Manager
@@ -87,6 +86,7 @@ enum caif_at_type {
87 86
88/** 87/**
89 * struct sockaddr_caif - the sockaddr structure for CAIF sockets. 88 * struct sockaddr_caif - the sockaddr structure for CAIF sockets.
89 * @family: Address family number, must be AF_CAIF.
90 * @u: Union of address data 'switched' by family. 90 * @u: Union of address data 'switched' by family.
91 * : 91 * :
92 * @u.at: Applies when family = CAIFPROTO_AT. 92 * @u.at: Applies when family = CAIFPROTO_AT.
@@ -153,6 +153,7 @@ struct sockaddr_caif {
153 * 153 *
154 * 154 *
155 * This enum defines the CAIF Socket options to be used on a socket 155 * This enum defines the CAIF Socket options to be used on a socket
156 * of type PF_CAIF.
156 * 157 *
157 */ 158 */
158enum caif_socket_opts { 159enum caif_socket_opts {
diff --git a/net/caif/caif_socket.c b/net/caif/caif_socket.c
index d455375789fb..c3a70c5c893a 100644
--- a/net/caif/caif_socket.c
+++ b/net/caif/caif_socket.c
@@ -1,7 +1,6 @@
1/* 1/*
2 * Copyright (C) ST-Ericsson AB 2010 2 * Copyright (C) ST-Ericsson AB 2010
3 * Author: Sjur Brendeland sjur.brandeland@stericsson.com 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 4 * License terms: GNU General Public License (GPL) version 2
6 */ 5 */
7 6
@@ -16,91 +15,52 @@
16#include <linux/poll.h> 15#include <linux/poll.h>
17#include <linux/tcp.h> 16#include <linux/tcp.h>
18#include <linux/uaccess.h> 17#include <linux/uaccess.h>
19#include <asm/atomic.h> 18#include <linux/mutex.h>
20 19#include <linux/debugfs.h>
21#include <linux/caif/caif_socket.h> 20#include <linux/caif/caif_socket.h>
21#include <asm/atomic.h>
22#include <net/sock.h>
23#include <net/tcp_states.h>
22#include <net/caif/caif_layer.h> 24#include <net/caif/caif_layer.h>
23#include <net/caif/caif_dev.h> 25#include <net/caif/caif_dev.h>
24#include <net/caif/cfpkt.h> 26#include <net/caif/cfpkt.h>
25 27
26MODULE_LICENSE("GPL"); 28MODULE_LICENSE("GPL");
29MODULE_ALIAS_NETPROTO(AF_CAIF);
30
31#define CAIF_DEF_SNDBUF (CAIF_MAX_PAYLOAD_SIZE*10)
32#define CAIF_DEF_RCVBUF (CAIF_MAX_PAYLOAD_SIZE*100)
33
34/*
35 * CAIF state is re-using the TCP socket states.
36 * caif_states stored in sk_state reflect the state as reported by
37 * the CAIF stack, while sk_socket->state is the state of the socket.
38 */
39enum caif_states {
40 CAIF_CONNECTED = TCP_ESTABLISHED,
41 CAIF_CONNECTING = TCP_SYN_SENT,
42 CAIF_DISCONNECTED = TCP_CLOSE
43};
44
45#define TX_FLOW_ON_BIT 1
46#define RX_FLOW_ON_BIT 2
27 47
28#define CHNL_SKT_READ_QUEUE_HIGH 200
29#define CHNL_SKT_READ_QUEUE_LOW 100
30
31static int caif_sockbuf_size = 40000;
32static 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
82static struct dentry *debugfsdir; 48static struct dentry *debugfsdir;
83#include <linux/debugfs.h>
84 49
85#ifdef CONFIG_DEBUG_FS 50#ifdef CONFIG_DEBUG_FS
86struct debug_fs_counter { 51struct debug_fs_counter {
87 atomic_t num_open; 52 atomic_t caif_nr_socks;
88 atomic_t num_close; 53 atomic_t num_connect_req;
89 atomic_t num_init; 54 atomic_t num_connect_resp;
90 atomic_t num_init_resp; 55 atomic_t num_connect_fail_resp;
91 atomic_t num_init_fail_resp; 56 atomic_t num_disconnect;
92 atomic_t num_deinit;
93 atomic_t num_deinit_resp;
94 atomic_t num_remote_shutdown_ind; 57 atomic_t num_remote_shutdown_ind;
95 atomic_t num_tx_flow_off_ind; 58 atomic_t num_tx_flow_off_ind;
96 atomic_t num_tx_flow_on_ind; 59 atomic_t num_tx_flow_on_ind;
97 atomic_t num_rx_flow_off; 60 atomic_t num_rx_flow_off;
98 atomic_t num_rx_flow_on; 61 atomic_t num_rx_flow_on;
99 atomic_t skb_in_use;
100 atomic_t skb_alloc;
101 atomic_t skb_free;
102}; 62};
103static struct debug_fs_counter cnt; 63struct debug_fs_counter cnt;
104#define dbfs_atomic_inc(v) atomic_inc(v) 64#define dbfs_atomic_inc(v) atomic_inc(v)
105#define dbfs_atomic_dec(v) atomic_dec(v) 65#define dbfs_atomic_dec(v) atomic_dec(v)
106#else 66#else
@@ -108,624 +68,666 @@ static struct debug_fs_counter cnt;
108#define dbfs_atomic_dec(v) 68#define dbfs_atomic_dec(v)
109#endif 69#endif
110 70
111/* The AF_CAIF socket */
112struct caifsock { 71struct caifsock {
113 /* NOTE: sk has to be the first member */ 72 struct sock sk; /* must be first member */
114 struct sock sk;
115 struct cflayer layer; 73 struct cflayer layer;
116 char name[CAIF_LAYER_NAME_SZ]; 74 char name[CAIF_LAYER_NAME_SZ]; /* Used for debugging */
117 u32 conn_state;
118 u32 flow_state; 75 u32 flow_state;
119 struct cfpktq *pktq;
120 int file_mode;
121 struct caif_connect_request conn_req; 76 struct caif_connect_request conn_req;
122 int read_queue_len; 77 struct mutex readlock;
123 /* protect updates of read_queue_len */
124 spinlock_t read_queue_len_lock;
125 struct dentry *debugfs_socket_dir; 78 struct dentry *debugfs_socket_dir;
126}; 79};
127 80
128static void drain_queue(struct caifsock *cf_sk); 81static int rx_flow_is_on(struct caifsock *cf_sk)
82{
83 return test_bit(RX_FLOW_ON_BIT,
84 (void *) &cf_sk->flow_state);
85}
86
87static int tx_flow_is_on(struct caifsock *cf_sk)
88{
89 return test_bit(TX_FLOW_ON_BIT,
90 (void *) &cf_sk->flow_state);
91}
129 92
130/* Packet Receive Callback function called from CAIF Stack */ 93static void set_rx_flow_off(struct caifsock *cf_sk)
131static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
132{ 94{
133 struct caifsock *cf_sk; 95 clear_bit(RX_FLOW_ON_BIT,
134 int read_queue_high; 96 (void *) &cf_sk->flow_state);
135 cf_sk = container_of(layr, struct caifsock, layer); 97}
136 98
137 if (!STATE_IS_OPEN(cf_sk)) { 99static void set_rx_flow_on(struct caifsock *cf_sk)
138 /*FIXME: This should be allowed finally!*/ 100{
139 pr_debug("CAIF: %s(): called after close request\n", __func__); 101 set_bit(RX_FLOW_ON_BIT,
140 cfpkt_destroy(pkt); 102 (void *) &cf_sk->flow_state);
141 return 0; 103}
142 }
143 /* NOTE: This function may be called in Tasklet context! */
144 104
145 /* The queue has its own lock */ 105static void set_tx_flow_off(struct caifsock *cf_sk)
146 cfpkt_queue(cf_sk->pktq, pkt, 0); 106{
107 clear_bit(TX_FLOW_ON_BIT,
108 (void *) &cf_sk->flow_state);
109}
147 110
148 spin_lock(&cf_sk->read_queue_len_lock); 111static void set_tx_flow_on(struct caifsock *cf_sk)
149 cf_sk->read_queue_len++; 112{
113 set_bit(TX_FLOW_ON_BIT,
114 (void *) &cf_sk->flow_state);
115}
150 116
151 read_queue_high = (cf_sk->read_queue_len > CHNL_SKT_READ_QUEUE_HIGH); 117static void caif_read_lock(struct sock *sk)
152 spin_unlock(&cf_sk->read_queue_len_lock); 118{
119 struct caifsock *cf_sk;
120 cf_sk = container_of(sk, struct caifsock, sk);
121 mutex_lock(&cf_sk->readlock);
122}
153 123
154 if (RX_FLOW_IS_ON(cf_sk) && read_queue_high) { 124static void caif_read_unlock(struct sock *sk)
155 dbfs_atomic_inc(&cnt.num_rx_flow_off); 125{
156 SET_RX_FLOW_OFF(cf_sk); 126 struct caifsock *cf_sk;
127 cf_sk = container_of(sk, struct caifsock, sk);
128 mutex_unlock(&cf_sk->readlock);
129}
157 130
158 /* Send flow off (NOTE: must not sleep) */ 131int sk_rcvbuf_lowwater(struct caifsock *cf_sk)
159 pr_debug("CAIF: %s():" 132{
160 " sending flow OFF (queue len = %d)\n", 133 /* A quarter of full buffer is used a low water mark */
161 __func__, 134 return cf_sk->sk.sk_rcvbuf / 4;
162 cf_sk->read_queue_len); 135}
163 caif_assert(cf_sk->layer.dn);
164 caif_assert(cf_sk->layer.dn->ctrlcmd);
165 136
166 (void) cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, 137void caif_flow_ctrl(struct sock *sk, int mode)
167 CAIF_MODEMCMD_FLOW_OFF_REQ); 138{
168 } 139 struct caifsock *cf_sk;
140 cf_sk = container_of(sk, struct caifsock, sk);
141 if (cf_sk->layer.dn)
142 cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode);
143}
169 144
170 /* Signal reader that data is available. */ 145/*
146 * Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are
147 * not dropped, but CAIF is sending flow off instead.
148 */
149int caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
150{
151 int err;
152 int skb_len;
153 unsigned long flags;
154 struct sk_buff_head *list = &sk->sk_receive_queue;
155 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
171 156
172 wake_up_interruptible(sk_sleep(&cf_sk->sk)); 157 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
158 (unsigned)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
159 trace_printk("CAIF: %s():"
160 " sending flow OFF (queue len = %d %d)\n",
161 __func__,
162 atomic_read(&cf_sk->sk.sk_rmem_alloc),
163 sk_rcvbuf_lowwater(cf_sk));
164 set_rx_flow_off(cf_sk);
165 if (cf_sk->layer.dn)
166 cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
167 CAIF_MODEMCMD_FLOW_OFF_REQ);
168 }
173 169
170 err = sk_filter(sk, skb);
171 if (err)
172 return err;
173 if (!sk_rmem_schedule(sk, skb->truesize) && rx_flow_is_on(cf_sk)) {
174 set_rx_flow_off(cf_sk);
175 trace_printk("CAIF: %s():"
176 " sending flow OFF due to rmem_schedule\n",
177 __func__);
178 if (cf_sk->layer.dn)
179 cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
180 CAIF_MODEMCMD_FLOW_OFF_REQ);
181 }
182 skb->dev = NULL;
183 skb_set_owner_r(skb, sk);
184 /* Cache the SKB length before we tack it onto the receive
185 * queue. Once it is added it no longer belongs to us and
186 * may be freed by other threads of control pulling packets
187 * from the queue.
188 */
189 skb_len = skb->len;
190 spin_lock_irqsave(&list->lock, flags);
191 if (!sock_flag(sk, SOCK_DEAD))
192 __skb_queue_tail(list, skb);
193 spin_unlock_irqrestore(&list->lock, flags);
194
195 if (!sock_flag(sk, SOCK_DEAD))
196 sk->sk_data_ready(sk, skb_len);
197 else
198 kfree_skb(skb);
174 return 0; 199 return 0;
175} 200}
176 201
177/* Packet Flow Control Callback function called from CAIF */ 202/* Packet Receive Callback function called from CAIF Stack */
178static void caif_sktflowctrl_cb(struct cflayer *layr, 203static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
179 enum caif_ctrlcmd flow,
180 int phyid)
181{ 204{
182 struct caifsock *cf_sk; 205 struct caifsock *cf_sk;
183 206 struct sk_buff *skb;
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 207
199 cf_sk = container_of(layr, struct caifsock, layer); 208 cf_sk = container_of(layr, struct caifsock, layer);
209 skb = cfpkt_tonative(pkt);
210
211 if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
212 cfpkt_destroy(pkt);
213 return 0;
214 }
215 caif_queue_rcv_skb(&cf_sk->sk, skb);
216 return 0;
217}
200 218
219/* Packet Control Callback function called from CAIF */
220static void caif_ctrl_cb(struct cflayer *layr,
221 enum caif_ctrlcmd flow,
222 int phyid)
223{
224 struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
201 switch (flow) { 225 switch (flow) {
202 case CAIF_CTRLCMD_FLOW_ON_IND: 226 case CAIF_CTRLCMD_FLOW_ON_IND:
227 /* OK from modem to start sending again */
203 dbfs_atomic_inc(&cnt.num_tx_flow_on_ind); 228 dbfs_atomic_inc(&cnt.num_tx_flow_on_ind);
204 /* Signal reader that data is available. */ 229 set_tx_flow_on(cf_sk);
205 SET_TX_FLOW_ON(cf_sk); 230 cf_sk->sk.sk_state_change(&cf_sk->sk);
206 wake_up_interruptible(sk_sleep(&cf_sk->sk));
207 break; 231 break;
208 232
209 case CAIF_CTRLCMD_FLOW_OFF_IND: 233 case CAIF_CTRLCMD_FLOW_OFF_IND:
234 /* Modem asks us to shut up */
210 dbfs_atomic_inc(&cnt.num_tx_flow_off_ind); 235 dbfs_atomic_inc(&cnt.num_tx_flow_off_ind);
211 SET_TX_FLOW_OFF(cf_sk); 236 set_tx_flow_off(cf_sk);
237 cf_sk->sk.sk_state_change(&cf_sk->sk);
212 break; 238 break;
213 239
214 case CAIF_CTRLCMD_INIT_RSP: 240 case CAIF_CTRLCMD_INIT_RSP:
215 dbfs_atomic_inc(&cnt.num_init_resp); 241 /* We're now connected */
216 /* Signal reader that data is available. */ 242 dbfs_atomic_inc(&cnt.num_connect_resp);
217 caif_assert(STATE_IS_OPEN(cf_sk)); 243 cf_sk->sk.sk_state = CAIF_CONNECTED;
218 SET_PENDING_OFF(cf_sk); 244 set_tx_flow_on(cf_sk);
219 SET_TX_FLOW_ON(cf_sk); 245 cf_sk->sk.sk_state_change(&cf_sk->sk);
220 wake_up_interruptible(sk_sleep(&cf_sk->sk));
221 break; 246 break;
222 247
223 case CAIF_CTRLCMD_DEINIT_RSP: 248 case CAIF_CTRLCMD_DEINIT_RSP:
224 dbfs_atomic_inc(&cnt.num_deinit_resp); 249 /* We're now disconnected */
225 caif_assert(!STATE_IS_OPEN(cf_sk)); 250 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
226 SET_PENDING_OFF(cf_sk); 251 cf_sk->sk.sk_state_change(&cf_sk->sk);
227 if (!STATE_IS_PENDING_DESTROY(cf_sk)) { 252 cfcnfg_release_adap_layer(&cf_sk->layer);
228 if (sk_sleep(&cf_sk->sk) != NULL)
229 wake_up_interruptible(sk_sleep(&cf_sk->sk));
230 }
231 dbfs_atomic_inc(&cnt.num_deinit);
232 sock_put(&cf_sk->sk);
233 break; 253 break;
234 254
235 case CAIF_CTRLCMD_INIT_FAIL_RSP: 255 case CAIF_CTRLCMD_INIT_FAIL_RSP:
236 dbfs_atomic_inc(&cnt.num_init_fail_resp); 256 /* Connect request failed */
237 caif_assert(STATE_IS_OPEN(cf_sk)); 257 dbfs_atomic_inc(&cnt.num_connect_fail_resp);
238 SET_STATE_CLOSED(cf_sk); 258 cf_sk->sk.sk_err = ECONNREFUSED;
239 SET_PENDING_OFF(cf_sk); 259 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
240 SET_TX_FLOW_OFF(cf_sk); 260 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
241 wake_up_interruptible(sk_sleep(&cf_sk->sk)); 261 /*
262 * Socket "standards" seems to require POLLOUT to
263 * be set at connect failure.
264 */
265 set_tx_flow_on(cf_sk);
266 cf_sk->sk.sk_state_change(&cf_sk->sk);
242 break; 267 break;
243 268
244 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: 269 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
270 /* Modem has closed this connection, or device is down. */
245 dbfs_atomic_inc(&cnt.num_remote_shutdown_ind); 271 dbfs_atomic_inc(&cnt.num_remote_shutdown_ind);
246 SET_REMOTE_SHUTDOWN(cf_sk); 272 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
247 /* Use sk_shutdown to indicate remote shutdown indication */ 273 cf_sk->sk.sk_err = ECONNRESET;
248 cf_sk->sk.sk_shutdown |= RCV_SHUTDOWN; 274 set_rx_flow_on(cf_sk);
249 cf_sk->file_mode = 0; 275 cf_sk->sk.sk_error_report(&cf_sk->sk);
250 wake_up_interruptible(sk_sleep(&cf_sk->sk));
251 break; 276 break;
252 277
253 default: 278 default:
254 pr_debug("CAIF: %s(): Unexpected flow command %d\n", 279 pr_debug("CAIF: %s(): Unexpected flow command %d\n",
255 __func__, flow); 280 __func__, flow);
256 } 281 }
257} 282}
258 283
259static void skb_destructor(struct sk_buff *skb) 284static void caif_check_flow_release(struct sock *sk)
260{ 285{
261 dbfs_atomic_inc(&cnt.skb_free); 286 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
262 dbfs_atomic_dec(&cnt.skb_in_use);
263}
264 287
288 if (cf_sk->layer.dn == NULL || cf_sk->layer.dn->modemcmd == NULL)
289 return;
290 if (rx_flow_is_on(cf_sk))
291 return;
265 292
266static int caif_recvmsg(struct kiocb *iocb, struct socket *sock, 293 if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
294 dbfs_atomic_inc(&cnt.num_rx_flow_on);
295 set_rx_flow_on(cf_sk);
296 cf_sk->layer.dn->modemcmd(cf_sk->layer.dn,
297 CAIF_MODEMCMD_FLOW_ON_REQ);
298 }
299}
300/*
301 * Copied from sock.c:sock_queue_rcv_skb(), and added check that user buffer
302 * has sufficient size.
303 */
304
305static int caif_seqpkt_recvmsg(struct kiocb *iocb, struct socket *sock,
267 struct msghdr *m, size_t buf_len, int flags) 306 struct msghdr *m, size_t buf_len, int flags)
268 307
269{ 308{
270 struct sock *sk = sock->sk; 309 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; 310 struct sk_buff *skb;
276 ssize_t ret = -EIO; 311 int ret = 0;
277 int read_queue_low; 312 int len;
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 313
290 if (unlikely(!buf_len)) 314 if (unlikely(!buf_len))
291 return -EINVAL; 315 return -EINVAL;
292 316
293 lock_sock(&(cf_sk->sk)); 317 skb = skb_recv_datagram(sk, flags, 0 , &ret);
294 318 if (!skb)
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; 319 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 320
321 len = skb->len;
322
323 if (skb && skb->len > buf_len && !(flags & MSG_PEEK)) {
324 len = buf_len;
321 /* 325 /*
322 * Blocking mode; state is pending and we need to wait 326 * Push skb back on receive queue if buffer too small.
323 * for its conclusion. 327 * This has a built-in race where multi-threaded receive
328 * may get packet in wrong order, but multiple read does
329 * not really guarantee ordered delivery anyway.
330 * Let's optimize for speed without taking locks.
324 */ 331 */
325 release_sock(&cf_sk->sk);
326
327 result =
328 wait_event_interruptible(*sk_sleep(&cf_sk->sk),
329 !STATE_IS_PENDING(cf_sk));
330 332
331 lock_sock(&(cf_sk->sk)); 333 skb_queue_head(&sk->sk_receive_queue, skb);
332 334 ret = -EMSGSIZE;
333 if (result == -ERESTARTSYS) { 335 goto read_error;
334 pr_debug("CAIF: %s(): wait_event_interruptible"
335 " woken by a signal (1)", __func__);
336 ret = -ERESTARTSYS;
337 goto read_error;
338 }
339 } 336 }
340 337
341 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk) || 338 ret = skb_copy_datagram_iovec(skb, 0, m->msg_iov, len);
342 !STATE_IS_OPEN(cf_sk) || 339 if (ret)
343 STATE_IS_PENDING(cf_sk)) {
344
345 pr_debug("CAIF: %s(): socket closed\n",
346 __func__);
347 ret = -ESHUTDOWN;
348 goto read_error; 340 goto read_error;
349 }
350 341
351 /* 342 skb_free_datagram(sk, skb);
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 343
357 if (flags & MSG_DONTWAIT) { 344 caif_check_flow_release(sk);
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 345
364 /* Let writers in. */ 346 return len;
365 release_sock(&cf_sk->sk);
366 347
367 /* Block reader until data arrives or socket is closed. */ 348read_error:
368 if (wait_event_interruptible(*sk_sleep(&cf_sk->sk), 349 return ret;
369 cfpkt_qpeek(cf_sk->pktq) 350}
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 351
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 352
390 /* I want to be alone on cf_sk (except status and queue). */ 353/* Copied from unix_stream_wait_data, identical except for lock call. */
391 lock_sock(&(cf_sk->sk)); 354static long caif_stream_data_wait(struct sock *sk, long timeo)
355{
356 DEFINE_WAIT(wait);
357 lock_sock(sk);
358
359 for (;;) {
360 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
361
362 if (!skb_queue_empty(&sk->sk_receive_queue) ||
363 sk->sk_err ||
364 sk->sk_state != CAIF_CONNECTED ||
365 sock_flag(sk, SOCK_DEAD) ||
366 (sk->sk_shutdown & RCV_SHUTDOWN) ||
367 signal_pending(current) ||
368 !timeo)
369 break;
392 370
393 if (!STATE_IS_OPEN(cf_sk)) { 371 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
394 /* Someone closed the link, report error. */ 372 release_sock(sk);
395 pr_debug("CAIF: %s(): remote end shutdown!\n", 373 timeo = schedule_timeout(timeo);
396 __func__); 374 lock_sock(sk);
397 ret = -EPIPE; 375 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
398 goto read_error;
399 }
400 } 376 }
401 377
402 /* The queue has its own lock. */ 378 finish_wait(sk_sleep(sk), &wait);
403 len = cfpkt_getlen(pkt); 379 release_sock(sk);
404 380 return timeo;
405 /* Check max length that can be copied. */ 381}
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 382
418 383
419 spin_lock(&cf_sk->read_queue_len_lock); 384/*
420 cf_sk->read_queue_len--; 385 * Copied from unix_stream_recvmsg, but removed credit checks,
421 read_queue_low = (cf_sk->read_queue_len < CHNL_SKT_READ_QUEUE_LOW); 386 * changed locking calls, changed address handling.
422 spin_unlock(&cf_sk->read_queue_len_lock); 387 */
388static int caif_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
389 struct msghdr *msg, size_t size,
390 int flags)
391{
392 struct sock *sk = sock->sk;
393 int copied = 0;
394 int target;
395 int err = 0;
396 long timeo;
423 397
424 if (!RX_FLOW_IS_ON(cf_sk) && read_queue_low) { 398 err = -EOPNOTSUPP;
425 dbfs_atomic_inc(&cnt.num_rx_flow_on); 399 if (flags&MSG_OOB)
426 SET_RX_FLOW_ON(cf_sk); 400 goto out;
427 401
428 /* Send flow on. */ 402 msg->msg_namelen = 0;
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 403
436 caif_assert(cf_sk->read_queue_len >= 0); 404 /*
437 } 405 * Lock the socket to prevent queue disordering
406 * while sleeps in memcpy_tomsg
407 */
408 err = -EAGAIN;
409 if (sk->sk_state == CAIF_CONNECTING)
410 goto out;
438 411
439 skb = cfpkt_tonative(pkt); 412 caif_read_lock(sk);
440 result = skb_copy_datagram_iovec(skb, 0, m->msg_iov, len); 413 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
441 skb_pull(skb, len); 414 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
442 415
443 if (result) { 416 do {
444 pr_debug("CAIF: %s(): copy to_iovec failed\n", __func__); 417 int chunk;
445 cfpkt_destroy(pkt); 418 struct sk_buff *skb;
446 ret = -EFAULT;
447 goto read_error;
448 }
449 419
450 /* Free packet and remove from queue */ 420 lock_sock(sk);
451 if (skb->len == 0) 421 skb = skb_dequeue(&sk->sk_receive_queue);
452 skb_free_datagram(sk, skb); 422 caif_check_flow_release(sk);
453 423
454 /* Let the others in. */ 424 if (skb == NULL) {
455 release_sock(&cf_sk->sk); 425 if (copied >= target)
456 return len; 426 goto unlock;
427 /*
428 * POSIX 1003.1g mandates this order.
429 */
430 err = sock_error(sk);
431 if (err)
432 goto unlock;
433 err = -ECONNRESET;
434 if (sk->sk_shutdown & RCV_SHUTDOWN)
435 goto unlock;
457 436
458read_error: 437 err = -EPIPE;
459 release_sock(&cf_sk->sk); 438 if (sk->sk_state != CAIF_CONNECTED)
460read_error_no_unlock: 439 goto unlock;
461 return ret; 440 if (sock_flag(sk, SOCK_DEAD))
462} 441 goto unlock;
463 442
464/* Send a signal as a consequence of sendmsg, sendto or caif_sendmsg. */ 443 release_sock(sk);
465static int caif_sendmsg(struct kiocb *kiocb, struct socket *sock,
466 struct msghdr *msg, size_t len)
467{
468 444
469 struct sock *sk = sock->sk; 445 err = -EAGAIN;
470 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 446 if (!timeo)
471 size_t payload_size = msg->msg_iov->iov_len; 447 break;
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 448
480 if (cf_sk == NULL) { 449 caif_read_unlock(sk);
481 pr_debug("CAIF: %s(): private_data not set!\n",
482 __func__);
483 ret = -EBADFD;
484 goto write_error_no_unlock;
485 }
486 450
487 if (unlikely(msg->msg_iov->iov_base == NULL)) { 451 timeo = caif_stream_data_wait(sk, timeo);
488 pr_warning("CAIF: %s(): Buffer is NULL.\n", __func__);
489 ret = -EINVAL;
490 goto write_error_no_unlock;
491 }
492 452
493 if (payload_size > CAIF_MAX_PAYLOAD_SIZE) { 453 if (signal_pending(current)) {
494 pr_debug("CAIF: %s(): buffer too long\n", __func__); 454 err = sock_intr_errno(timeo);
495 if (sock->type == SOCK_SEQPACKET) { 455 goto out;
496 ret = -EINVAL; 456 }
497 goto write_error_no_unlock; 457 caif_read_lock(sk);
458 continue;
459unlock:
460 release_sock(sk);
461 break;
498 } 462 }
499 payload_size = CAIF_MAX_PAYLOAD_SIZE; 463 release_sock(sk);
500 } 464 chunk = min_t(unsigned int, skb->len, size);
465 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
466 skb_queue_head(&sk->sk_receive_queue, skb);
467 if (copied == 0)
468 copied = -EFAULT;
469 break;
470 }
471 copied += chunk;
472 size -= chunk;
501 473
502 /* I want to be alone on cf_sk (except status and queue) */ 474 /* Mark read part of skb as used */
503 lock_sock(&(cf_sk->sk)); 475 if (!(flags & MSG_PEEK)) {
476 skb_pull(skb, chunk);
504 477
505 caif_assert(cf_sk->pktq); 478 /* put the skb back if we didn't use it up. */
479 if (skb->len) {
480 skb_queue_head(&sk->sk_receive_queue, skb);
481 break;
482 }
483 kfree_skb(skb);
506 484
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 { 485 } else {
514 pr_debug("CAIF: %s(): socket is closing...\n", 486 /*
515 __func__); 487 * It is questionable, see note in unix_dgram_recvmsg.
516 ret = -EBADF; 488 */
517 } 489 /* put message back and return */
518 goto write_error; 490 skb_queue_head(&sk->sk_receive_queue, skb);
519 } 491 break;
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 } 492 }
532 /* Let readers in */ 493 } while (size);
533 release_sock(&cf_sk->sk); 494 caif_read_unlock(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(*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));
544 495
545 if (result == -ERESTARTSYS) { 496out:
546 pr_debug("CAIF: %s(): wait_event_interruptible" 497 return copied ? : err;
547 " woken by a signal (1)", __func__); 498}
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 499
556 pr_debug("CAIF: %s(): socket closed\n", 500/*
557 __func__); 501 * Copied from sock.c:sock_wait_for_wmem, but change to wait for
558 ret = -ESHUTDOWN; 502 * CAIF flow-on and sock_writable.
559 goto write_error; 503 */
504static long caif_wait_for_flow_on(struct caifsock *cf_sk,
505 int wait_writeable, long timeo, int *err)
506{
507 struct sock *sk = &cf_sk->sk;
508 DEFINE_WAIT(wait);
509 for (;;) {
510 *err = 0;
511 if (tx_flow_is_on(cf_sk) &&
512 (!wait_writeable || sock_writeable(&cf_sk->sk)))
513 break;
514 *err = -ETIMEDOUT;
515 if (!timeo)
516 break;
517 *err = -ERESTARTSYS;
518 if (signal_pending(current))
519 break;
520 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
521 *err = -ECONNRESET;
522 if (sk->sk_shutdown & SHUTDOWN_MASK)
523 break;
524 *err = -sk->sk_err;
525 if (sk->sk_err)
526 break;
527 *err = -EPIPE;
528 if (cf_sk->sk.sk_state != CAIF_CONNECTED)
529 break;
530 timeo = schedule_timeout(timeo);
560 } 531 }
532 finish_wait(sk_sleep(sk), &wait);
533 return timeo;
534}
561 535
562 if (!TX_FLOW_IS_ON(cf_sk)) { 536/*
537 * Transmit a SKB. The device may temporarily request re-transmission
538 * by returning EAGAIN.
539 */
540static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk,
541 int noblock, long timeo)
542{
543 struct cfpkt *pkt;
544 int ret, loopcnt = 0;
563 545
564 /* Flow is off. Check non-block flag */ 546 pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb);
565 if (msg->msg_flags & MSG_DONTWAIT) { 547 memset(cfpkt_info(pkt), 0, sizeof(struct caif_payload_info));
566 trace_printk("CAIF: %s(): MSG_DONTWAIT and tx flow off", 548 do {
567 __func__);
568 ret = -EAGAIN;
569 goto write_error;
570 }
571 549
572 /* release lock before waiting */ 550 ret = -ETIMEDOUT;
573 release_sock(&cf_sk->sk);
574 551
575 /* Wait until flow is on or socket is closed */ 552 /* Slight paranoia, probably not needed. */
576 if (wait_event_interruptible(*sk_sleep(&cf_sk->sk), 553 if (unlikely(loopcnt++ > 1000)) {
577 TX_FLOW_IS_ON(cf_sk) 554 pr_warning("CAIF: %s(): transmit retries failed,"
578 || !STATE_IS_OPEN(cf_sk) 555 " error = %d\n", __func__, ret);
579 || STATE_IS_REMOTE_SHUTDOWN(cf_sk) 556 break;
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 } 557 }
587 558
588 /* I want to be alone on cf_sk (except status and queue) */ 559 if (cf_sk->layer.dn != NULL)
589 lock_sock(&(cf_sk->sk)); 560 ret = cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
590 561 if (likely(ret >= 0))
591 if (!STATE_IS_OPEN(cf_sk)) { 562 break;
592 /* someone closed the link, report error */ 563 /* if transmit return -EAGAIN, then retry */
593 pr_debug("CAIF: %s(): remote end shutdown!\n", 564 if (noblock && ret == -EAGAIN)
594 __func__); 565 break;
595 ret = -EPIPE; 566 timeo = caif_wait_for_flow_on(cf_sk, 0, timeo, &ret);
596 goto write_error; 567 if (signal_pending(current)) {
568 ret = sock_intr_errno(timeo);
569 break;
597 } 570 }
598 571 if (ret)
599 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk)) { 572 break;
600 pr_debug("CAIF: %s(): " 573 if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
601 "received remote_shutdown indication\n", 574 sock_flag(&cf_sk->sk, SOCK_DEAD) ||
602 __func__); 575 (cf_sk->sk.sk_shutdown & RCV_SHUTDOWN)) {
603 ret = -ESHUTDOWN; 576 ret = -EPIPE;
604 goto write_error; 577 cf_sk->sk.sk_err = EPIPE;
578 break;
605 } 579 }
606 } 580 } while (ret == -EAGAIN);
581 return ret;
582}
607 583
608 pkt = cfpkt_create(payload_size); 584/* Copied from af_unix:unix_dgram_sendmsg, and adapted to CAIF */
609 skb = (struct sk_buff *)pkt; 585static int caif_seqpkt_sendmsg(struct kiocb *kiocb, struct socket *sock,
610 skb->destructor = skb_destructor; 586 struct msghdr *msg, size_t len)
611 skb->sk = sk; 587{
612 dbfs_atomic_inc(&cnt.skb_alloc); 588 struct sock *sk = sock->sk;
613 dbfs_atomic_inc(&cnt.skb_in_use); 589 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
614 if (cfpkt_raw_append(pkt, (void **) &txbuf, payload_size) < 0) { 590 int buffer_size;
615 pr_debug("CAIF: %s(): cfpkt_raw_append failed\n", __func__); 591 int ret = 0;
616 cfpkt_destroy(pkt); 592 struct sk_buff *skb = NULL;
617 ret = -EINVAL; 593 int noblock;
618 goto write_error; 594 long timeo;
619 } 595 caif_assert(cf_sk);
596 ret = sock_error(sk);
597 if (ret)
598 goto err;
599
600 ret = -EOPNOTSUPP;
601 if (msg->msg_flags&MSG_OOB)
602 goto err;
603
604 ret = -EOPNOTSUPP;
605 if (msg->msg_namelen)
606 goto err;
607
608 ret = -EINVAL;
609 if (unlikely(msg->msg_iov->iov_base == NULL))
610 goto err;
611 noblock = msg->msg_flags & MSG_DONTWAIT;
612
613 buffer_size = len + CAIF_NEEDED_HEADROOM + CAIF_NEEDED_TAILROOM;
614
615 ret = -EMSGSIZE;
616 if (buffer_size > CAIF_MAX_PAYLOAD_SIZE)
617 goto err;
618
619 timeo = sock_sndtimeo(sk, noblock);
620 timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
621 1, timeo, &ret);
622
623 ret = -EPIPE;
624 if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
625 sock_flag(sk, SOCK_DEAD) ||
626 (sk->sk_shutdown & RCV_SHUTDOWN))
627 goto err;
628
629 ret = -ENOMEM;
630 skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
631 if (!skb)
632 goto err;
633 skb_reserve(skb, CAIF_NEEDED_HEADROOM);
634
635 ret = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
636
637 if (ret)
638 goto err;
639 ret = transmit_skb(skb, cf_sk, noblock, timeo);
640 if (ret < 0)
641 goto err;
642 return len;
643err:
644 kfree_skb(skb);
645 return ret;
646}
620 647
621 /* Copy data into buffer. */ 648/*
622 if (copy_from_user(txbuf, msg->msg_iov->iov_base, payload_size)) { 649 * Copied from unix_stream_sendmsg and adapted to CAIF:
623 pr_debug("CAIF: %s(): copy_from_user returned non zero.\n", 650 * Changed removed permission handling and added waiting for flow on
624 __func__); 651 * and other minor adaptations.
625 cfpkt_destroy(pkt); 652 */
626 ret = -EINVAL; 653static int caif_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
627 goto write_error; 654 struct msghdr *msg, size_t len)
628 } 655{
629 memset(&info, 0, sizeof(info)); 656 struct sock *sk = sock->sk;
657 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
658 int err, size;
659 struct sk_buff *skb;
660 int sent = 0;
661 long timeo;
630 662
631 /* Send the packet down the stack. */ 663 err = -EOPNOTSUPP;
632 caif_assert(cf_sk->layer.dn);
633 caif_assert(cf_sk->layer.dn->transmit);
634 664
635 do { 665 if (unlikely(msg->msg_flags&MSG_OOB))
636 ret = cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt); 666 goto out_err;
637 667
638 if (likely((ret >= 0) || (ret != -EAGAIN))) 668 if (unlikely(msg->msg_namelen))
639 break; 669 goto out_err;
640 670
641 /* EAGAIN - retry */ 671 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
642 if (msg->msg_flags & MSG_DONTWAIT) { 672 timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err);
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 673
649 /* Let readers in */ 674 if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
650 release_sock(&cf_sk->sk); 675 goto pipe_err;
651 676
652 /* Wait until flow is on or socket is closed */ 677 while (sent < len) {
653 if (wait_event_interruptible(*sk_sleep(&cf_sk->sk),
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 678
664 /* I want to be alone on cf_sk (except status and queue) */ 679 size = len-sent;
665 lock_sock(&(cf_sk->sk));
666 680
667 } while (ret == -EAGAIN); 681 if (size > CAIF_MAX_PAYLOAD_SIZE)
682 size = CAIF_MAX_PAYLOAD_SIZE;
668 683
669 if (ret < 0) { 684 /* If size is more than half of sndbuf, chop up message */
670 cfpkt_destroy(pkt); 685 if (size > ((sk->sk_sndbuf >> 1) - 64))
671 pr_debug("CAIF: %s(): transmit failed, error = %ld\n", 686 size = (sk->sk_sndbuf >> 1) - 64;
672 __func__, (long) ret);
673 687
674 goto write_error; 688 if (size > SKB_MAX_ALLOC)
675 } 689 size = SKB_MAX_ALLOC;
676 690
677 release_sock(&cf_sk->sk); 691 skb = sock_alloc_send_skb(sk,
678 return payload_size; 692 size + CAIF_NEEDED_HEADROOM
693 + CAIF_NEEDED_TAILROOM,
694 msg->msg_flags&MSG_DONTWAIT,
695 &err);
696 if (skb == NULL)
697 goto out_err;
679 698
680write_error: 699 skb_reserve(skb, CAIF_NEEDED_HEADROOM);
681 release_sock(&cf_sk->sk); 700 /*
682write_error_no_unlock: 701 * If you pass two values to the sock_alloc_send_skb
683 return ret; 702 * it tries to grab the large buffer with GFP_NOFS
684} 703 * (which can fail easily), and if it fails grab the
704 * fallback size buffer which is under a page and will
705 * succeed. [Alan]
706 */
707 size = min_t(int, size, skb_tailroom(skb));
685 708
686static unsigned int caif_poll(struct file *file, struct socket *sock, 709 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
687 poll_table *wait) 710 if (err) {
688{ 711 kfree_skb(skb);
689 struct sock *sk = sock->sk; 712 goto out_err;
690 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 713 }
691 u32 mask = 0; 714 err = transmit_skb(skb, cf_sk,
692 poll_wait(file, sk_sleep(sk), wait); 715 msg->msg_flags&MSG_DONTWAIT, timeo);
693 lock_sock(&(cf_sk->sk)); 716 if (err < 0) {
694 if (!STATE_IS_OPEN(cf_sk)) { 717 kfree_skb(skb);
695 if (!STATE_IS_PENDING(cf_sk)) 718 goto pipe_err;
696 mask |= POLLHUP; 719 }
697 } else { 720 sent += size;
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 } 721 }
703 release_sock(&cf_sk->sk);
704 trace_printk("CAIF: %s(): poll mask=0x%04x\n",
705 __func__, mask);
706 return mask;
707}
708
709static 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 722
726 } while (1); 723 return sent;
727 724
728 cf_sk->read_queue_len = 0; 725pipe_err:
726 if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
727 send_sig(SIGPIPE, current, 0);
728 err = -EPIPE;
729out_err:
730 return sent ? : err;
729} 731}
730 732
731static int setsockopt(struct socket *sock, 733static int setsockopt(struct socket *sock,
@@ -736,19 +738,13 @@ static int setsockopt(struct socket *sock,
736 int prio, linksel; 738 int prio, linksel;
737 struct ifreq ifreq; 739 struct ifreq ifreq;
738 740
739 if (STATE_IS_OPEN(cf_sk)) { 741 if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
740 pr_debug("CAIF: %s(): setsockopt "
741 "cannot be done on a connected socket\n",
742 __func__);
743 return -ENOPROTOOPT; 742 return -ENOPROTOOPT;
744 } 743
745 switch (opt) { 744 switch (opt) {
746 case CAIFSO_LINK_SELECT: 745 case CAIFSO_LINK_SELECT:
747 if (ol < sizeof(int)) { 746 if (ol < sizeof(int))
748 pr_debug("CAIF: %s(): setsockopt"
749 " CAIFSO_CHANNEL_CONFIG bad size\n", __func__);
750 return -EINVAL; 747 return -EINVAL;
751 }
752 if (lvl != SOL_CAIF) 748 if (lvl != SOL_CAIF)
753 goto bad_sol; 749 goto bad_sol;
754 if (copy_from_user(&linksel, ov, sizeof(int))) 750 if (copy_from_user(&linksel, ov, sizeof(int)))
@@ -761,28 +757,20 @@ static int setsockopt(struct socket *sock,
761 case SO_PRIORITY: 757 case SO_PRIORITY:
762 if (lvl != SOL_SOCKET) 758 if (lvl != SOL_SOCKET)
763 goto bad_sol; 759 goto bad_sol;
764 if (ol < sizeof(int)) { 760 if (ol < sizeof(int))
765 pr_debug("CAIF: %s(): setsockopt"
766 " SO_PRIORITY bad size\n", __func__);
767 return -EINVAL; 761 return -EINVAL;
768 }
769 if (copy_from_user(&prio, ov, sizeof(int))) 762 if (copy_from_user(&prio, ov, sizeof(int)))
770 return -EINVAL; 763 return -EINVAL;
771 lock_sock(&(cf_sk->sk)); 764 lock_sock(&(cf_sk->sk));
772 cf_sk->conn_req.priority = prio; 765 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); 766 release_sock(&cf_sk->sk);
776 return 0; 767 return 0;
777 768
778 case SO_BINDTODEVICE: 769 case SO_BINDTODEVICE:
779 if (lvl != SOL_SOCKET) 770 if (lvl != SOL_SOCKET)
780 goto bad_sol; 771 goto bad_sol;
781 if (ol < sizeof(struct ifreq)) { 772 if (ol < sizeof(struct ifreq))
782 pr_debug("CAIF: %s(): setsockopt"
783 " SO_PRIORITY bad size\n", __func__);
784 return -EINVAL; 773 return -EINVAL;
785 }
786 if (copy_from_user(&ifreq, ov, sizeof(ifreq))) 774 if (copy_from_user(&ifreq, ov, sizeof(ifreq)))
787 return -EFAULT; 775 return -EFAULT;
788 lock_sock(&(cf_sk->sk)); 776 lock_sock(&(cf_sk->sk));
@@ -798,359 +786,275 @@ static int setsockopt(struct socket *sock,
798 goto bad_sol; 786 goto bad_sol;
799 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL) 787 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
800 return -ENOPROTOOPT; 788 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)); 789 lock_sock(&(cf_sk->sk));
805 cf_sk->conn_req.param.size = ol; 790 cf_sk->conn_req.param.size = ol;
806 if (copy_from_user(&cf_sk->conn_req.param.data, ov, ol)) { 791 if (ol > sizeof(cf_sk->conn_req.param.data) ||
792 copy_from_user(&cf_sk->conn_req.param.data, ov, ol)) {
807 release_sock(&cf_sk->sk); 793 release_sock(&cf_sk->sk);
808req_param_bad_size:
809 pr_debug("CAIF: %s(): setsockopt"
810 " CAIFSO_CHANNEL_CONFIG bad size\n", __func__);
811 return -EINVAL; 794 return -EINVAL;
812 } 795 }
813
814 release_sock(&cf_sk->sk); 796 release_sock(&cf_sk->sk);
815 return 0; 797 return 0;
816 798
817 default: 799 default:
818 pr_debug("CAIF: %s(): unhandled option %d\n", __func__, opt); 800 return -ENOPROTOOPT;
819 return -EINVAL;
820 } 801 }
821 802
822 return 0; 803 return 0;
823bad_sol: 804bad_sol:
824 pr_debug("CAIF: %s(): setsockopt bad level\n", __func__);
825 return -ENOPROTOOPT; 805 return -ENOPROTOOPT;
826 806
827} 807}
828 808
829static int caif_connect(struct socket *sock, struct sockaddr *uservaddr, 809/*
830 int sockaddr_len, int flags) 810 * caif_connect() - Connect a CAIF Socket
811 * Copied and modified af_irda.c:irda_connect().
812 *
813 * Note : by consulting "errno", the user space caller may learn the cause
814 * of the failure. Most of them are visible in the function, others may come
815 * from subroutines called and are listed here :
816 * o -EAFNOSUPPORT: bad socket family or type.
817 * o -ESOCKTNOSUPPORT: bad socket type or protocol
818 * o -EINVAL: bad socket address, or CAIF link type
819 * o -ECONNREFUSED: remote end refused the connection.
820 * o -EINPROGRESS: connect request sent but timed out (or non-blocking)
821 * o -EISCONN: already connected.
822 * o -ETIMEDOUT: Connection timed out (send timeout)
823 * o -ENODEV: No link layer to send request
824 * o -ECONNRESET: Received Shutdown indication or lost link layer
825 * o -ENOMEM: Out of memory
826 *
827 * State Strategy:
828 * o sk_state: holds the CAIF_* protocol state, it's updated by
829 * caif_ctrl_cb.
830 * o sock->state: holds the SS_* socket state and is updated by connect and
831 * disconnect.
832 */
833static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
834 int addr_len, int flags)
831{ 835{
832 struct caifsock *cf_sk = NULL;
833 int result = -1;
834 int mode = 0;
835 int ret = -EIO;
836 struct sock *sk = sock->sk; 836 struct sock *sk = sock->sk;
837 BUG_ON(sk == NULL); 837 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
838 838 long timeo;
839 cf_sk = container_of(sk, struct caifsock, sk); 839 int err;
840 840 lock_sock(sk);
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 841
847 if (sock->type == SOCK_SEQPACKET || sock->type == SOCK_STREAM) 842 err = -EAFNOSUPPORT;
848 sock->state = SS_CONNECTING; 843 if (uaddr->sa_family != AF_CAIF)
849 else
850 goto out; 844 goto out;
851 845
852 /* I want to be alone on cf_sk (except status and queue) */ 846 err = -ESOCKTNOSUPPORT;
853 lock_sock(&(cf_sk->sk)); 847 if (unlikely(!(sk->sk_type == SOCK_STREAM &&
854 848 cf_sk->sk.sk_protocol == CAIFPROTO_AT) &&
855 if (sockaddr_len != sizeof(struct sockaddr_caif)) { 849 sk->sk_type != SOCK_SEQPACKET))
856 pr_debug("CAIF: %s(): Bad address len (%ld,%lu)\n", 850 goto out;
857 __func__, (long) sockaddr_len, 851 switch (sock->state) {
858 (long unsigned) sizeof(struct sockaddr_caif)); 852 case SS_UNCONNECTED:
859 ret = -EINVAL; 853 /* Normal case, a fresh connect */
860 goto open_error; 854 caif_assert(sk->sk_state == CAIF_DISCONNECTED);
855 break;
856 case SS_CONNECTING:
857 switch (sk->sk_state) {
858 case CAIF_CONNECTED:
859 sock->state = SS_CONNECTED;
860 err = -EISCONN;
861 goto out;
862 case CAIF_DISCONNECTED:
863 /* Reconnect allowed */
864 break;
865 case CAIF_CONNECTING:
866 err = -EALREADY;
867 if (flags & O_NONBLOCK)
868 goto out;
869 goto wait_connect;
870 }
871 break;
872 case SS_CONNECTED:
873 caif_assert(sk->sk_state == CAIF_CONNECTED ||
874 sk->sk_state == CAIF_DISCONNECTED);
875 if (sk->sk_shutdown & SHUTDOWN_MASK) {
876 /* Allow re-connect after SHUTDOWN_IND */
877 caif_disconnect_client(&cf_sk->layer);
878 break;
879 }
880 /* No reconnect on a seqpacket socket */
881 err = -EISCONN;
882 goto out;
883 case SS_DISCONNECTING:
884 case SS_FREE:
885 caif_assert(1); /*Should never happen */
886 break;
861 } 887 }
888 sk->sk_state = CAIF_DISCONNECTED;
889 sock->state = SS_UNCONNECTED;
890 sk_stream_kill_queues(&cf_sk->sk);
862 891
863 if (uservaddr->sa_family != AF_CAIF) { 892 err = -EINVAL;
864 pr_debug("CAIF: %s(): Bad address family (%d)\n", 893 if (addr_len != sizeof(struct sockaddr_caif) ||
865 __func__, uservaddr->sa_family); 894 !uaddr)
866 ret = -EAFNOSUPPORT; 895 goto out;
867 goto open_error;
868 }
869 896
870 memcpy(&cf_sk->conn_req.sockaddr, uservaddr, 897 memcpy(&cf_sk->conn_req.sockaddr, uaddr,
871 sizeof(struct sockaddr_caif)); 898 sizeof(struct sockaddr_caif));
872 899
873 dbfs_atomic_inc(&cnt.num_open); 900 /* Move to connecting socket, start sending Connect Requests */
874 mode = SKT_READ_FLAG | SKT_WRITE_FLAG; 901 sock->state = SS_CONNECTING;
875 902 sk->sk_state = CAIF_CONNECTING;
876 /* If socket is not open, make sure socket is in fully closed state */ 903
877 if (!STATE_IS_OPEN(cf_sk)) { 904 dbfs_atomic_inc(&cnt.num_connect_req);
878 /* Has link close response been received (if we ever sent it)?*/ 905 cf_sk->layer.receive = caif_sktrecv_cb;
879 if (STATE_IS_PENDING(cf_sk)) { 906 err = caif_connect_client(&cf_sk->conn_req,
880 /* 907 &cf_sk->layer);
881 * Still waiting for close response from remote. 908 if (err < 0) {
882 * If opened non-blocking, report "would block" 909 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
883 */ 910 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
884 if (flags & O_NONBLOCK) { 911 goto out;
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(*sk_sleep(&cf_sk->sk),
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 } 912 }
913 913
914 /* socket is now either closed, pending open or open */ 914 err = -EINPROGRESS;
915 if (STATE_IS_OPEN(cf_sk) && !STATE_IS_PENDING(cf_sk)) { 915wait_connect:
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 916
964 /* release lock before waiting */ 917 if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
965 release_sock(&cf_sk->sk); 918 goto out;
966
967 result =
968 wait_event_interruptible(*sk_sleep(&cf_sk->sk),
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 919
987 trace_printk("CAIF: %s(): Connect received\n", __func__); 920 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
921
922 release_sock(sk);
923 err = wait_event_interruptible_timeout(*sk_sleep(sk),
924 sk->sk_state != CAIF_CONNECTING,
925 timeo);
926 lock_sock(sk);
927 if (err < 0)
928 goto out; /* -ERESTARTSYS */
929 if (err == 0 && sk->sk_state != CAIF_CONNECTED) {
930 err = -ETIMEDOUT;
931 goto out;
988 } 932 }
989 /* Open is ok */
990 cf_sk->file_mode |= mode;
991 933
992 trace_printk("CAIF: %s(): Connected - file mode = %x\n", 934 if (sk->sk_state != CAIF_CONNECTED) {
993 __func__, cf_sk->file_mode); 935 sock->state = SS_UNCONNECTED;
994 936 err = sock_error(sk);
995 release_sock(&cf_sk->sk); 937 if (!err)
996 return 0; 938 err = -ECONNREFUSED;
997open_error: 939 goto out;
998 sock->state = SS_UNCONNECTED; 940 }
999 release_sock(&cf_sk->sk); 941 sock->state = SS_CONNECTED;
942 err = 0;
1000out: 943out:
1001 return ret; 944 release_sock(sk);
945 return err;
1002} 946}
1003 947
1004static int caif_shutdown(struct socket *sock, int how) 948
949/*
950 * caif_release() - Disconnect a CAIF Socket
951 * Copied and modified af_irda.c:irda_release().
952 */
953static int caif_release(struct socket *sock)
1005{ 954{
1006 struct caifsock *cf_sk = NULL;
1007 int result = 0;
1008 int tx_flow_state_was_on;
1009 struct sock *sk = sock->sk; 955 struct sock *sk = sock->sk;
956 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
957 int res = 0;
1010 958
1011 trace_printk("CAIF: %s(): enter\n", __func__); 959 if (!sk)
1012 pr_debug("f_flags=%x\n", sock->file->f_flags); 960 return 0;
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 961
1055 } 962 set_tx_flow_off(cf_sk);
1056 if (STATE_IS_REMOTE_SHUTDOWN(cf_sk)) {
1057 SET_PENDING_OFF(cf_sk);
1058 SET_REMOTE_SHUTDOWN_OFF(cf_sk);
1059 }
1060 963
1061 /* 964 /*
1062 * Socket is no longer in state pending close, 965 * Ensure that packets are not queued after this point in time.
1063 * and we can release the reference. 966 * caif_queue_rcv_skb checks SOCK_DEAD holding the queue lock,
967 * this ensures no packets when sock is dead.
1064 */ 968 */
969 spin_lock(&sk->sk_receive_queue.lock);
970 sock_set_flag(sk, SOCK_DEAD);
971 spin_unlock(&sk->sk_receive_queue.lock);
972 sock->sk = NULL;
1065 973
1066 dbfs_atomic_inc(&cnt.num_close); 974 dbfs_atomic_inc(&cnt.num_disconnect);
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
1079static 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. */
1087static 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 975
1095 if (cf_sk->debugfs_socket_dir != NULL) 976 if (cf_sk->debugfs_socket_dir != NULL)
1096 debugfs_remove_recursive(cf_sk->debugfs_socket_dir); 977 debugfs_remove_recursive(cf_sk->debugfs_socket_dir);
1097 978
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(*sk_sleep(&cf_sk->sk),
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)); 979 lock_sock(&(cf_sk->sk));
980 sk->sk_state = CAIF_DISCONNECTED;
981 sk->sk_shutdown = SHUTDOWN_MASK;
1119 982
1120 sock->sk = NULL; 983 if (cf_sk->sk.sk_socket->state == SS_CONNECTED ||
984 cf_sk->sk.sk_socket->state == SS_CONNECTING)
985 res = caif_disconnect_client(&cf_sk->layer);
1121 986
1122 /* Detach the socket from its process context by making it orphan. */ 987 cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
1123 sock_orphan(sk); 988 wake_up_interruptible_poll(sk_sleep(sk), POLLERR|POLLHUP);
1124 989
1125 /* 990 sock_orphan(sk);
1126 * Setting SHUTDOWN_MASK means that both send and receive are shutdown 991 cf_sk->layer.dn = NULL;
1127 * for the socket. 992 sk_stream_kill_queues(&cf_sk->sk);
1128 */ 993 release_sock(sk);
1129 sk->sk_shutdown = SHUTDOWN_MASK; 994 sock_put(sk);
995 return res;
996}
1130 997
1131 /* 998/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
1132 * Set the socket state to closed, the TCP_CLOSE macro is used when 999static unsigned int caif_poll(struct file *file,
1133 * closing any socket. 1000 struct socket *sock, poll_table *wait)
1134 */ 1001{
1002 struct sock *sk = sock->sk;
1003 unsigned int mask;
1004 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1135 1005
1136 /* Flush out this sockets receive queue. */ 1006 sock_poll_wait(file, sk_sleep(sk), wait);
1137 drain_queue(cf_sk); 1007 mask = 0;
1138 1008
1139 /* Finally release the socket. */ 1009 /* exceptional events? */
1140 SET_STATE_PENDING_DESTROY(cf_sk); 1010 if (sk->sk_err)
1011 mask |= POLLERR;
1012 if (sk->sk_shutdown == SHUTDOWN_MASK)
1013 mask |= POLLHUP;
1014 if (sk->sk_shutdown & RCV_SHUTDOWN)
1015 mask |= POLLRDHUP;
1141 1016
1142 release_sock(&cf_sk->sk); 1017 /* readable? */
1018 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1019 (sk->sk_shutdown & RCV_SHUTDOWN))
1020 mask |= POLLIN | POLLRDNORM;
1143 1021
1144 sock_put(sk); 1022 /* Connection-based need to check for termination and startup */
1023 if (sk->sk_state == CAIF_DISCONNECTED)
1024 mask |= POLLHUP;
1145 1025
1146 /* 1026 /*
1147 * The rest of the cleanup will be handled from the 1027 * we set writable also when the other side has shut down the
1148 * caif_sock_destructor 1028 * connection. This prevents stuck sockets.
1149 */ 1029 */
1150 return res; 1030 if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
1031 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
1032
1033 return mask;
1151} 1034}
1152 1035
1153static const struct proto_ops caif_ops = { 1036static const struct proto_ops caif_seqpacket_ops = {
1037 .family = PF_CAIF,
1038 .owner = THIS_MODULE,
1039 .release = caif_release,
1040 .bind = sock_no_bind,
1041 .connect = caif_connect,
1042 .socketpair = sock_no_socketpair,
1043 .accept = sock_no_accept,
1044 .getname = sock_no_getname,
1045 .poll = caif_poll,
1046 .ioctl = sock_no_ioctl,
1047 .listen = sock_no_listen,
1048 .shutdown = sock_no_shutdown,
1049 .setsockopt = setsockopt,
1050 .getsockopt = sock_no_getsockopt,
1051 .sendmsg = caif_seqpkt_sendmsg,
1052 .recvmsg = caif_seqpkt_recvmsg,
1053 .mmap = sock_no_mmap,
1054 .sendpage = sock_no_sendpage,
1055};
1056
1057static const struct proto_ops caif_stream_ops = {
1154 .family = PF_CAIF, 1058 .family = PF_CAIF,
1155 .owner = THIS_MODULE, 1059 .owner = THIS_MODULE,
1156 .release = caif_release, 1060 .release = caif_release,
@@ -1162,73 +1066,62 @@ static const struct proto_ops caif_ops = {
1162 .poll = caif_poll, 1066 .poll = caif_poll,
1163 .ioctl = sock_no_ioctl, 1067 .ioctl = sock_no_ioctl,
1164 .listen = sock_no_listen, 1068 .listen = sock_no_listen,
1165 .shutdown = caif_shutdown, 1069 .shutdown = sock_no_shutdown,
1166 .setsockopt = setsockopt, 1070 .setsockopt = setsockopt,
1167 .getsockopt = sock_no_getsockopt, 1071 .getsockopt = sock_no_getsockopt,
1168 .sendmsg = caif_sendmsg, 1072 .sendmsg = caif_stream_sendmsg,
1169 .recvmsg = caif_recvmsg, 1073 .recvmsg = caif_stream_recvmsg,
1170 .mmap = sock_no_mmap, 1074 .mmap = sock_no_mmap,
1171 .sendpage = caif_sock_no_sendpage, 1075 .sendpage = sock_no_sendpage,
1172}; 1076};
1173 1077
1174/* This function is called when a socket is finally destroyed. */ 1078/* This function is called when a socket is finally destroyed. */
1175static void caif_sock_destructor(struct sock *sk) 1079static void caif_sock_destructor(struct sock *sk)
1176{ 1080{
1177 struct caifsock *cf_sk = NULL; 1081 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1178 cf_sk = container_of(sk, struct caifsock, sk);
1179 /* Error checks. */
1180 caif_assert(!atomic_read(&sk->sk_wmem_alloc)); 1082 caif_assert(!atomic_read(&sk->sk_wmem_alloc));
1181 caif_assert(sk_unhashed(sk)); 1083 caif_assert(sk_unhashed(sk));
1182 caif_assert(!sk->sk_socket); 1084 caif_assert(!sk->sk_socket);
1183 if (!sock_flag(sk, SOCK_DEAD)) { 1085 if (!sock_flag(sk, SOCK_DEAD)) {
1184 pr_debug("CAIF: %s(): 0x%p", __func__, sk); 1086 pr_info("Attempt to release alive CAIF socket: %p\n", sk);
1185 return; 1087 return;
1186 } 1088 }
1187 1089 sk_stream_kill_queues(&cf_sk->sk);
1188 if (STATE_IS_OPEN(cf_sk)) { 1090 dbfs_atomic_dec(&cnt.caif_nr_socks);
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} 1091}
1201 1092
1202static int caif_create(struct net *net, struct socket *sock, int protocol, 1093static int caif_create(struct net *net, struct socket *sock, int protocol,
1203 int kern) 1094 int kern)
1204{ 1095{
1205 struct sock *sk = NULL; 1096 struct sock *sk = NULL;
1206 struct caifsock *cf_sk = NULL; 1097 struct caifsock *cf_sk = NULL;
1207 int result = 0;
1208 static struct proto prot = {.name = "PF_CAIF", 1098 static struct proto prot = {.name = "PF_CAIF",
1209 .owner = THIS_MODULE, 1099 .owner = THIS_MODULE,
1210 .obj_size = sizeof(struct caifsock), 1100 .obj_size = sizeof(struct caifsock),
1211 }; 1101 };
1212 1102
1103 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
1104 return -EPERM;
1213 /* 1105 /*
1214 * The sock->type specifies the socket type to use. 1106 * The sock->type specifies the socket type to use.
1215 * in SEQPACKET mode packet boundaries are enforced. 1107 * The CAIF socket is a packet stream in the sense
1108 * that it is packet based. CAIF trusts the reliability
1109 * of the link, no resending is implemented.
1216 */ 1110 */
1217 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM) 1111 if (sock->type == SOCK_SEQPACKET)
1112 sock->ops = &caif_seqpacket_ops;
1113 else if (sock->type == SOCK_STREAM)
1114 sock->ops = &caif_stream_ops;
1115 else
1218 return -ESOCKTNOSUPPORT; 1116 return -ESOCKTNOSUPPORT;
1219 1117
1220 if (net != &init_net)
1221 return -EAFNOSUPPORT;
1222
1223 if (protocol < 0 || protocol >= CAIFPROTO_MAX) 1118 if (protocol < 0 || protocol >= CAIFPROTO_MAX)
1224 return -EPROTONOSUPPORT; 1119 return -EPROTONOSUPPORT;
1225 /* 1120 /*
1226 * Set the socket state to unconnected. The socket state is really 1121 * Set the socket state to unconnected. The socket state
1227 * not used at all in the net/core or socket.c but the 1122 * is really not used at all in the net/core or socket.c but the
1228 * initialization makes sure that sock->state is not uninitialized. 1123 * initialization makes sure that sock->state is not uninitialized.
1229 */ 1124 */
1230 sock->state = SS_UNCONNECTED;
1231
1232 sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot); 1125 sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot);
1233 if (!sk) 1126 if (!sk)
1234 return -ENOMEM; 1127 return -ENOMEM;
@@ -1238,11 +1131,9 @@ static int caif_create(struct net *net, struct socket *sock, int protocol,
1238 /* Store the protocol */ 1131 /* Store the protocol */
1239 sk->sk_protocol = (unsigned char) protocol; 1132 sk->sk_protocol = (unsigned char) protocol;
1240 1133
1241 spin_lock_init(&cf_sk->read_queue_len_lock); 1134 /* Sendbuf dictates the amount of outbound packets not yet sent */
1242 1135 sk->sk_sndbuf = CAIF_DEF_SNDBUF;
1243 /* Fill in some information concerning the misc socket. */ 1136 sk->sk_rcvbuf = CAIF_DEF_RCVBUF;
1244 snprintf(cf_sk->name, sizeof(cf_sk->name), "cf_sk%d",
1245 atomic_read(&caif_nr_socks));
1246 1137
1247 /* 1138 /*
1248 * Lock in order to try to stop someone from opening the socket 1139 * Lock in order to try to stop someone from opening the socket
@@ -1252,108 +1143,85 @@ static int caif_create(struct net *net, struct socket *sock, int protocol,
1252 1143
1253 /* Initialize the nozero default sock structure data. */ 1144 /* Initialize the nozero default sock structure data. */
1254 sock_init_data(sock, sk); 1145 sock_init_data(sock, sk);
1255 sock->ops = &caif_ops;
1256 sk->sk_destruct = caif_sock_destructor; 1146 sk->sk_destruct = caif_sock_destructor;
1257 sk->sk_sndbuf = caif_sockbuf_size;
1258 sk->sk_rcvbuf = caif_sockbuf_size;
1259 1147
1260 cf_sk->pktq = cfpktq_create(); 1148 mutex_init(&cf_sk->readlock); /* single task reading lock */
1149 cf_sk->layer.ctrlcmd = caif_ctrl_cb;
1150 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
1151 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
1261 1152
1262 if (!cf_sk->pktq) { 1153 set_tx_flow_off(cf_sk);
1263 pr_err("CAIF: %s(): queue create failed.\n", __func__); 1154 set_rx_flow_on(cf_sk);
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 1155
1274 /* Set default options on configuration */ 1156 /* Set default options on configuration */
1275 cf_sk->conn_req.priority = CAIF_PRIO_NORMAL; 1157 cf_sk->conn_req.priority = CAIF_PRIO_NORMAL;
1276 cf_sk->conn_req.link_selector = CAIF_LINK_HIGH_BANDW; 1158 cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY;
1277 cf_sk->conn_req.protocol = protocol; 1159 cf_sk->conn_req.protocol = protocol;
1278 /* Increase the number of sockets created. */ 1160 /* Increase the number of sockets created. */
1279 atomic_inc(&caif_nr_socks); 1161 dbfs_atomic_inc(&cnt.caif_nr_socks);
1162#ifdef CONFIG_DEBUG_FS
1280 if (!IS_ERR(debugfsdir)) { 1163 if (!IS_ERR(debugfsdir)) {
1164 /* Fill in some information concerning the misc socket. */
1165 snprintf(cf_sk->name, sizeof(cf_sk->name), "cfsk%d",
1166 atomic_read(&cnt.caif_nr_socks));
1167
1281 cf_sk->debugfs_socket_dir = 1168 cf_sk->debugfs_socket_dir =
1282 debugfs_create_dir(cf_sk->name, debugfsdir); 1169 debugfs_create_dir(cf_sk->name, debugfsdir);
1283 debugfs_create_u32("conn_state", S_IRUSR | S_IWUSR, 1170 debugfs_create_u32("sk_state", S_IRUSR | S_IWUSR,
1284 cf_sk->debugfs_socket_dir, &cf_sk->conn_state); 1171 cf_sk->debugfs_socket_dir,
1172 (u32 *) &cf_sk->sk.sk_state);
1285 debugfs_create_u32("flow_state", S_IRUSR | S_IWUSR, 1173 debugfs_create_u32("flow_state", S_IRUSR | S_IWUSR,
1286 cf_sk->debugfs_socket_dir, &cf_sk->flow_state); 1174 cf_sk->debugfs_socket_dir, &cf_sk->flow_state);
1287 debugfs_create_u32("read_queue_len", S_IRUSR | S_IWUSR, 1175 debugfs_create_u32("sk_rmem_alloc", S_IRUSR | S_IWUSR,
1176 cf_sk->debugfs_socket_dir,
1177 (u32 *) &cf_sk->sk.sk_rmem_alloc);
1178 debugfs_create_u32("sk_wmem_alloc", S_IRUSR | S_IWUSR,
1288 cf_sk->debugfs_socket_dir, 1179 cf_sk->debugfs_socket_dir,
1289 (u32 *) &cf_sk->read_queue_len); 1180 (u32 *) &cf_sk->sk.sk_wmem_alloc);
1290 debugfs_create_u32("identity", S_IRUSR | S_IWUSR, 1181 debugfs_create_u32("identity", S_IRUSR | S_IWUSR,
1291 cf_sk->debugfs_socket_dir, 1182 cf_sk->debugfs_socket_dir,
1292 (u32 *) &cf_sk->layer.id); 1183 (u32 *) &cf_sk->layer.id);
1293 } 1184 }
1185#endif
1294 release_sock(&cf_sk->sk); 1186 release_sock(&cf_sk->sk);
1295 return 0; 1187 return 0;
1296err_failed:
1297 sk_free(sk);
1298 return result;
1299} 1188}
1300 1189
1190
1301static struct net_proto_family caif_family_ops = { 1191static struct net_proto_family caif_family_ops = {
1302 .family = PF_CAIF, 1192 .family = PF_CAIF,
1303 .create = caif_create, 1193 .create = caif_create,
1304 .owner = THIS_MODULE, 1194 .owner = THIS_MODULE,
1305}; 1195};
1306 1196
1307static int af_caif_init(void) 1197int af_caif_init(void)
1308{ 1198{
1309 int err; 1199 int err = sock_register(&caif_family_ops);
1310 err = sock_register(&caif_family_ops);
1311
1312 if (!err) 1200 if (!err)
1313 return err; 1201 return err;
1314
1315 return 0; 1202 return 0;
1316} 1203}
1317 1204
1318static int __init caif_sktinit_module(void) 1205static int __init caif_sktinit_module(void)
1319{ 1206{
1320 int stat;
1321#ifdef CONFIG_DEBUG_FS 1207#ifdef CONFIG_DEBUG_FS
1322 debugfsdir = debugfs_create_dir("chnl_skt", NULL); 1208 debugfsdir = debugfs_create_dir("caif_sk", NULL);
1323 if (!IS_ERR(debugfsdir)) { 1209 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, 1210 debugfs_create_u32("num_sockets", S_IRUSR | S_IWUSR,
1334 debugfsdir, 1211 debugfsdir,
1335 (u32 *) &caif_nr_socks); 1212 (u32 *) &cnt.caif_nr_socks);
1336 debugfs_create_u32("num_open", S_IRUSR | S_IWUSR, 1213 debugfs_create_u32("num_connect_req", S_IRUSR | S_IWUSR,
1337 debugfsdir, 1214 debugfsdir,
1338 (u32 *) &cnt.num_open); 1215 (u32 *) &cnt.num_connect_req);
1339 debugfs_create_u32("num_close", S_IRUSR | S_IWUSR, 1216 debugfs_create_u32("num_connect_resp", S_IRUSR | S_IWUSR,
1340 debugfsdir, 1217 debugfsdir,
1341 (u32 *) &cnt.num_close); 1218 (u32 *) &cnt.num_connect_resp);
1342 debugfs_create_u32("num_init", S_IRUSR | S_IWUSR, 1219 debugfs_create_u32("num_connect_fail_resp", S_IRUSR | S_IWUSR,
1343 debugfsdir, 1220 debugfsdir,
1344 (u32 *) &cnt.num_init); 1221 (u32 *) &cnt.num_connect_fail_resp);
1345 debugfs_create_u32("num_init_resp", S_IRUSR | S_IWUSR, 1222 debugfs_create_u32("num_disconnect", S_IRUSR | S_IWUSR,
1346 debugfsdir, 1223 debugfsdir,
1347 (u32 *) &cnt.num_init_resp); 1224 (u32 *) &cnt.num_disconnect);
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", 1225 debugfs_create_u32("num_remote_shutdown_ind",
1358 S_IRUSR | S_IWUSR, debugfsdir, 1226 S_IRUSR | S_IWUSR, debugfsdir,
1359 (u32 *) &cnt.num_remote_shutdown_ind); 1227 (u32 *) &cnt.num_remote_shutdown_ind);
@@ -1371,13 +1239,7 @@ static int __init caif_sktinit_module(void)
1371 (u32 *) &cnt.num_rx_flow_on); 1239 (u32 *) &cnt.num_rx_flow_on);
1372 } 1240 }
1373#endif 1241#endif
1374 stat = af_caif_init(); 1242 return 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} 1243}
1382 1244
1383static void __exit caif_sktexit_module(void) 1245static void __exit caif_sktexit_module(void)
@@ -1386,6 +1248,5 @@ static void __exit caif_sktexit_module(void)
1386 if (debugfsdir != NULL) 1248 if (debugfsdir != NULL)
1387 debugfs_remove_recursive(debugfsdir); 1249 debugfs_remove_recursive(debugfsdir);
1388} 1250}
1389
1390module_init(caif_sktinit_module); 1251module_init(caif_sktinit_module);
1391module_exit(caif_sktexit_module); 1252module_exit(caif_sktexit_module);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-23 21:23:46 -0500