common.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832
  1. /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
  2. /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
  3. #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  4. #include <linux/module.h>
  5. #include <linux/kmod.h>
  6. #include <linux/net.h> /* struct socket, struct proto_ops */
  7. #include <linux/atm.h> /* ATM stuff */
  8. #include <linux/atmdev.h>
  9. #include <linux/socket.h> /* SOL_SOCKET */
  10. #include <linux/errno.h> /* error codes */
  11. #include <linux/capability.h>
  12. #include <linux/mm.h>
  13. #include <linux/sched.h>
  14. #include <linux/time.h> /* struct timeval */
  15. #include <linux/skbuff.h>
  16. #include <linux/bitops.h>
  17. #include <linux/init.h>
  18. #include <net/sock.h> /* struct sock */
  19. #include <linux/uaccess.h>
  20. #include <linux/poll.h>
  21. #include <asm/atomic.h>
  22. #include "resources.h" /* atm_find_dev */
  23. #include "common.h" /* prototypes */
  24. #include "protocols.h" /* atm_init_<transport> */
  25. #include "addr.h" /* address registry */
  26. #include "signaling.h" /* for WAITING and sigd_attach */
  27. struct hlist_head vcc_hash[VCC_HTABLE_SIZE];
  28. EXPORT_SYMBOL(vcc_hash);
  29. DEFINE_RWLOCK(vcc_sklist_lock);
  30. EXPORT_SYMBOL(vcc_sklist_lock);
  31. static void __vcc_insert_socket(struct sock *sk)
  32. {
  33. struct atm_vcc *vcc = atm_sk(sk);
  34. struct hlist_head *head = &vcc_hash[vcc->vci & (VCC_HTABLE_SIZE - 1)];
  35. sk->sk_hash = vcc->vci & (VCC_HTABLE_SIZE - 1);
  36. sk_add_node(sk, head);
  37. }
  38. void vcc_insert_socket(struct sock *sk)
  39. {
  40. write_lock_irq(&vcc_sklist_lock);
  41. __vcc_insert_socket(sk);
  42. write_unlock_irq(&vcc_sklist_lock);
  43. }
  44. EXPORT_SYMBOL(vcc_insert_socket);
  45. static void vcc_remove_socket(struct sock *sk)
  46. {
  47. write_lock_irq(&vcc_sklist_lock);
  48. sk_del_node_init(sk);
  49. write_unlock_irq(&vcc_sklist_lock);
  50. }
  51. static struct sk_buff *alloc_tx(struct atm_vcc *vcc, unsigned int size)
  52. {
  53. struct sk_buff *skb;
  54. struct sock *sk = sk_atm(vcc);
  55. if (sk_wmem_alloc_get(sk) && !atm_may_send(vcc, size)) {
  56. pr_debug("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n",
  57. sk_wmem_alloc_get(sk), size, sk->sk_sndbuf);
  58. return NULL;
  59. }
  60. while (!(skb = alloc_skb(size, GFP_KERNEL)))
  61. schedule();
  62. pr_debug("%d += %d\n", sk_wmem_alloc_get(sk), skb->truesize);
  63. atomic_add(skb->truesize, &sk->sk_wmem_alloc);
  64. return skb;
  65. }
  66. static void vcc_sock_destruct(struct sock *sk)
  67. {
  68. if (atomic_read(&sk->sk_rmem_alloc))
  69. printk(KERN_DEBUG "%s: rmem leakage (%d bytes) detected.\n",
  70. __func__, atomic_read(&sk->sk_rmem_alloc));
  71. if (atomic_read(&sk->sk_wmem_alloc))
  72. printk(KERN_DEBUG "%s: wmem leakage (%d bytes) detected.\n",
  73. __func__, atomic_read(&sk->sk_wmem_alloc));
  74. }
  75. static void vcc_def_wakeup(struct sock *sk)
  76. {
  77. read_lock(&sk->sk_callback_lock);
  78. if (sk_has_sleeper(sk))
  79. wake_up(sk->sk_sleep);
  80. read_unlock(&sk->sk_callback_lock);
  81. }
  82. static inline int vcc_writable(struct sock *sk)
  83. {
  84. struct atm_vcc *vcc = atm_sk(sk);
  85. return (vcc->qos.txtp.max_sdu +
  86. atomic_read(&sk->sk_wmem_alloc)) <= sk->sk_sndbuf;
  87. }
  88. static void vcc_write_space(struct sock *sk)
  89. {
  90. read_lock(&sk->sk_callback_lock);
  91. if (vcc_writable(sk)) {
  92. if (sk_has_sleeper(sk))
  93. wake_up_interruptible(sk->sk_sleep);
  94. sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
  95. }
  96. read_unlock(&sk->sk_callback_lock);
  97. }
  98. static struct proto vcc_proto = {
  99. .name = "VCC",
  100. .owner = THIS_MODULE,
  101. .obj_size = sizeof(struct atm_vcc),
  102. };
  103. int vcc_create(struct net *net, struct socket *sock, int protocol, int family)
  104. {
  105. struct sock *sk;
  106. struct atm_vcc *vcc;
  107. sock->sk = NULL;
  108. if (sock->type == SOCK_STREAM)
  109. return -EINVAL;
  110. sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto);
  111. if (!sk)
  112. return -ENOMEM;
  113. sock_init_data(sock, sk);
  114. sk->sk_state_change = vcc_def_wakeup;
  115. sk->sk_write_space = vcc_write_space;
  116. vcc = atm_sk(sk);
  117. vcc->dev = NULL;
  118. memset(&vcc->local, 0, sizeof(struct sockaddr_atmsvc));
  119. memset(&vcc->remote, 0, sizeof(struct sockaddr_atmsvc));
  120. vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
  121. atomic_set(&sk->sk_wmem_alloc, 1);
  122. atomic_set(&sk->sk_rmem_alloc, 0);
  123. vcc->push = NULL;
  124. vcc->pop = NULL;
  125. vcc->push_oam = NULL;
  126. vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
  127. vcc->atm_options = vcc->aal_options = 0;
  128. sk->sk_destruct = vcc_sock_destruct;
  129. return 0;
  130. }
  131. static void vcc_destroy_socket(struct sock *sk)
  132. {
  133. struct atm_vcc *vcc = atm_sk(sk);
  134. struct sk_buff *skb;
  135. set_bit(ATM_VF_CLOSE, &vcc->flags);
  136. clear_bit(ATM_VF_READY, &vcc->flags);
  137. if (vcc->dev) {
  138. if (vcc->dev->ops->close)
  139. vcc->dev->ops->close(vcc);
  140. if (vcc->push)
  141. vcc->push(vcc, NULL); /* atmarpd has no push */
  142. while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  143. atm_return(vcc, skb->truesize);
  144. kfree_skb(skb);
  145. }
  146. module_put(vcc->dev->ops->owner);
  147. atm_dev_put(vcc->dev);
  148. }
  149. vcc_remove_socket(sk);
  150. }
  151. int vcc_release(struct socket *sock)
  152. {
  153. struct sock *sk = sock->sk;
  154. if (sk) {
  155. lock_sock(sk);
  156. vcc_destroy_socket(sock->sk);
  157. release_sock(sk);
  158. sock_put(sk);
  159. }
  160. return 0;
  161. }
  162. void vcc_release_async(struct atm_vcc *vcc, int reply)
  163. {
  164. struct sock *sk = sk_atm(vcc);
  165. set_bit(ATM_VF_CLOSE, &vcc->flags);
  166. sk->sk_shutdown |= RCV_SHUTDOWN;
  167. sk->sk_err = -reply;
  168. clear_bit(ATM_VF_WAITING, &vcc->flags);
  169. sk->sk_state_change(sk);
  170. }
  171. EXPORT_SYMBOL(vcc_release_async);
  172. void atm_dev_release_vccs(struct atm_dev *dev)
  173. {
  174. int i;
  175. write_lock_irq(&vcc_sklist_lock);
  176. for (i = 0; i < VCC_HTABLE_SIZE; i++) {
  177. struct hlist_head *head = &vcc_hash[i];
  178. struct hlist_node *node, *tmp;
  179. struct sock *s;
  180. struct atm_vcc *vcc;
  181. sk_for_each_safe(s, node, tmp, head) {
  182. vcc = atm_sk(s);
  183. if (vcc->dev == dev) {
  184. vcc_release_async(vcc, -EPIPE);
  185. sk_del_node_init(s);
  186. }
  187. }
  188. }
  189. write_unlock_irq(&vcc_sklist_lock);
  190. }
  191. static int adjust_tp(struct atm_trafprm *tp, unsigned char aal)
  192. {
  193. int max_sdu;
  194. if (!tp->traffic_class)
  195. return 0;
  196. switch (aal) {
  197. case ATM_AAL0:
  198. max_sdu = ATM_CELL_SIZE-1;
  199. break;
  200. case ATM_AAL34:
  201. max_sdu = ATM_MAX_AAL34_PDU;
  202. break;
  203. default:
  204. pr_warning("AAL problems ... (%d)\n", aal);
  205. /* fall through */
  206. case ATM_AAL5:
  207. max_sdu = ATM_MAX_AAL5_PDU;
  208. }
  209. if (!tp->max_sdu)
  210. tp->max_sdu = max_sdu;
  211. else if (tp->max_sdu > max_sdu)
  212. return -EINVAL;
  213. if (!tp->max_cdv)
  214. tp->max_cdv = ATM_MAX_CDV;
  215. return 0;
  216. }
  217. static int check_ci(const struct atm_vcc *vcc, short vpi, int vci)
  218. {
  219. struct hlist_head *head = &vcc_hash[vci & (VCC_HTABLE_SIZE - 1)];
  220. struct hlist_node *node;
  221. struct sock *s;
  222. struct atm_vcc *walk;
  223. sk_for_each(s, node, head) {
  224. walk = atm_sk(s);
  225. if (walk->dev != vcc->dev)
  226. continue;
  227. if (test_bit(ATM_VF_ADDR, &walk->flags) && walk->vpi == vpi &&
  228. walk->vci == vci && ((walk->qos.txtp.traffic_class !=
  229. ATM_NONE && vcc->qos.txtp.traffic_class != ATM_NONE) ||
  230. (walk->qos.rxtp.traffic_class != ATM_NONE &&
  231. vcc->qos.rxtp.traffic_class != ATM_NONE)))
  232. return -EADDRINUSE;
  233. }
  234. /* allow VCCs with same VPI/VCI iff they don't collide on
  235. TX/RX (but we may refuse such sharing for other reasons,
  236. e.g. if protocol requires to have both channels) */
  237. return 0;
  238. }
  239. static int find_ci(const struct atm_vcc *vcc, short *vpi, int *vci)
  240. {
  241. static short p; /* poor man's per-device cache */
  242. static int c;
  243. short old_p;
  244. int old_c;
  245. int err;
  246. if (*vpi != ATM_VPI_ANY && *vci != ATM_VCI_ANY) {
  247. err = check_ci(vcc, *vpi, *vci);
  248. return err;
  249. }
  250. /* last scan may have left values out of bounds for current device */
  251. if (*vpi != ATM_VPI_ANY)
  252. p = *vpi;
  253. else if (p >= 1 << vcc->dev->ci_range.vpi_bits)
  254. p = 0;
  255. if (*vci != ATM_VCI_ANY)
  256. c = *vci;
  257. else if (c < ATM_NOT_RSV_VCI || c >= 1 << vcc->dev->ci_range.vci_bits)
  258. c = ATM_NOT_RSV_VCI;
  259. old_p = p;
  260. old_c = c;
  261. do {
  262. if (!check_ci(vcc, p, c)) {
  263. *vpi = p;
  264. *vci = c;
  265. return 0;
  266. }
  267. if (*vci == ATM_VCI_ANY) {
  268. c++;
  269. if (c >= 1 << vcc->dev->ci_range.vci_bits)
  270. c = ATM_NOT_RSV_VCI;
  271. }
  272. if ((c == ATM_NOT_RSV_VCI || *vci != ATM_VCI_ANY) &&
  273. *vpi == ATM_VPI_ANY) {
  274. p++;
  275. if (p >= 1 << vcc->dev->ci_range.vpi_bits)
  276. p = 0;
  277. }
  278. } while (old_p != p || old_c != c);
  279. return -EADDRINUSE;
  280. }
  281. static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, short vpi,
  282. int vci)
  283. {
  284. struct sock *sk = sk_atm(vcc);
  285. int error;
  286. if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
  287. vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
  288. vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
  289. return -EINVAL;
  290. if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
  291. return -EPERM;
  292. error = -ENODEV;
  293. if (!try_module_get(dev->ops->owner))
  294. return error;
  295. vcc->dev = dev;
  296. write_lock_irq(&vcc_sklist_lock);
  297. if (test_bit(ATM_DF_REMOVED, &dev->flags) ||
  298. (error = find_ci(vcc, &vpi, &vci))) {
  299. write_unlock_irq(&vcc_sklist_lock);
  300. goto fail_module_put;
  301. }
  302. vcc->vpi = vpi;
  303. vcc->vci = vci;
  304. __vcc_insert_socket(sk);
  305. write_unlock_irq(&vcc_sklist_lock);
  306. switch (vcc->qos.aal) {
  307. case ATM_AAL0:
  308. error = atm_init_aal0(vcc);
  309. vcc->stats = &dev->stats.aal0;
  310. break;
  311. case ATM_AAL34:
  312. error = atm_init_aal34(vcc);
  313. vcc->stats = &dev->stats.aal34;
  314. break;
  315. case ATM_NO_AAL:
  316. /* ATM_AAL5 is also used in the "0 for default" case */
  317. vcc->qos.aal = ATM_AAL5;
  318. /* fall through */
  319. case ATM_AAL5:
  320. error = atm_init_aal5(vcc);
  321. vcc->stats = &dev->stats.aal5;
  322. break;
  323. default:
  324. error = -EPROTOTYPE;
  325. }
  326. if (!error)
  327. error = adjust_tp(&vcc->qos.txtp, vcc->qos.aal);
  328. if (!error)
  329. error = adjust_tp(&vcc->qos.rxtp, vcc->qos.aal);
  330. if (error)
  331. goto fail;
  332. pr_debug("VCC %d.%d, AAL %d\n", vpi, vci, vcc->qos.aal);
  333. pr_debug(" TX: %d, PCR %d..%d, SDU %d\n",
  334. vcc->qos.txtp.traffic_class,
  335. vcc->qos.txtp.min_pcr,
  336. vcc->qos.txtp.max_pcr,
  337. vcc->qos.txtp.max_sdu);
  338. pr_debug(" RX: %d, PCR %d..%d, SDU %d\n",
  339. vcc->qos.rxtp.traffic_class,
  340. vcc->qos.rxtp.min_pcr,
  341. vcc->qos.rxtp.max_pcr,
  342. vcc->qos.rxtp.max_sdu);
  343. if (dev->ops->open) {
  344. error = dev->ops->open(vcc);
  345. if (error)
  346. goto fail;
  347. }
  348. return 0;
  349. fail:
  350. vcc_remove_socket(sk);
  351. fail_module_put:
  352. module_put(dev->ops->owner);
  353. /* ensure we get dev module ref count correct */
  354. vcc->dev = NULL;
  355. return error;
  356. }
  357. int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
  358. {
  359. struct atm_dev *dev;
  360. struct atm_vcc *vcc = ATM_SD(sock);
  361. int error;
  362. pr_debug("(vpi %d, vci %d)\n", vpi, vci);
  363. if (sock->state == SS_CONNECTED)
  364. return -EISCONN;
  365. if (sock->state != SS_UNCONNECTED)
  366. return -EINVAL;
  367. if (!(vpi || vci))
  368. return -EINVAL;
  369. if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
  370. clear_bit(ATM_VF_PARTIAL, &vcc->flags);
  371. else
  372. if (test_bit(ATM_VF_PARTIAL, &vcc->flags))
  373. return -EINVAL;
  374. pr_debug("(TX: cl %d,bw %d-%d,sdu %d; "
  375. "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n",
  376. vcc->qos.txtp.traffic_class, vcc->qos.txtp.min_pcr,
  377. vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_sdu,
  378. vcc->qos.rxtp.traffic_class, vcc->qos.rxtp.min_pcr,
  379. vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_sdu,
  380. vcc->qos.aal == ATM_AAL5 ? "" :
  381. vcc->qos.aal == ATM_AAL0 ? "" : " ??? code ",
  382. vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
  383. if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
  384. return -EBADFD;
  385. if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
  386. vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
  387. return -EINVAL;
  388. if (likely(itf != ATM_ITF_ANY)) {
  389. dev = try_then_request_module(atm_dev_lookup(itf),
  390. "atm-device-%d", itf);
  391. } else {
  392. dev = NULL;
  393. mutex_lock(&atm_dev_mutex);
  394. if (!list_empty(&atm_devs)) {
  395. dev = list_entry(atm_devs.next,
  396. struct atm_dev, dev_list);
  397. atm_dev_hold(dev);
  398. }
  399. mutex_unlock(&atm_dev_mutex);
  400. }
  401. if (!dev)
  402. return -ENODEV;
  403. error = __vcc_connect(vcc, dev, vpi, vci);
  404. if (error) {
  405. atm_dev_put(dev);
  406. return error;
  407. }
  408. if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
  409. set_bit(ATM_VF_PARTIAL, &vcc->flags);
  410. if (test_bit(ATM_VF_READY, &ATM_SD(sock)->flags))
  411. sock->state = SS_CONNECTED;
  412. return 0;
  413. }
  414. int vcc_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
  415. size_t size, int flags)
  416. {
  417. struct sock *sk = sock->sk;
  418. struct atm_vcc *vcc;
  419. struct sk_buff *skb;
  420. int copied, error = -EINVAL;
  421. if (sock->state != SS_CONNECTED)
  422. return -ENOTCONN;
  423. if (flags & ~MSG_DONTWAIT) /* only handle MSG_DONTWAIT */
  424. return -EOPNOTSUPP;
  425. vcc = ATM_SD(sock);
  426. if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
  427. test_bit(ATM_VF_CLOSE, &vcc->flags) ||
  428. !test_bit(ATM_VF_READY, &vcc->flags))
  429. return 0;
  430. skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error);
  431. if (!skb)
  432. return error;
  433. copied = skb->len;
  434. if (copied > size) {
  435. copied = size;
  436. msg->msg_flags |= MSG_TRUNC;
  437. }
  438. error = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  439. if (error)
  440. return error;
  441. sock_recv_ts_and_drops(msg, sk, skb);
  442. pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc), skb->truesize);
  443. atm_return(vcc, skb->truesize);
  444. skb_free_datagram(sk, skb);
  445. return copied;
  446. }
  447. int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
  448. size_t total_len)
  449. {
  450. struct sock *sk = sock->sk;
  451. DEFINE_WAIT(wait);
  452. struct atm_vcc *vcc;
  453. struct sk_buff *skb;
  454. int eff, error;
  455. const void __user *buff;
  456. int size;
  457. lock_sock(sk);
  458. if (sock->state != SS_CONNECTED) {
  459. error = -ENOTCONN;
  460. goto out;
  461. }
  462. if (m->msg_name) {
  463. error = -EISCONN;
  464. goto out;
  465. }
  466. if (m->msg_iovlen != 1) {
  467. error = -ENOSYS; /* fix this later @@@ */
  468. goto out;
  469. }
  470. buff = m->msg_iov->iov_base;
  471. size = m->msg_iov->iov_len;
  472. vcc = ATM_SD(sock);
  473. if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
  474. test_bit(ATM_VF_CLOSE, &vcc->flags) ||
  475. !test_bit(ATM_VF_READY, &vcc->flags)) {
  476. error = -EPIPE;
  477. send_sig(SIGPIPE, current, 0);
  478. goto out;
  479. }
  480. if (!size) {
  481. error = 0;
  482. goto out;
  483. }
  484. if (size < 0 || size > vcc->qos.txtp.max_sdu) {
  485. error = -EMSGSIZE;
  486. goto out;
  487. }
  488. eff = (size+3) & ~3; /* align to word boundary */
  489. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  490. error = 0;
  491. while (!(skb = alloc_tx(vcc, eff))) {
  492. if (m->msg_flags & MSG_DONTWAIT) {
  493. error = -EAGAIN;
  494. break;
  495. }
  496. schedule();
  497. if (signal_pending(current)) {
  498. error = -ERESTARTSYS;
  499. break;
  500. }
  501. if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
  502. test_bit(ATM_VF_CLOSE, &vcc->flags) ||
  503. !test_bit(ATM_VF_READY, &vcc->flags)) {
  504. error = -EPIPE;
  505. send_sig(SIGPIPE, current, 0);
  506. break;
  507. }
  508. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  509. }
  510. finish_wait(sk->sk_sleep, &wait);
  511. if (error)
  512. goto out;
  513. skb->dev = NULL; /* for paths shared with net_device interfaces */
  514. ATM_SKB(skb)->atm_options = vcc->atm_options;
  515. if (copy_from_user(skb_put(skb, size), buff, size)) {
  516. kfree_skb(skb);
  517. error = -EFAULT;
  518. goto out;
  519. }
  520. if (eff != size)
  521. memset(skb->data + size, 0, eff-size);
  522. error = vcc->dev->ops->send(vcc, skb);
  523. error = error ? error : size;
  524. out:
  525. release_sock(sk);
  526. return error;
  527. }
  528. unsigned int vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
  529. {
  530. struct sock *sk = sock->sk;
  531. struct atm_vcc *vcc;
  532. unsigned int mask;
  533. sock_poll_wait(file, sk->sk_sleep, wait);
  534. mask = 0;
  535. vcc = ATM_SD(sock);
  536. /* exceptional events */
  537. if (sk->sk_err)
  538. mask = POLLERR;
  539. if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
  540. test_bit(ATM_VF_CLOSE, &vcc->flags))
  541. mask |= POLLHUP;
  542. /* readable? */
  543. if (!skb_queue_empty(&sk->sk_receive_queue))
  544. mask |= POLLIN | POLLRDNORM;
  545. /* writable? */
  546. if (sock->state == SS_CONNECTING &&
  547. test_bit(ATM_VF_WAITING, &vcc->flags))
  548. return mask;
  549. if (vcc->qos.txtp.traffic_class != ATM_NONE &&
  550. vcc_writable(sk))
  551. mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
  552. return mask;
  553. }
  554. static int atm_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
  555. {
  556. int error;
  557. /*
  558. * Don't let the QoS change the already connected AAL type nor the
  559. * traffic class.
  560. */
  561. if (qos->aal != vcc->qos.aal ||
  562. qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
  563. qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
  564. return -EINVAL;
  565. error = adjust_tp(&qos->txtp, qos->aal);
  566. if (!error)
  567. error = adjust_tp(&qos->rxtp, qos->aal);
  568. if (error)
  569. return error;
  570. if (!vcc->dev->ops->change_qos)
  571. return -EOPNOTSUPP;
  572. if (sk_atm(vcc)->sk_family == AF_ATMPVC)
  573. return vcc->dev->ops->change_qos(vcc, qos, ATM_MF_SET);
  574. return svc_change_qos(vcc, qos);
  575. }
  576. static int check_tp(const struct atm_trafprm *tp)
  577. {
  578. /* @@@ Should be merged with adjust_tp */
  579. if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS)
  580. return 0;
  581. if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
  582. !tp->max_pcr)
  583. return -EINVAL;
  584. if (tp->min_pcr == ATM_MAX_PCR)
  585. return -EINVAL;
  586. if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
  587. tp->min_pcr > tp->max_pcr)
  588. return -EINVAL;
  589. /*
  590. * We allow pcr to be outside [min_pcr,max_pcr], because later
  591. * adjustment may still push it in the valid range.
  592. */
  593. return 0;
  594. }
  595. static int check_qos(const struct atm_qos *qos)
  596. {
  597. int error;
  598. if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
  599. return -EINVAL;
  600. if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
  601. qos->txtp.traffic_class && qos->rxtp.traffic_class &&
  602. qos->txtp.traffic_class != ATM_ANYCLASS &&
  603. qos->rxtp.traffic_class != ATM_ANYCLASS)
  604. return -EINVAL;
  605. error = check_tp(&qos->txtp);
  606. if (error)
  607. return error;
  608. return check_tp(&qos->rxtp);
  609. }
  610. int vcc_setsockopt(struct socket *sock, int level, int optname,
  611. char __user *optval, unsigned int optlen)
  612. {
  613. struct atm_vcc *vcc;
  614. unsigned long value;
  615. int error;
  616. if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
  617. return -EINVAL;
  618. vcc = ATM_SD(sock);
  619. switch (optname) {
  620. case SO_ATMQOS:
  621. {
  622. struct atm_qos qos;
  623. if (copy_from_user(&qos, optval, sizeof(qos)))
  624. return -EFAULT;
  625. error = check_qos(&qos);
  626. if (error)
  627. return error;
  628. if (sock->state == SS_CONNECTED)
  629. return atm_change_qos(vcc, &qos);
  630. if (sock->state != SS_UNCONNECTED)
  631. return -EBADFD;
  632. vcc->qos = qos;
  633. set_bit(ATM_VF_HASQOS, &vcc->flags);
  634. return 0;
  635. }
  636. case SO_SETCLP:
  637. if (get_user(value, (unsigned long __user *)optval))
  638. return -EFAULT;
  639. if (value)
  640. vcc->atm_options |= ATM_ATMOPT_CLP;
  641. else
  642. vcc->atm_options &= ~ATM_ATMOPT_CLP;
  643. return 0;
  644. default:
  645. if (level == SOL_SOCKET)
  646. return -EINVAL;
  647. break;
  648. }
  649. if (!vcc->dev || !vcc->dev->ops->setsockopt)
  650. return -EINVAL;
  651. return vcc->dev->ops->setsockopt(vcc, level, optname, optval, optlen);
  652. }
  653. int vcc_getsockopt(struct socket *sock, int level, int optname,
  654. char __user *optval, int __user *optlen)
  655. {
  656. struct atm_vcc *vcc;
  657. int len;
  658. if (get_user(len, optlen))
  659. return -EFAULT;
  660. if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
  661. return -EINVAL;
  662. vcc = ATM_SD(sock);
  663. switch (optname) {
  664. case SO_ATMQOS:
  665. if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
  666. return -EINVAL;
  667. return copy_to_user(optval, &vcc->qos, sizeof(vcc->qos))
  668. ? -EFAULT : 0;
  669. case SO_SETCLP:
  670. return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 : 0,
  671. (unsigned long __user *)optval) ? -EFAULT : 0;
  672. case SO_ATMPVC:
  673. {
  674. struct sockaddr_atmpvc pvc;
  675. if (!vcc->dev || !test_bit(ATM_VF_ADDR, &vcc->flags))
  676. return -ENOTCONN;
  677. pvc.sap_family = AF_ATMPVC;
  678. pvc.sap_addr.itf = vcc->dev->number;
  679. pvc.sap_addr.vpi = vcc->vpi;
  680. pvc.sap_addr.vci = vcc->vci;
  681. return copy_to_user(optval, &pvc, sizeof(pvc)) ? -EFAULT : 0;
  682. }
  683. default:
  684. if (level == SOL_SOCKET)
  685. return -EINVAL;
  686. break;
  687. }
  688. if (!vcc->dev || !vcc->dev->ops->getsockopt)
  689. return -EINVAL;
  690. return vcc->dev->ops->getsockopt(vcc, level, optname, optval, len);
  691. }
  692. static int __init atm_init(void)
  693. {
  694. int error;
  695. error = proto_register(&vcc_proto, 0);
  696. if (error < 0)
  697. goto out;
  698. error = atmpvc_init();
  699. if (error < 0) {
  700. pr_err("atmpvc_init() failed with %d\n", error);
  701. goto out_unregister_vcc_proto;
  702. }
  703. error = atmsvc_init();
  704. if (error < 0) {
  705. pr_err("atmsvc_init() failed with %d\n", error);
  706. goto out_atmpvc_exit;
  707. }
  708. error = atm_proc_init();
  709. if (error < 0) {
  710. pr_err("atm_proc_init() failed with %d\n", error);
  711. goto out_atmsvc_exit;
  712. }
  713. error = atm_sysfs_init();
  714. if (error < 0) {
  715. pr_err("atm_sysfs_init() failed with %d\n", error);
  716. goto out_atmproc_exit;
  717. }
  718. out:
  719. return error;
  720. out_atmproc_exit:
  721. atm_proc_exit();
  722. out_atmsvc_exit:
  723. atmsvc_exit();
  724. out_atmpvc_exit:
  725. atmsvc_exit();
  726. out_unregister_vcc_proto:
  727. proto_unregister(&vcc_proto);
  728. goto out;
  729. }
  730. static void __exit atm_exit(void)
  731. {
  732. atm_proc_exit();
  733. atm_sysfs_exit();
  734. atmsvc_exit();
  735. atmpvc_exit();
  736. proto_unregister(&vcc_proto);
  737. }
  738. subsys_initcall(atm_init);
  739. module_exit(atm_exit);
  740. MODULE_LICENSE("GPL");
  741. MODULE_ALIAS_NETPROTO(PF_ATMPVC);
  742. MODULE_ALIAS_NETPROTO(PF_ATMSVC);