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->sk_sleep, 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); 1392