caif_socket.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) ST-Ericsson AB 2010
  4. * Author: Sjur Brendeland
  5. */
  6. #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
  7. #include <linux/fs.h>
  8. #include <linux/init.h>
  9. #include <linux/module.h>
  10. #include <linux/sched/signal.h>
  11. #include <linux/spinlock.h>
  12. #include <linux/mutex.h>
  13. #include <linux/list.h>
  14. #include <linux/wait.h>
  15. #include <linux/poll.h>
  16. #include <linux/tcp.h>
  17. #include <linux/uaccess.h>
  18. #include <linux/debugfs.h>
  19. #include <linux/caif/caif_socket.h>
  20. #include <linux/pkt_sched.h>
  21. #include <net/sock.h>
  22. #include <net/tcp_states.h>
  23. #include <net/caif/caif_layer.h>
  24. #include <net/caif/caif_dev.h>
  25. #include <net/caif/cfpkt.h>
  26. MODULE_LICENSE("GPL");
  27. MODULE_ALIAS_NETPROTO(AF_CAIF);
  28. /*
  29. * CAIF state is re-using the TCP socket states.
  30. * caif_states stored in sk_state reflect the state as reported by
  31. * the CAIF stack, while sk_socket->state is the state of the socket.
  32. */
  33. enum caif_states {
  34. CAIF_CONNECTED = TCP_ESTABLISHED,
  35. CAIF_CONNECTING = TCP_SYN_SENT,
  36. CAIF_DISCONNECTED = TCP_CLOSE
  37. };
  38. #define TX_FLOW_ON_BIT 1
  39. #define RX_FLOW_ON_BIT 2
  40. struct caifsock {
  41. struct sock sk; /* must be first member */
  42. struct cflayer layer;
  43. u32 flow_state;
  44. struct caif_connect_request conn_req;
  45. struct mutex readlock;
  46. struct dentry *debugfs_socket_dir;
  47. int headroom, tailroom, maxframe;
  48. };
  49. static int rx_flow_is_on(struct caifsock *cf_sk)
  50. {
  51. return test_bit(RX_FLOW_ON_BIT,
  52. (void *) &cf_sk->flow_state);
  53. }
  54. static int tx_flow_is_on(struct caifsock *cf_sk)
  55. {
  56. return test_bit(TX_FLOW_ON_BIT,
  57. (void *) &cf_sk->flow_state);
  58. }
  59. static void set_rx_flow_off(struct caifsock *cf_sk)
  60. {
  61. clear_bit(RX_FLOW_ON_BIT,
  62. (void *) &cf_sk->flow_state);
  63. }
  64. static void set_rx_flow_on(struct caifsock *cf_sk)
  65. {
  66. set_bit(RX_FLOW_ON_BIT,
  67. (void *) &cf_sk->flow_state);
  68. }
  69. static void set_tx_flow_off(struct caifsock *cf_sk)
  70. {
  71. clear_bit(TX_FLOW_ON_BIT,
  72. (void *) &cf_sk->flow_state);
  73. }
  74. static void set_tx_flow_on(struct caifsock *cf_sk)
  75. {
  76. set_bit(TX_FLOW_ON_BIT,
  77. (void *) &cf_sk->flow_state);
  78. }
  79. static void caif_read_lock(struct sock *sk)
  80. {
  81. struct caifsock *cf_sk;
  82. cf_sk = container_of(sk, struct caifsock, sk);
  83. mutex_lock(&cf_sk->readlock);
  84. }
  85. static void caif_read_unlock(struct sock *sk)
  86. {
  87. struct caifsock *cf_sk;
  88. cf_sk = container_of(sk, struct caifsock, sk);
  89. mutex_unlock(&cf_sk->readlock);
  90. }
  91. static int sk_rcvbuf_lowwater(struct caifsock *cf_sk)
  92. {
  93. /* A quarter of full buffer is used a low water mark */
  94. return cf_sk->sk.sk_rcvbuf / 4;
  95. }
  96. static void caif_flow_ctrl(struct sock *sk, int mode)
  97. {
  98. struct caifsock *cf_sk;
  99. cf_sk = container_of(sk, struct caifsock, sk);
  100. if (cf_sk->layer.dn && cf_sk->layer.dn->modemcmd)
  101. cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode);
  102. }
  103. /*
  104. * Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are
  105. * not dropped, but CAIF is sending flow off instead.
  106. */
  107. static void caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  108. {
  109. int err;
  110. unsigned long flags;
  111. struct sk_buff_head *list = &sk->sk_receive_queue;
  112. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  113. bool queued = false;
  114. if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
  115. (unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
  116. net_dbg_ratelimited("sending flow OFF (queue len = %d %d)\n",
  117. atomic_read(&cf_sk->sk.sk_rmem_alloc),
  118. sk_rcvbuf_lowwater(cf_sk));
  119. set_rx_flow_off(cf_sk);
  120. caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
  121. }
  122. err = sk_filter(sk, skb);
  123. if (err)
  124. goto out;
  125. if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {
  126. set_rx_flow_off(cf_sk);
  127. net_dbg_ratelimited("sending flow OFF due to rmem_schedule\n");
  128. caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
  129. }
  130. skb->dev = NULL;
  131. skb_set_owner_r(skb, sk);
  132. spin_lock_irqsave(&list->lock, flags);
  133. queued = !sock_flag(sk, SOCK_DEAD);
  134. if (queued)
  135. __skb_queue_tail(list, skb);
  136. spin_unlock_irqrestore(&list->lock, flags);
  137. out:
  138. if (queued)
  139. sk->sk_data_ready(sk);
  140. else
  141. kfree_skb(skb);
  142. }
  143. /* Packet Receive Callback function called from CAIF Stack */
  144. static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
  145. {
  146. struct caifsock *cf_sk;
  147. struct sk_buff *skb;
  148. cf_sk = container_of(layr, struct caifsock, layer);
  149. skb = cfpkt_tonative(pkt);
  150. if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
  151. kfree_skb(skb);
  152. return 0;
  153. }
  154. caif_queue_rcv_skb(&cf_sk->sk, skb);
  155. return 0;
  156. }
  157. static void cfsk_hold(struct cflayer *layr)
  158. {
  159. struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
  160. sock_hold(&cf_sk->sk);
  161. }
  162. static void cfsk_put(struct cflayer *layr)
  163. {
  164. struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
  165. sock_put(&cf_sk->sk);
  166. }
  167. /* Packet Control Callback function called from CAIF */
  168. static void caif_ctrl_cb(struct cflayer *layr,
  169. enum caif_ctrlcmd flow,
  170. int phyid)
  171. {
  172. struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
  173. switch (flow) {
  174. case CAIF_CTRLCMD_FLOW_ON_IND:
  175. /* OK from modem to start sending again */
  176. set_tx_flow_on(cf_sk);
  177. cf_sk->sk.sk_state_change(&cf_sk->sk);
  178. break;
  179. case CAIF_CTRLCMD_FLOW_OFF_IND:
  180. /* Modem asks us to shut up */
  181. set_tx_flow_off(cf_sk);
  182. cf_sk->sk.sk_state_change(&cf_sk->sk);
  183. break;
  184. case CAIF_CTRLCMD_INIT_RSP:
  185. /* We're now connected */
  186. caif_client_register_refcnt(&cf_sk->layer,
  187. cfsk_hold, cfsk_put);
  188. cf_sk->sk.sk_state = CAIF_CONNECTED;
  189. set_tx_flow_on(cf_sk);
  190. cf_sk->sk.sk_shutdown = 0;
  191. cf_sk->sk.sk_state_change(&cf_sk->sk);
  192. break;
  193. case CAIF_CTRLCMD_DEINIT_RSP:
  194. /* We're now disconnected */
  195. cf_sk->sk.sk_state = CAIF_DISCONNECTED;
  196. cf_sk->sk.sk_state_change(&cf_sk->sk);
  197. break;
  198. case CAIF_CTRLCMD_INIT_FAIL_RSP:
  199. /* Connect request failed */
  200. cf_sk->sk.sk_err = ECONNREFUSED;
  201. cf_sk->sk.sk_state = CAIF_DISCONNECTED;
  202. cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
  203. /*
  204. * Socket "standards" seems to require POLLOUT to
  205. * be set at connect failure.
  206. */
  207. set_tx_flow_on(cf_sk);
  208. cf_sk->sk.sk_state_change(&cf_sk->sk);
  209. break;
  210. case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
  211. /* Modem has closed this connection, or device is down. */
  212. cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
  213. cf_sk->sk.sk_err = ECONNRESET;
  214. set_rx_flow_on(cf_sk);
  215. cf_sk->sk.sk_error_report(&cf_sk->sk);
  216. break;
  217. default:
  218. pr_debug("Unexpected flow command %d\n", flow);
  219. }
  220. }
  221. static void caif_check_flow_release(struct sock *sk)
  222. {
  223. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  224. if (rx_flow_is_on(cf_sk))
  225. return;
  226. if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
  227. set_rx_flow_on(cf_sk);
  228. caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ);
  229. }
  230. }
  231. /*
  232. * Copied from unix_dgram_recvmsg, but removed credit checks,
  233. * changed locking, address handling and added MSG_TRUNC.
  234. */
  235. static int caif_seqpkt_recvmsg(struct socket *sock, struct msghdr *m,
  236. size_t len, int flags)
  237. {
  238. struct sock *sk = sock->sk;
  239. struct sk_buff *skb;
  240. int ret;
  241. int copylen;
  242. ret = -EOPNOTSUPP;
  243. if (flags & MSG_OOB)
  244. goto read_error;
  245. skb = skb_recv_datagram(sk, flags, 0 , &ret);
  246. if (!skb)
  247. goto read_error;
  248. copylen = skb->len;
  249. if (len < copylen) {
  250. m->msg_flags |= MSG_TRUNC;
  251. copylen = len;
  252. }
  253. ret = skb_copy_datagram_msg(skb, 0, m, copylen);
  254. if (ret)
  255. goto out_free;
  256. ret = (flags & MSG_TRUNC) ? skb->len : copylen;
  257. out_free:
  258. skb_free_datagram(sk, skb);
  259. caif_check_flow_release(sk);
  260. return ret;
  261. read_error:
  262. return ret;
  263. }
  264. /* Copied from unix_stream_wait_data, identical except for lock call. */
  265. static long caif_stream_data_wait(struct sock *sk, long timeo)
  266. {
  267. DEFINE_WAIT(wait);
  268. lock_sock(sk);
  269. for (;;) {
  270. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  271. if (!skb_queue_empty(&sk->sk_receive_queue) ||
  272. sk->sk_err ||
  273. sk->sk_state != CAIF_CONNECTED ||
  274. sock_flag(sk, SOCK_DEAD) ||
  275. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  276. signal_pending(current) ||
  277. !timeo)
  278. break;
  279. sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
  280. release_sock(sk);
  281. timeo = schedule_timeout(timeo);
  282. lock_sock(sk);
  283. if (sock_flag(sk, SOCK_DEAD))
  284. break;
  285. sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
  286. }
  287. finish_wait(sk_sleep(sk), &wait);
  288. release_sock(sk);
  289. return timeo;
  290. }
  291. /*
  292. * Copied from unix_stream_recvmsg, but removed credit checks,
  293. * changed locking calls, changed address handling.
  294. */
  295. static int caif_stream_recvmsg(struct socket *sock, struct msghdr *msg,
  296. size_t size, int flags)
  297. {
  298. struct sock *sk = sock->sk;
  299. int copied = 0;
  300. int target;
  301. int err = 0;
  302. long timeo;
  303. err = -EOPNOTSUPP;
  304. if (flags&MSG_OOB)
  305. goto out;
  306. /*
  307. * Lock the socket to prevent queue disordering
  308. * while sleeps in memcpy_tomsg
  309. */
  310. err = -EAGAIN;
  311. if (sk->sk_state == CAIF_CONNECTING)
  312. goto out;
  313. caif_read_lock(sk);
  314. target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
  315. timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
  316. do {
  317. int chunk;
  318. struct sk_buff *skb;
  319. lock_sock(sk);
  320. if (sock_flag(sk, SOCK_DEAD)) {
  321. err = -ECONNRESET;
  322. goto unlock;
  323. }
  324. skb = skb_dequeue(&sk->sk_receive_queue);
  325. caif_check_flow_release(sk);
  326. if (skb == NULL) {
  327. if (copied >= target)
  328. goto unlock;
  329. /*
  330. * POSIX 1003.1g mandates this order.
  331. */
  332. err = sock_error(sk);
  333. if (err)
  334. goto unlock;
  335. err = -ECONNRESET;
  336. if (sk->sk_shutdown & RCV_SHUTDOWN)
  337. goto unlock;
  338. err = -EPIPE;
  339. if (sk->sk_state != CAIF_CONNECTED)
  340. goto unlock;
  341. if (sock_flag(sk, SOCK_DEAD))
  342. goto unlock;
  343. release_sock(sk);
  344. err = -EAGAIN;
  345. if (!timeo)
  346. break;
  347. caif_read_unlock(sk);
  348. timeo = caif_stream_data_wait(sk, timeo);
  349. if (signal_pending(current)) {
  350. err = sock_intr_errno(timeo);
  351. goto out;
  352. }
  353. caif_read_lock(sk);
  354. continue;
  355. unlock:
  356. release_sock(sk);
  357. break;
  358. }
  359. release_sock(sk);
  360. chunk = min_t(unsigned int, skb->len, size);
  361. if (memcpy_to_msg(msg, skb->data, chunk)) {
  362. skb_queue_head(&sk->sk_receive_queue, skb);
  363. if (copied == 0)
  364. copied = -EFAULT;
  365. break;
  366. }
  367. copied += chunk;
  368. size -= chunk;
  369. /* Mark read part of skb as used */
  370. if (!(flags & MSG_PEEK)) {
  371. skb_pull(skb, chunk);
  372. /* put the skb back if we didn't use it up. */
  373. if (skb->len) {
  374. skb_queue_head(&sk->sk_receive_queue, skb);
  375. break;
  376. }
  377. kfree_skb(skb);
  378. } else {
  379. /*
  380. * It is questionable, see note in unix_dgram_recvmsg.
  381. */
  382. /* put message back and return */
  383. skb_queue_head(&sk->sk_receive_queue, skb);
  384. break;
  385. }
  386. } while (size);
  387. caif_read_unlock(sk);
  388. out:
  389. return copied ? : err;
  390. }
  391. /*
  392. * Copied from sock.c:sock_wait_for_wmem, but change to wait for
  393. * CAIF flow-on and sock_writable.
  394. */
  395. static long caif_wait_for_flow_on(struct caifsock *cf_sk,
  396. int wait_writeable, long timeo, int *err)
  397. {
  398. struct sock *sk = &cf_sk->sk;
  399. DEFINE_WAIT(wait);
  400. for (;;) {
  401. *err = 0;
  402. if (tx_flow_is_on(cf_sk) &&
  403. (!wait_writeable || sock_writeable(&cf_sk->sk)))
  404. break;
  405. *err = -ETIMEDOUT;
  406. if (!timeo)
  407. break;
  408. *err = -ERESTARTSYS;
  409. if (signal_pending(current))
  410. break;
  411. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  412. *err = -ECONNRESET;
  413. if (sk->sk_shutdown & SHUTDOWN_MASK)
  414. break;
  415. *err = -sk->sk_err;
  416. if (sk->sk_err)
  417. break;
  418. *err = -EPIPE;
  419. if (cf_sk->sk.sk_state != CAIF_CONNECTED)
  420. break;
  421. timeo = schedule_timeout(timeo);
  422. }
  423. finish_wait(sk_sleep(sk), &wait);
  424. return timeo;
  425. }
  426. /*
  427. * Transmit a SKB. The device may temporarily request re-transmission
  428. * by returning EAGAIN.
  429. */
  430. static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk,
  431. int noblock, long timeo)
  432. {
  433. struct cfpkt *pkt;
  434. pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb);
  435. memset(skb->cb, 0, sizeof(struct caif_payload_info));
  436. cfpkt_set_prio(pkt, cf_sk->sk.sk_priority);
  437. if (cf_sk->layer.dn == NULL) {
  438. kfree_skb(skb);
  439. return -EINVAL;
  440. }
  441. return cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
  442. }
  443. /* Copied from af_unix:unix_dgram_sendmsg, and adapted to CAIF */
  444. static int caif_seqpkt_sendmsg(struct socket *sock, struct msghdr *msg,
  445. size_t len)
  446. {
  447. struct sock *sk = sock->sk;
  448. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  449. int buffer_size;
  450. int ret = 0;
  451. struct sk_buff *skb = NULL;
  452. int noblock;
  453. long timeo;
  454. caif_assert(cf_sk);
  455. ret = sock_error(sk);
  456. if (ret)
  457. goto err;
  458. ret = -EOPNOTSUPP;
  459. if (msg->msg_flags&MSG_OOB)
  460. goto err;
  461. ret = -EOPNOTSUPP;
  462. if (msg->msg_namelen)
  463. goto err;
  464. ret = -EINVAL;
  465. if (unlikely(msg->msg_iter.nr_segs == 0) ||
  466. unlikely(msg->msg_iter.iov->iov_base == NULL))
  467. goto err;
  468. noblock = msg->msg_flags & MSG_DONTWAIT;
  469. timeo = sock_sndtimeo(sk, noblock);
  470. timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
  471. 1, timeo, &ret);
  472. if (ret)
  473. goto err;
  474. ret = -EPIPE;
  475. if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
  476. sock_flag(sk, SOCK_DEAD) ||
  477. (sk->sk_shutdown & RCV_SHUTDOWN))
  478. goto err;
  479. /* Error if trying to write more than maximum frame size. */
  480. ret = -EMSGSIZE;
  481. if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM)
  482. goto err;
  483. buffer_size = len + cf_sk->headroom + cf_sk->tailroom;
  484. ret = -ENOMEM;
  485. skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
  486. if (!skb || skb_tailroom(skb) < buffer_size)
  487. goto err;
  488. skb_reserve(skb, cf_sk->headroom);
  489. ret = memcpy_from_msg(skb_put(skb, len), msg, len);
  490. if (ret)
  491. goto err;
  492. ret = transmit_skb(skb, cf_sk, noblock, timeo);
  493. if (ret < 0)
  494. /* skb is already freed */
  495. return ret;
  496. return len;
  497. err:
  498. kfree_skb(skb);
  499. return ret;
  500. }
  501. /*
  502. * Copied from unix_stream_sendmsg and adapted to CAIF:
  503. * Changed removed permission handling and added waiting for flow on
  504. * and other minor adaptations.
  505. */
  506. static int caif_stream_sendmsg(struct socket *sock, struct msghdr *msg,
  507. size_t len)
  508. {
  509. struct sock *sk = sock->sk;
  510. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  511. int err, size;
  512. struct sk_buff *skb;
  513. int sent = 0;
  514. long timeo;
  515. err = -EOPNOTSUPP;
  516. if (unlikely(msg->msg_flags&MSG_OOB))
  517. goto out_err;
  518. if (unlikely(msg->msg_namelen))
  519. goto out_err;
  520. timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
  521. timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err);
  522. if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
  523. goto pipe_err;
  524. while (sent < len) {
  525. size = len-sent;
  526. if (size > cf_sk->maxframe)
  527. size = cf_sk->maxframe;
  528. /* If size is more than half of sndbuf, chop up message */
  529. if (size > ((sk->sk_sndbuf >> 1) - 64))
  530. size = (sk->sk_sndbuf >> 1) - 64;
  531. if (size > SKB_MAX_ALLOC)
  532. size = SKB_MAX_ALLOC;
  533. skb = sock_alloc_send_skb(sk,
  534. size + cf_sk->headroom +
  535. cf_sk->tailroom,
  536. msg->msg_flags&MSG_DONTWAIT,
  537. &err);
  538. if (skb == NULL)
  539. goto out_err;
  540. skb_reserve(skb, cf_sk->headroom);
  541. /*
  542. * If you pass two values to the sock_alloc_send_skb
  543. * it tries to grab the large buffer with GFP_NOFS
  544. * (which can fail easily), and if it fails grab the
  545. * fallback size buffer which is under a page and will
  546. * succeed. [Alan]
  547. */
  548. size = min_t(int, size, skb_tailroom(skb));
  549. err = memcpy_from_msg(skb_put(skb, size), msg, size);
  550. if (err) {
  551. kfree_skb(skb);
  552. goto out_err;
  553. }
  554. err = transmit_skb(skb, cf_sk,
  555. msg->msg_flags&MSG_DONTWAIT, timeo);
  556. if (err < 0)
  557. /* skb is already freed */
  558. goto pipe_err;
  559. sent += size;
  560. }
  561. return sent;
  562. pipe_err:
  563. if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
  564. send_sig(SIGPIPE, current, 0);
  565. err = -EPIPE;
  566. out_err:
  567. return sent ? : err;
  568. }
  569. static int setsockopt(struct socket *sock, int lvl, int opt, sockptr_t ov,
  570. unsigned int ol)
  571. {
  572. struct sock *sk = sock->sk;
  573. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  574. int linksel;
  575. if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
  576. return -ENOPROTOOPT;
  577. switch (opt) {
  578. case CAIFSO_LINK_SELECT:
  579. if (ol < sizeof(int))
  580. return -EINVAL;
  581. if (lvl != SOL_CAIF)
  582. goto bad_sol;
  583. if (copy_from_sockptr(&linksel, ov, sizeof(int)))
  584. return -EINVAL;
  585. lock_sock(&(cf_sk->sk));
  586. cf_sk->conn_req.link_selector = linksel;
  587. release_sock(&cf_sk->sk);
  588. return 0;
  589. case CAIFSO_REQ_PARAM:
  590. if (lvl != SOL_CAIF)
  591. goto bad_sol;
  592. if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
  593. return -ENOPROTOOPT;
  594. lock_sock(&(cf_sk->sk));
  595. if (ol > sizeof(cf_sk->conn_req.param.data) ||
  596. copy_from_sockptr(&cf_sk->conn_req.param.data, ov, ol)) {
  597. release_sock(&cf_sk->sk);
  598. return -EINVAL;
  599. }
  600. cf_sk->conn_req.param.size = ol;
  601. release_sock(&cf_sk->sk);
  602. return 0;
  603. default:
  604. return -ENOPROTOOPT;
  605. }
  606. return 0;
  607. bad_sol:
  608. return -ENOPROTOOPT;
  609. }
  610. /*
  611. * caif_connect() - Connect a CAIF Socket
  612. * Copied and modified af_irda.c:irda_connect().
  613. *
  614. * Note : by consulting "errno", the user space caller may learn the cause
  615. * of the failure. Most of them are visible in the function, others may come
  616. * from subroutines called and are listed here :
  617. * o -EAFNOSUPPORT: bad socket family or type.
  618. * o -ESOCKTNOSUPPORT: bad socket type or protocol
  619. * o -EINVAL: bad socket address, or CAIF link type
  620. * o -ECONNREFUSED: remote end refused the connection.
  621. * o -EINPROGRESS: connect request sent but timed out (or non-blocking)
  622. * o -EISCONN: already connected.
  623. * o -ETIMEDOUT: Connection timed out (send timeout)
  624. * o -ENODEV: No link layer to send request
  625. * o -ECONNRESET: Received Shutdown indication or lost link layer
  626. * o -ENOMEM: Out of memory
  627. *
  628. * State Strategy:
  629. * o sk_state: holds the CAIF_* protocol state, it's updated by
  630. * caif_ctrl_cb.
  631. * o sock->state: holds the SS_* socket state and is updated by connect and
  632. * disconnect.
  633. */
  634. static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
  635. int addr_len, int flags)
  636. {
  637. struct sock *sk = sock->sk;
  638. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  639. long timeo;
  640. int err;
  641. int ifindex, headroom, tailroom;
  642. unsigned int mtu;
  643. struct net_device *dev;
  644. lock_sock(sk);
  645. err = -EINVAL;
  646. if (addr_len < offsetofend(struct sockaddr, sa_family))
  647. goto out;
  648. err = -EAFNOSUPPORT;
  649. if (uaddr->sa_family != AF_CAIF)
  650. goto out;
  651. switch (sock->state) {
  652. case SS_UNCONNECTED:
  653. /* Normal case, a fresh connect */
  654. caif_assert(sk->sk_state == CAIF_DISCONNECTED);
  655. break;
  656. case SS_CONNECTING:
  657. switch (sk->sk_state) {
  658. case CAIF_CONNECTED:
  659. sock->state = SS_CONNECTED;
  660. err = -EISCONN;
  661. goto out;
  662. case CAIF_DISCONNECTED:
  663. /* Reconnect allowed */
  664. break;
  665. case CAIF_CONNECTING:
  666. err = -EALREADY;
  667. if (flags & O_NONBLOCK)
  668. goto out;
  669. goto wait_connect;
  670. }
  671. break;
  672. case SS_CONNECTED:
  673. caif_assert(sk->sk_state == CAIF_CONNECTED ||
  674. sk->sk_state == CAIF_DISCONNECTED);
  675. if (sk->sk_shutdown & SHUTDOWN_MASK) {
  676. /* Allow re-connect after SHUTDOWN_IND */
  677. caif_disconnect_client(sock_net(sk), &cf_sk->layer);
  678. caif_free_client(&cf_sk->layer);
  679. break;
  680. }
  681. /* No reconnect on a seqpacket socket */
  682. err = -EISCONN;
  683. goto out;
  684. case SS_DISCONNECTING:
  685. case SS_FREE:
  686. caif_assert(1); /*Should never happen */
  687. break;
  688. }
  689. sk->sk_state = CAIF_DISCONNECTED;
  690. sock->state = SS_UNCONNECTED;
  691. sk_stream_kill_queues(&cf_sk->sk);
  692. err = -EINVAL;
  693. if (addr_len != sizeof(struct sockaddr_caif))
  694. goto out;
  695. memcpy(&cf_sk->conn_req.sockaddr, uaddr,
  696. sizeof(struct sockaddr_caif));
  697. /* Move to connecting socket, start sending Connect Requests */
  698. sock->state = SS_CONNECTING;
  699. sk->sk_state = CAIF_CONNECTING;
  700. /* Check priority value comming from socket */
  701. /* if priority value is out of range it will be ajusted */
  702. if (cf_sk->sk.sk_priority > CAIF_PRIO_MAX)
  703. cf_sk->conn_req.priority = CAIF_PRIO_MAX;
  704. else if (cf_sk->sk.sk_priority < CAIF_PRIO_MIN)
  705. cf_sk->conn_req.priority = CAIF_PRIO_MIN;
  706. else
  707. cf_sk->conn_req.priority = cf_sk->sk.sk_priority;
  708. /*ifindex = id of the interface.*/
  709. cf_sk->conn_req.ifindex = cf_sk->sk.sk_bound_dev_if;
  710. cf_sk->layer.receive = caif_sktrecv_cb;
  711. err = caif_connect_client(sock_net(sk), &cf_sk->conn_req,
  712. &cf_sk->layer, &ifindex, &headroom, &tailroom);
  713. if (err < 0) {
  714. cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
  715. cf_sk->sk.sk_state = CAIF_DISCONNECTED;
  716. goto out;
  717. }
  718. err = -ENODEV;
  719. rcu_read_lock();
  720. dev = dev_get_by_index_rcu(sock_net(sk), ifindex);
  721. if (!dev) {
  722. rcu_read_unlock();
  723. goto out;
  724. }
  725. cf_sk->headroom = LL_RESERVED_SPACE_EXTRA(dev, headroom);
  726. mtu = dev->mtu;
  727. rcu_read_unlock();
  728. cf_sk->tailroom = tailroom;
  729. cf_sk->maxframe = mtu - (headroom + tailroom);
  730. if (cf_sk->maxframe < 1) {
  731. pr_warn("CAIF Interface MTU too small (%d)\n", dev->mtu);
  732. err = -ENODEV;
  733. goto out;
  734. }
  735. err = -EINPROGRESS;
  736. wait_connect:
  737. if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
  738. goto out;
  739. timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  740. release_sock(sk);
  741. err = -ERESTARTSYS;
  742. timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
  743. sk->sk_state != CAIF_CONNECTING,
  744. timeo);
  745. lock_sock(sk);
  746. if (timeo < 0)
  747. goto out; /* -ERESTARTSYS */
  748. err = -ETIMEDOUT;
  749. if (timeo == 0 && sk->sk_state != CAIF_CONNECTED)
  750. goto out;
  751. if (sk->sk_state != CAIF_CONNECTED) {
  752. sock->state = SS_UNCONNECTED;
  753. err = sock_error(sk);
  754. if (!err)
  755. err = -ECONNREFUSED;
  756. goto out;
  757. }
  758. sock->state = SS_CONNECTED;
  759. err = 0;
  760. out:
  761. release_sock(sk);
  762. return err;
  763. }
  764. /*
  765. * caif_release() - Disconnect a CAIF Socket
  766. * Copied and modified af_irda.c:irda_release().
  767. */
  768. static int caif_release(struct socket *sock)
  769. {
  770. struct sock *sk = sock->sk;
  771. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  772. if (!sk)
  773. return 0;
  774. set_tx_flow_off(cf_sk);
  775. /*
  776. * Ensure that packets are not queued after this point in time.
  777. * caif_queue_rcv_skb checks SOCK_DEAD holding the queue lock,
  778. * this ensures no packets when sock is dead.
  779. */
  780. spin_lock_bh(&sk->sk_receive_queue.lock);
  781. sock_set_flag(sk, SOCK_DEAD);
  782. spin_unlock_bh(&sk->sk_receive_queue.lock);
  783. sock->sk = NULL;
  784. WARN_ON(IS_ERR(cf_sk->debugfs_socket_dir));
  785. debugfs_remove_recursive(cf_sk->debugfs_socket_dir);
  786. lock_sock(&(cf_sk->sk));
  787. sk->sk_state = CAIF_DISCONNECTED;
  788. sk->sk_shutdown = SHUTDOWN_MASK;
  789. caif_disconnect_client(sock_net(sk), &cf_sk->layer);
  790. cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
  791. wake_up_interruptible_poll(sk_sleep(sk), EPOLLERR|EPOLLHUP);
  792. sock_orphan(sk);
  793. sk_stream_kill_queues(&cf_sk->sk);
  794. release_sock(sk);
  795. sock_put(sk);
  796. return 0;
  797. }
  798. /* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
  799. static __poll_t caif_poll(struct file *file,
  800. struct socket *sock, poll_table *wait)
  801. {
  802. struct sock *sk = sock->sk;
  803. __poll_t mask;
  804. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  805. sock_poll_wait(file, sock, wait);
  806. mask = 0;
  807. /* exceptional events? */
  808. if (sk->sk_err)
  809. mask |= EPOLLERR;
  810. if (sk->sk_shutdown == SHUTDOWN_MASK)
  811. mask |= EPOLLHUP;
  812. if (sk->sk_shutdown & RCV_SHUTDOWN)
  813. mask |= EPOLLRDHUP;
  814. /* readable? */
  815. if (!skb_queue_empty_lockless(&sk->sk_receive_queue) ||
  816. (sk->sk_shutdown & RCV_SHUTDOWN))
  817. mask |= EPOLLIN | EPOLLRDNORM;
  818. /*
  819. * we set writable also when the other side has shut down the
  820. * connection. This prevents stuck sockets.
  821. */
  822. if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
  823. mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
  824. return mask;
  825. }
  826. static const struct proto_ops caif_seqpacket_ops = {
  827. .family = PF_CAIF,
  828. .owner = THIS_MODULE,
  829. .release = caif_release,
  830. .bind = sock_no_bind,
  831. .connect = caif_connect,
  832. .socketpair = sock_no_socketpair,
  833. .accept = sock_no_accept,
  834. .getname = sock_no_getname,
  835. .poll = caif_poll,
  836. .ioctl = sock_no_ioctl,
  837. .listen = sock_no_listen,
  838. .shutdown = sock_no_shutdown,
  839. .setsockopt = setsockopt,
  840. .sendmsg = caif_seqpkt_sendmsg,
  841. .recvmsg = caif_seqpkt_recvmsg,
  842. .mmap = sock_no_mmap,
  843. .sendpage = sock_no_sendpage,
  844. };
  845. static const struct proto_ops caif_stream_ops = {
  846. .family = PF_CAIF,
  847. .owner = THIS_MODULE,
  848. .release = caif_release,
  849. .bind = sock_no_bind,
  850. .connect = caif_connect,
  851. .socketpair = sock_no_socketpair,
  852. .accept = sock_no_accept,
  853. .getname = sock_no_getname,
  854. .poll = caif_poll,
  855. .ioctl = sock_no_ioctl,
  856. .listen = sock_no_listen,
  857. .shutdown = sock_no_shutdown,
  858. .setsockopt = setsockopt,
  859. .sendmsg = caif_stream_sendmsg,
  860. .recvmsg = caif_stream_recvmsg,
  861. .mmap = sock_no_mmap,
  862. .sendpage = sock_no_sendpage,
  863. };
  864. /* This function is called when a socket is finally destroyed. */
  865. static void caif_sock_destructor(struct sock *sk)
  866. {
  867. struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
  868. caif_assert(!refcount_read(&sk->sk_wmem_alloc));
  869. caif_assert(sk_unhashed(sk));
  870. caif_assert(!sk->sk_socket);
  871. if (!sock_flag(sk, SOCK_DEAD)) {
  872. pr_debug("Attempt to release alive CAIF socket: %p\n", sk);
  873. return;
  874. }
  875. sk_stream_kill_queues(&cf_sk->sk);
  876. caif_free_client(&cf_sk->layer);
  877. }
  878. static int caif_create(struct net *net, struct socket *sock, int protocol,
  879. int kern)
  880. {
  881. struct sock *sk = NULL;
  882. struct caifsock *cf_sk = NULL;
  883. static struct proto prot = {.name = "PF_CAIF",
  884. .owner = THIS_MODULE,
  885. .obj_size = sizeof(struct caifsock),
  886. .useroffset = offsetof(struct caifsock, conn_req.param),
  887. .usersize = sizeof_field(struct caifsock, conn_req.param)
  888. };
  889. if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
  890. return -EPERM;
  891. /*
  892. * The sock->type specifies the socket type to use.
  893. * The CAIF socket is a packet stream in the sense
  894. * that it is packet based. CAIF trusts the reliability
  895. * of the link, no resending is implemented.
  896. */
  897. if (sock->type == SOCK_SEQPACKET)
  898. sock->ops = &caif_seqpacket_ops;
  899. else if (sock->type == SOCK_STREAM)
  900. sock->ops = &caif_stream_ops;
  901. else
  902. return -ESOCKTNOSUPPORT;
  903. if (protocol < 0 || protocol >= CAIFPROTO_MAX)
  904. return -EPROTONOSUPPORT;
  905. /*
  906. * Set the socket state to unconnected. The socket state
  907. * is really not used at all in the net/core or socket.c but the
  908. * initialization makes sure that sock->state is not uninitialized.
  909. */
  910. sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot, kern);
  911. if (!sk)
  912. return -ENOMEM;
  913. cf_sk = container_of(sk, struct caifsock, sk);
  914. /* Store the protocol */
  915. sk->sk_protocol = (unsigned char) protocol;
  916. /* Initialize default priority for well-known cases */
  917. switch (protocol) {
  918. case CAIFPROTO_AT:
  919. sk->sk_priority = TC_PRIO_CONTROL;
  920. break;
  921. case CAIFPROTO_RFM:
  922. sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
  923. break;
  924. default:
  925. sk->sk_priority = TC_PRIO_BESTEFFORT;
  926. }
  927. /*
  928. * Lock in order to try to stop someone from opening the socket
  929. * too early.
  930. */
  931. lock_sock(&(cf_sk->sk));
  932. /* Initialize the nozero default sock structure data. */
  933. sock_init_data(sock, sk);
  934. sk->sk_destruct = caif_sock_destructor;
  935. mutex_init(&cf_sk->readlock); /* single task reading lock */
  936. cf_sk->layer.ctrlcmd = caif_ctrl_cb;
  937. cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
  938. cf_sk->sk.sk_state = CAIF_DISCONNECTED;
  939. set_tx_flow_off(cf_sk);
  940. set_rx_flow_on(cf_sk);
  941. /* Set default options on configuration */
  942. cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY;
  943. cf_sk->conn_req.protocol = protocol;
  944. release_sock(&cf_sk->sk);
  945. return 0;
  946. }
  947. static const struct net_proto_family caif_family_ops = {
  948. .family = PF_CAIF,
  949. .create = caif_create,
  950. .owner = THIS_MODULE,
  951. };
  952. static int __init caif_sktinit_module(void)
  953. {
  954. return sock_register(&caif_family_ops);
  955. }
  956. static void __exit caif_sktexit_module(void)
  957. {
  958. sock_unregister(PF_CAIF);
  959. }
  960. module_init(caif_sktinit_module);
  961. module_exit(caif_sktexit_module);