开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
common.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：30k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

common.c：源码内容
  1. /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
  3. /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
  6. #include <linux/config.h>
  7. #include <linux/module.h>
  8. #include <linux/kmod.h>
  9. #include <linux/net.h> /* struct socket, struct net_proto, struct
  10.    proto_ops */
  11. #include <linux/atm.h> /* ATM stuff */
  12. #include <linux/atmdev.h>
  13. #include <linux/atmclip.h> /* CLIP_*ENCAP */
  14. #include <linux/atmarp.h> /* manifest constants */
  15. #include <linux/sonet.h> /* for ioctls */
  16. #include <linux/socket.h> /* SOL_SOCKET */
  17. #include <linux/errno.h> /* error codes */
  18. #include <linux/capability.h>
  19. #include <linux/mm.h> /* verify_area */
  20. #include <linux/sched.h>
  21. #include <linux/time.h> /* struct timeval */
  22. #include <linux/skbuff.h>
  23. #include <linux/bitops.h>
  24. #include <net/sock.h> /* struct sock */
  26. #include <asm/uaccess.h>
  27. #include <asm/atomic.h>
  28. #include <asm/poll.h>
  29. #include <asm/ioctls.h>
  31. #if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
  32. #include <linux/atmlec.h>
  33. #include "lec.h"
  34. #include "lec_arpc.h"
  35. struct atm_lane_ops atm_lane_ops;
  36. #endif
  37. #ifdef CONFIG_ATM_LANE_MODULE
  38. EXPORT_SYMBOL(atm_lane_ops);
  39. #endif
  41. #if defined(CONFIG_ATM_MPOA) || defined(CONFIG_ATM_MPOA_MODULE)
  42. #include <linux/atmmpc.h>
  43. #include "mpc.h"
  44. struct atm_mpoa_ops atm_mpoa_ops;
  45. #endif
  46. #ifdef CONFIG_ATM_MPOA_MODULE
  47. EXPORT_SYMBOL(atm_mpoa_ops);
  48. #ifndef CONFIG_ATM_LANE_MODULE
  49. EXPORT_SYMBOL(atm_lane_ops);
  50. #endif
  51. #endif
  53. #if defined(CONFIG_ATM_TCP) || defined(CONFIG_ATM_TCP_MODULE)
  54. #include <linux/atm_tcp.h>
  55. #ifdef CONFIG_ATM_TCP_MODULE
  56. struct atm_tcp_ops atm_tcp_ops;
  57. EXPORT_SYMBOL(atm_tcp_ops);
  58. #endif
  59. #endif
  61. #if defined(CONFIG_PPPOATM) || defined(CONFIG_PPPOATM_MODULE)
  62. int (*pppoatm_ioctl_hook)(struct atm_vcc *, unsigned int, unsigned long);
  63. EXPORT_SYMBOL(pppoatm_ioctl_hook);
  64. #endif
  66. #include "resources.h" /* atm_find_dev */
  67. #include "common.h" /* prototypes */
  68. #include "protocols.h" /* atm_init_<transport> */
  69. #include "addr.h" /* address registry */
  70. #ifdef CONFIG_ATM_CLIP
  71. #include <net/atmclip.h> /* for clip_create */
  72. #endif
  73. #include "signaling.h" /* for WAITING and sigd_attach */
  76. #if 0
  77. #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
  78. #else
  79. #define DPRINTK(format,args...)
  80. #endif
  82. spinlock_t atm_dev_lock = SPIN_LOCK_UNLOCKED;
  84. static struct sk_buff *alloc_tx(struct atm_vcc *vcc,unsigned int size)
  85. {
  86. struct sk_buff *skb;
  88. if (atomic_read(&vcc->tx_inuse) && !atm_may_send(vcc,size)) {
  89. DPRINTK("Sorry: tx_inuse = %d, size = %d, sndbuf = %dn",
  90.     atomic_read(&vcc->tx_inuse),size,vcc->sk->sndbuf);
  91. return NULL;
  92. }
  93. while (!(skb = alloc_skb(size,GFP_KERNEL))) schedule();
  94. DPRINTK("AlTx %d += %dn",atomic_read(&vcc->tx_inuse),skb->truesize);
  95. atomic_add(skb->truesize+ATM_PDU_OVHD,&vcc->tx_inuse);
  96. return skb;
  97. }
  100. int atm_create(struct socket *sock,int protocol,int family)
  101. {
  102. struct sock *sk;
  103. struct atm_vcc *vcc;
  105. sock->sk = NULL;
  106. if (sock->type == SOCK_STREAM) return -EINVAL;
  107. if (!(sk = alloc_atm_vcc_sk(family))) return -ENOMEM;
  108. vcc = sk->protinfo.af_atm;
  109. memset(&vcc->flags,0,sizeof(vcc->flags));
  110. vcc->dev = NULL;
  111. vcc->family = sock->ops->family;
  112. vcc->alloc_tx = alloc_tx;
  113. vcc->callback = NULL;
  114. memset(&vcc->local,0,sizeof(struct sockaddr_atmsvc));
  115. memset(&vcc->remote,0,sizeof(struct sockaddr_atmsvc));
  116. vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
  117. atomic_set(&vcc->tx_inuse,0);
  118. atomic_set(&vcc->rx_inuse,0);
  119. vcc->push = NULL;
  120. vcc->pop = NULL;
  121. vcc->push_oam = NULL;
  122. vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
  123. vcc->atm_options = vcc->aal_options = 0;
  124. vcc->timestamp.tv_sec = vcc->timestamp.tv_usec = 0;
  125. init_waitqueue_head(&vcc->sleep);
  126. skb_queue_head_init(&vcc->recvq);
  127. skb_queue_head_init(&vcc->listenq);
  128. sk->sleep = &vcc->sleep;
  129. sock->sk = sk;
  130. return 0;
  131. }
  134. void atm_release_vcc_sk(struct sock *sk,int free_sk)
  135. {
  136. struct atm_vcc *vcc;
  137. struct sk_buff *skb;
  139. vcc = sk->protinfo.af_atm;
  140. clear_bit(ATM_VF_READY,&vcc->flags);
  141. if (vcc->dev) {
  142. if (vcc->dev->ops->close) vcc->dev->ops->close(vcc);
  143. if (vcc->push) vcc->push(vcc,NULL); /* atmarpd has no push */
  144. while ((skb = skb_dequeue(&vcc->recvq))) {
  145. atm_return(vcc,skb->truesize);
  146. if (vcc->dev->ops->free_rx_skb)
  147. vcc->dev->ops->free_rx_skb(vcc,skb);
  148. else kfree_skb(skb);
  149. }
  150. spin_lock (&atm_dev_lock);
  151. fops_put (vcc->dev->ops);
  152. if (atomic_read(&vcc->rx_inuse))
  153. printk(KERN_WARNING "atm_release_vcc: strange ... "
  154.     "rx_inuse == %d after closingn",
  155.     atomic_read(&vcc->rx_inuse));
  156. bind_vcc(vcc,NULL);
  157. } else
  158. spin_lock (&atm_dev_lock);
  160. if (free_sk) free_atm_vcc_sk(sk);
  162. spin_unlock (&atm_dev_lock);
  163. }
  166. int atm_release(struct socket *sock)
  167. {
  168. if (sock->sk)
  169. atm_release_vcc_sk(sock->sk,1);
  170. return 0;
  171. }
  174. void atm_async_release_vcc(struct atm_vcc *vcc,int reply)
  175. {
  176. set_bit(ATM_VF_CLOSE,&vcc->flags);
  177. vcc->reply = reply;
  178. wake_up(&vcc->sleep);
  179. }
  182. EXPORT_SYMBOL(atm_async_release_vcc);
  185. static int adjust_tp(struct atm_trafprm *tp,unsigned char aal)
  186. {
  187. int max_sdu;
  189. if (!tp->traffic_class) return 0;
  190. switch (aal) {
  191. case ATM_AAL0:
  192. max_sdu = ATM_CELL_SIZE-1;
  193. break;
  194. case ATM_AAL34:
  195. max_sdu = ATM_MAX_AAL34_PDU;
  196. break;
  197. default:
  198. printk(KERN_WARNING "ATM: AAL problems ... "
  199.     "(%d)n",aal);
  200. /* fall through */
  201. case ATM_AAL5:
  202. max_sdu = ATM_MAX_AAL5_PDU;
  203. }
  204. if (!tp->max_sdu) tp->max_sdu = max_sdu;
  205. else if (tp->max_sdu > max_sdu) return -EINVAL;
  206. if (!tp->max_cdv) tp->max_cdv = ATM_MAX_CDV;
  207. return 0;
  208. }
  211. static int atm_do_connect_dev(struct atm_vcc *vcc,struct atm_dev *dev,int vpi,
  212.     int vci)
  213. {
  214. int error;
  216. if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
  217.     vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
  218.     vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
  219. return -EINVAL;
  220. if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
  221. return -EPERM;
  222. error = 0;
  223. bind_vcc(vcc,dev);
  224. switch (vcc->qos.aal) {
  225. case ATM_AAL0:
  226. error = atm_init_aal0(vcc);
  227. vcc->stats = &dev->stats.aal0;
  228. break;
  229. case ATM_AAL34:
  230. error = atm_init_aal34(vcc);
  231. vcc->stats = &dev->stats.aal34;
  232. break;
  233. case ATM_NO_AAL:
  234. /* ATM_AAL5 is also used in the "0 for default" case */
  235. vcc->qos.aal = ATM_AAL5;
  236. /* fall through */
  237. case ATM_AAL5:
  238. error = atm_init_aal5(vcc);
  239. vcc->stats = &dev->stats.aal5;
  240. break;
  241. default:
  242. error = -EPROTOTYPE;
  243. }
  244. if (!error) error = adjust_tp(&vcc->qos.txtp,vcc->qos.aal);
  245. if (!error) error = adjust_tp(&vcc->qos.rxtp,vcc->qos.aal);
  246. if (error) {
  247. bind_vcc(vcc,NULL);
  248. return error;
  249. }
  250. DPRINTK("VCC %d.%d, AAL %dn",vpi,vci,vcc->qos.aal);
  251. DPRINTK("  TX: %d, PCR %d..%d, SDU %dn",vcc->qos.txtp.traffic_class,
  252.     vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,vcc->qos.txtp.max_sdu);
  253. DPRINTK("  RX: %d, PCR %d..%d, SDU %dn",vcc->qos.rxtp.traffic_class,
  254.     vcc->qos.rxtp.min_pcr,vcc->qos.rxtp.max_pcr,vcc->qos.rxtp.max_sdu);
  255. fops_get (dev->ops);
  256. if (dev->ops->open) {
  257. error = dev->ops->open(vcc,vpi,vci);
  258. if (error) {
  259. fops_put (dev->ops);
  260. bind_vcc(vcc,NULL);
  261. return error;
  262. }
  263. }
  264. return 0;
  265. }
  268. static int atm_do_connect(struct atm_vcc *vcc,int itf,int vpi,int vci)
  269. {
  270. struct atm_dev *dev;
  271. int return_val;
  273. spin_lock (&atm_dev_lock);
  274. dev = atm_find_dev(itf);
  275. if (!dev)
  276. return_val =  -ENODEV;
  277. else
  278. return_val = atm_do_connect_dev(vcc,dev,vpi,vci);
  280. spin_unlock (&atm_dev_lock);
  282. return return_val;
  283. }
  286. int atm_connect_vcc(struct atm_vcc *vcc,int itf,short vpi,int vci)
  287. {
  288. if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
  289. clear_bit(ATM_VF_PARTIAL,&vcc->flags);
  290. else if (test_bit(ATM_VF_PARTIAL,&vcc->flags)) return -EINVAL;
  291. printk(KERN_DEBUG "atm_connect (TX: cl %d,bw %d-%d,sdu %d; "
  292.     "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)n",
  293.     vcc->qos.txtp.traffic_class,vcc->qos.txtp.min_pcr,
  294.     vcc->qos.txtp.max_pcr,vcc->qos.txtp.max_sdu,
  295.     vcc->qos.rxtp.traffic_class,vcc->qos.rxtp.min_pcr,
  296.     vcc->qos.rxtp.max_pcr,vcc->qos.rxtp.max_sdu,
  297.     vcc->qos.aal == ATM_AAL5 ? "" : vcc->qos.aal == ATM_AAL0 ? "" :
  298.     " ??? code ",vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
  299. if (!test_bit(ATM_VF_HASQOS,&vcc->flags)) return -EBADFD;
  300. if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
  301.     vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
  302. return -EINVAL;
  303. if (itf != ATM_ITF_ANY) {
  304. int error;
  306. error = atm_do_connect(vcc,itf,vpi,vci);
  307. if (error) return error;
  308. }
  309. else {
  310. struct atm_dev *dev;
  312. spin_lock (&atm_dev_lock);
  313. for (dev = atm_devs; dev; dev = dev->next)
  314. if (!atm_do_connect_dev(vcc,dev,vpi,vci)) break;
  315. spin_unlock (&atm_dev_lock);
  316. if (!dev) return -ENODEV;
  317. }
  318. if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
  319. set_bit(ATM_VF_PARTIAL,&vcc->flags);
  320. return 0;
  321. }
  324. int atm_connect(struct socket *sock,int itf,short vpi,int vci)
  325. {
  326. int error;
  328. DPRINTK("atm_connect (vpi %d, vci %d)n",vpi,vci);
  329. if (sock->state == SS_CONNECTED) return -EISCONN;
  330. if (sock->state != SS_UNCONNECTED) return -EINVAL;
  331. if (!(vpi || vci)) return -EINVAL;
  332. error = atm_connect_vcc(ATM_SD(sock),itf,vpi,vci);
  333. if (error) return error;
  334. if (test_bit(ATM_VF_READY,&ATM_SD(sock)->flags))
  335. sock->state = SS_CONNECTED;
  336. return 0;
  337. }
  340. int atm_recvmsg(struct socket *sock,struct msghdr *m,int total_len,
  341.     int flags,struct scm_cookie *scm)
  342. {
  343. DECLARE_WAITQUEUE(wait,current);
  344. struct atm_vcc *vcc;
  345. struct sk_buff *skb;
  346. int eff_len,error;
  347. void *buff;
  348. int size;
  350. if (sock->state != SS_CONNECTED) return -ENOTCONN;
  351. if (flags & ~MSG_DONTWAIT) return -EOPNOTSUPP;
  352. if (m->msg_iovlen != 1) return -ENOSYS; /* fix this later @@@ */
  353. buff = m->msg_iov->iov_base;
  354. size = m->msg_iov->iov_len;
  355. vcc = ATM_SD(sock);
  356. add_wait_queue(&vcc->sleep,&wait);
  357. set_current_state(TASK_INTERRUPTIBLE);
  358. error = 1; /* <= 0 is error */
  359. while (!(skb = skb_dequeue(&vcc->recvq))) {
  360. if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
  361.     test_bit(ATM_VF_CLOSE,&vcc->flags)) {
  362. error = vcc->reply;
  363. break;
  364. }
  365. if (!test_bit(ATM_VF_READY,&vcc->flags)) {
  366. error = 0;
  367. break;
  368. }
  369. if (flags & MSG_DONTWAIT) {
  370. error = -EAGAIN;
  371. break;
  372. }
  373. schedule();
  374. set_current_state(TASK_INTERRUPTIBLE);
  375. if (signal_pending(current)) {
  376. error = -ERESTARTSYS;
  377. break;
  378. }
  379. }
  380. set_current_state(TASK_RUNNING);
  381. remove_wait_queue(&vcc->sleep,&wait);
  382. if (error <= 0) return error;
  383. vcc->timestamp = skb->stamp;
  384. eff_len = skb->len > size ? size : skb->len;
  385. if (skb->len > size) /* Not fit ?  Report it... */
  386. m->msg_flags |= MSG_TRUNC;
  387. if (vcc->dev->ops->feedback)
  388. vcc->dev->ops->feedback(vcc,skb,(unsigned long) skb->data,
  389.     (unsigned long) buff,eff_len);
  390. DPRINTK("RcvM %d -= %dn",atomic_read(&vcc->rx_inuse),skb->truesize);
  391. atm_return(vcc,skb->truesize);
  392. if (ATM_SKB(skb)->iovcnt) { /* @@@ hack */
  393. /* iovcnt set, use scatter-gather for receive */
  394. int el, cnt;
  395. struct iovec *iov = (struct iovec *)skb->data;
  396. unsigned char *p = (unsigned char *)buff;
  398. el = eff_len;
  399. error = 0;
  400. for (cnt = 0; (cnt < ATM_SKB(skb)->iovcnt) && el; cnt++) {
  401. /*printk("s-g???: %p -> %p (%d)n",iov->iov_base,p,iov->iov_len);*/
  402. error = copy_to_user(p,iov->iov_base,
  403.     (iov->iov_len > el) ? el : iov->iov_len) ?
  404.     -EFAULT : 0;
  405. if (error) break;
  406. p += iov->iov_len;
  407. el -= (iov->iov_len > el)?el:iov->iov_len;
  408. iov++;
  409. }
  410. if (!vcc->dev->ops->free_rx_skb) kfree_skb(skb);
  411. else vcc->dev->ops->free_rx_skb(vcc, skb);
  412. return error ? error : eff_len;
  413. }
  414. error = copy_to_user(buff,skb->data,eff_len) ? -EFAULT : 0;
  415. if (!vcc->dev->ops->free_rx_skb) kfree_skb(skb);
  416. else vcc->dev->ops->free_rx_skb(vcc, skb);
  417. return error ? error : eff_len;
  418. }
  421. int atm_sendmsg(struct socket *sock,struct msghdr *m,int total_len,
  422.     struct scm_cookie *scm)
  423. {
  424. DECLARE_WAITQUEUE(wait,current);
  425. struct atm_vcc *vcc;
  426. struct sk_buff *skb;
  427. int eff,error;
  428. const void *buff;
  429. int size;
  431. if (sock->state != SS_CONNECTED) return -ENOTCONN;
  432. if (m->msg_name) return -EISCONN;
  433. if (m->msg_iovlen != 1) return -ENOSYS; /* fix this later @@@ */
  434. buff = m->msg_iov->iov_base;
  435. size = m->msg_iov->iov_len;
  436. vcc = ATM_SD(sock);
  437. if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
  438.     test_bit(ATM_VF_CLOSE,&vcc->flags))
  439. return vcc->reply;
  440. if (!test_bit(ATM_VF_READY,&vcc->flags)) return -EPIPE;
  441. if (!size) return 0;
  442. if (size < 0 || size > vcc->qos.txtp.max_sdu) return -EMSGSIZE;
  443. /* verify_area is done by net/socket.c */
  444. eff = (size+3) & ~3; /* align to word boundary */
  445. add_wait_queue(&vcc->sleep,&wait);
  446. set_current_state(TASK_INTERRUPTIBLE);
  447. error = 0;
  448. while (!(skb = vcc->alloc_tx(vcc,eff))) {
  449. if (m->msg_flags & MSG_DONTWAIT) {
  450. error = -EAGAIN;
  451. break;
  452. }
  453. schedule();
  454. set_current_state(TASK_INTERRUPTIBLE);
  455. if (signal_pending(current)) {
  456. error = -ERESTARTSYS;
  457. break;
  458. }
  459. if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
  460.     test_bit(ATM_VF_CLOSE,&vcc->flags)) {
  461. error = vcc->reply;
  462. break;
  463. }
  464. if (!test_bit(ATM_VF_READY,&vcc->flags)) {
  465. error = -EPIPE;
  466. break;
  467. }
  468. }
  469. set_current_state(TASK_RUNNING);
  470. remove_wait_queue(&vcc->sleep,&wait);
  471. if (error) return error;
  472. skb->dev = NULL; /* for paths shared with net_device interfaces */
  473. ATM_SKB(skb)->iovcnt = 0;
  474. ATM_SKB(skb)->atm_options = vcc->atm_options;
  475. if (copy_from_user(skb_put(skb,size),buff,size)) {
  476. kfree_skb(skb);
  477. return -EFAULT;
  478. }
  479. if (eff != size) memset(skb->data+size,0,eff-size);
  480. error = vcc->dev->ops->send(vcc,skb);
  481. return error ? error : size;
  482. }
  485. unsigned int atm_poll(struct file *file,struct socket *sock,poll_table *wait)
  486. {
  487. struct atm_vcc *vcc;
  488. unsigned int mask;
  490. vcc = ATM_SD(sock);
  491. poll_wait(file,&vcc->sleep,wait);
  492. mask = 0;
  493. if (skb_peek(&vcc->recvq) || skb_peek(&vcc->listenq))
  494. mask |= POLLIN | POLLRDNORM;
  495. if (test_bit(ATM_VF_RELEASED,&vcc->flags) ||
  496.     test_bit(ATM_VF_CLOSE,&vcc->flags))
  497. mask |= POLLHUP;
  498. if (sock->state != SS_CONNECTING) {
  499. if (vcc->qos.txtp.traffic_class != ATM_NONE &&
  500.     vcc->qos.txtp.max_sdu+atomic_read(&vcc->tx_inuse)+
  501.     ATM_PDU_OVHD <= vcc->sk->sndbuf)
  502. mask |= POLLOUT | POLLWRNORM;
  503. }
  504. else if (vcc->reply != WAITING) {
  505. mask |= POLLOUT | POLLWRNORM;
  506. if (vcc->reply) mask |= POLLERR;
  507. }
  508. return mask;
  509. }
  512. static void copy_aal_stats(struct k_atm_aal_stats *from,
  513.     struct atm_aal_stats *to)
  514. {
  515. #define __HANDLE_ITEM(i) to->i = atomic_read(&from->i)
  516. __AAL_STAT_ITEMS
  517. #undef __HANDLE_ITEM
  518. }
  521. static void subtract_aal_stats(struct k_atm_aal_stats *from,
  522.     struct atm_aal_stats *to)
  523. {
  524. #define __HANDLE_ITEM(i) atomic_sub(to->i,&from->i)
  525. __AAL_STAT_ITEMS
  526. #undef __HANDLE_ITEM
  527. }
  530. static int fetch_stats(struct atm_dev *dev,struct atm_dev_stats *arg,int zero)
  531. {
  532. struct atm_dev_stats tmp;
  533. int error = 0;
  535. copy_aal_stats(&dev->stats.aal0,&tmp.aal0);
  536. copy_aal_stats(&dev->stats.aal34,&tmp.aal34);
  537. copy_aal_stats(&dev->stats.aal5,&tmp.aal5);
  538. if (arg) error = copy_to_user(arg,&tmp,sizeof(tmp));
  539. if (zero && !error) {
  540. subtract_aal_stats(&dev->stats.aal0,&tmp.aal0);
  541. subtract_aal_stats(&dev->stats.aal34,&tmp.aal34);
  542. subtract_aal_stats(&dev->stats.aal5,&tmp.aal5);
  543. }
  544. return error ? -EFAULT : 0;
  545. }
  548. int atm_ioctl(struct socket *sock,unsigned int cmd,unsigned long arg)
  549. {
  550. struct atm_dev *dev;
  551. struct atm_vcc *vcc;
  552. int *tmp_buf, *tmp_p;
  553. void *buf;
  554. int error,len,size,number, ret_val;
  556. ret_val = 0;
  557. spin_lock (&atm_dev_lock);
  558. vcc = ATM_SD(sock);
  559. switch (cmd) {
  560. case SIOCOUTQ:
  561. if (sock->state != SS_CONNECTED ||
  562.     !test_bit(ATM_VF_READY,&vcc->flags)) {
  563. ret_val =  -EINVAL;
  564. goto done;
  565. }
  566. ret_val =  put_user(vcc->sk->sndbuf-
  567.     atomic_read(&vcc->tx_inuse)-ATM_PDU_OVHD,
  568.     (int *) arg) ? -EFAULT : 0;
  569. goto done;
  570. case SIOCINQ:
  571. {
  572. struct sk_buff *skb;
  574. if (sock->state != SS_CONNECTED) {
  575. ret_val = -EINVAL;
  576. goto done;
  577. }
  578. skb = skb_peek(&vcc->recvq);
  579. ret_val = put_user(skb ? skb->len : 0,(int *) arg)
  580.     ? -EFAULT : 0;
  581. goto done;
  582. }
  583. case ATM_GETNAMES:
  584. if (get_user(buf,
  585.      &((struct atm_iobuf *) arg)->buffer)) {
  586. ret_val = -EFAULT;
  587. goto done;
  588. }
  589. if (get_user(len,
  590.      &((struct atm_iobuf *) arg)->length)) {
  591. ret_val = -EFAULT;
  592. goto done;
  593. }
  594. size = 0;
  595. for (dev = atm_devs; dev; dev = dev->next)
  596. size += sizeof(int);
  597. if (size > len) {
  598. ret_val = -E2BIG;
  599. goto done;
  600. }
  601. tmp_buf = kmalloc(size,GFP_KERNEL);
  602. if (!tmp_buf) {
  603. ret_val = -ENOMEM;
  604. goto done;
  605. }
  606. tmp_p = tmp_buf;
  607. for (dev = atm_devs; dev; dev = dev->next)
  608. *tmp_p++ = dev->number;
  609.         ret_val = ((copy_to_user(buf, tmp_buf, size)) ||
  610.     put_user(size, &((struct atm_iobuf *) arg)->length)
  611.     ) ? -EFAULT : 0;
  612. kfree(tmp_buf);
  613. goto done;
  614. case SIOCGSTAMP: /* borrowed from IP */
  615. if (!vcc->timestamp.tv_sec) {
  616. ret_val = -ENOENT;
  617. goto done;
  618. }
  619. vcc->timestamp.tv_sec += vcc->timestamp.tv_usec/1000000;
  620. vcc->timestamp.tv_usec %= 1000000;
  621. ret_val = copy_to_user((void *) arg,&vcc->timestamp,
  622.     sizeof(struct timeval)) ? -EFAULT : 0;
  623. goto done;
  624. case ATM_SETSC:
  625. printk(KERN_WARNING "ATM_SETSC is obsoleten");
  626. ret_val = 0;
  627. goto done;
  628. case ATMSIGD_CTRL:
  629. if (!capable(CAP_NET_ADMIN)) {
  630. ret_val = -EPERM;
  631. goto done;
  632. }
  633. /*
  634.  * The user/kernel protocol for exchanging signalling
  635.  * info uses kernel pointers as opaque references,
  636.  * so the holder of the file descriptor can scribble
  637.  * on the kernel... so we should make sure that we
  638.  * have the same privledges that /proc/kcore needs
  639.  */
  640. if (!capable(CAP_SYS_RAWIO)) {
  641. ret_val = -EPERM;
  642. goto done;
  643. }
  644. error = sigd_attach(vcc);
  645. if (!error) sock->state = SS_CONNECTED;
  646. ret_val = error;
  647. goto done;
  648. #ifdef CONFIG_ATM_CLIP
  649. case SIOCMKCLIP:
  650. if (!capable(CAP_NET_ADMIN))
  651. ret_val = -EPERM;
  652. else 
  653. ret_val = clip_create(arg);
  654. goto done;
  655. case ATMARPD_CTRL:
  656. if (!capable(CAP_NET_ADMIN)) {
  657. ret_val = -EPERM;
  658. goto done;
  659. }
  660. error = atm_init_atmarp(vcc);
  661. if (!error) sock->state = SS_CONNECTED;
  662. ret_val = error;
  663. goto done;
  664. case ATMARP_MKIP:
  665. if (!capable(CAP_NET_ADMIN)) 
  666. ret_val = -EPERM;
  667. else 
  668. ret_val = clip_mkip(vcc,arg);
  669. goto done;
  670. case ATMARP_SETENTRY:
  671. if (!capable(CAP_NET_ADMIN)) 
  672. ret_val = -EPERM;
  673. else
  674. ret_val = clip_setentry(vcc,arg);
  675. goto done;
  676. case ATMARP_ENCAP:
  677. if (!capable(CAP_NET_ADMIN)) 
  678. ret_val = -EPERM;
  679. else
  680. ret_val = clip_encap(vcc,arg);
  681. goto done;
  682. #endif
  683. #if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
  684.                 case ATMLEC_CTRL:
  685.                         if (!capable(CAP_NET_ADMIN)) {
  686. ret_val = -EPERM;
  687. goto done;
  688. }
  689.                         if (atm_lane_ops.lecd_attach == NULL)
  690. atm_lane_init();
  691.                         if (atm_lane_ops.lecd_attach == NULL) { /* try again */
  692. ret_val = -ENOSYS;
  693. goto done;
  694. }
  695. error = atm_lane_ops.lecd_attach(vcc, (int)arg);
  696. if (error >= 0) sock->state = SS_CONNECTED;
  697. ret_val =  error;
  698. goto done;
  699.                 case ATMLEC_MCAST:
  700. if (!capable(CAP_NET_ADMIN))
  701. ret_val = -EPERM;
  702. else
  703. ret_val = atm_lane_ops.mcast_attach(vcc, (int)arg);
  704. goto done;
  705.                 case ATMLEC_DATA:
  706. if (!capable(CAP_NET_ADMIN))
  707. ret_val = -EPERM;
  708. else
  709. ret_val = atm_lane_ops.vcc_attach(vcc, (void*)arg);
  710. goto done;
  711. #endif
  712. #if defined(CONFIG_ATM_MPOA) || defined(CONFIG_ATM_MPOA_MODULE)
  713. case ATMMPC_CTRL:
  714. if (!capable(CAP_NET_ADMIN)) {
  715. ret_val = -EPERM;
  716. goto done;
  717. }
  718. if (atm_mpoa_ops.mpoad_attach == NULL)
  719.                                 atm_mpoa_init();
  720. if (atm_mpoa_ops.mpoad_attach == NULL) { /* try again */
  721. ret_val = -ENOSYS;
  722. goto done;
  723. }
  724. error = atm_mpoa_ops.mpoad_attach(vcc, (int)arg);
  725. if (error >= 0) sock->state = SS_CONNECTED;
  726. ret_val = error;
  727. goto done;
  728. case ATMMPC_DATA:
  729. if (!capable(CAP_NET_ADMIN)) 
  730. ret_val = -EPERM;
  731. else
  732. ret_val = atm_mpoa_ops.vcc_attach(vcc, arg);
  733. goto done;
  734. #endif
  735. #if defined(CONFIG_ATM_TCP) || defined(CONFIG_ATM_TCP_MODULE)
  736. case SIOCSIFATMTCP:
  737. if (!capable(CAP_NET_ADMIN)) {
  738. ret_val = -EPERM;
  739. goto done;
  740. }
  741. if (!atm_tcp_ops.attach) {
  742. ret_val = -ENOPKG;
  743. goto done;
  744. }
  745. fops_get (&atm_tcp_ops);
  746. error = atm_tcp_ops.attach(vcc,(int) arg);
  747. if (error >= 0) sock->state = SS_CONNECTED;
  748. else            fops_put (&atm_tcp_ops);
  749. ret_val = error;
  750. goto done;
  751. case ATMTCP_CREATE:
  752. if (!capable(CAP_NET_ADMIN)) {
  753. ret_val = -EPERM;
  754. goto done;
  755. }
  756. if (!atm_tcp_ops.create_persistent) {
  757. ret_val = -ENOPKG;
  758. goto done;
  759. }
  760. error = atm_tcp_ops.create_persistent((int) arg);
  761. if (error < 0) fops_put (&atm_tcp_ops);
  762. ret_val = error;
  763. goto done;
  764. case ATMTCP_REMOVE:
  765. if (!capable(CAP_NET_ADMIN)) {
  766. ret_val = -EPERM;
  767. goto done;
  768. }
  769. if (!atm_tcp_ops.remove_persistent) {
  770. ret_val = -ENOPKG;
  771. goto done;
  772. }
  773. error = atm_tcp_ops.remove_persistent((int) arg);
  774. fops_put (&atm_tcp_ops);
  775. ret_val = error;
  776. goto done;
  777. #endif
  778. default:
  779. break;
  780. }
  781. #if defined(CONFIG_PPPOATM) || defined(CONFIG_PPPOATM_MODULE)
  782. if (pppoatm_ioctl_hook) {
  783. ret_val = pppoatm_ioctl_hook(vcc, cmd, arg);
  784. if (ret_val != -ENOIOCTLCMD)
  785. goto done;
  786. }
  787. #endif
  788. if (get_user(buf,&((struct atmif_sioc *) arg)->arg)) {
  789. ret_val = -EFAULT;
  790. goto done;
  791. }
  792. if (get_user(len,&((struct atmif_sioc *) arg)->length)) {
  793. ret_val = -EFAULT;
  794. goto done;
  795. }
  796. if (get_user(number,&((struct atmif_sioc *) arg)->number)) {
  797. ret_val = -EFAULT;
  798. goto done;
  799. }
  800. if (!(dev = atm_find_dev(number))) {
  801. ret_val = -ENODEV;
  802. goto done;
  803. }
  805. size = 0;
  806. switch (cmd) {
  807. case ATM_GETTYPE:
  808. size = strlen(dev->type)+1;
  809. if (copy_to_user(buf,dev->type,size)) {
  810. ret_val = -EFAULT;
  811. goto done;
  812. }
  813. break;
  814. case ATM_GETESI:
  815. size = ESI_LEN;
  816. if (copy_to_user(buf,dev->esi,size)) {
  817. ret_val = -EFAULT;
  818. goto done;
  819. }
  820. break;
  821. case ATM_SETESI:
  822. {
  823. int i;
  825. for (i = 0; i < ESI_LEN; i++)
  826. if (dev->esi[i]) {
  827. ret_val = -EEXIST;
  828. goto done;
  829. }
  830. }
  831. /* fall through */
  832. case ATM_SETESIF:
  833. {
  834. unsigned char esi[ESI_LEN];
  836. if (!capable(CAP_NET_ADMIN)) {
  837. ret_val = -EPERM;
  838. goto done;
  839. }
  840. if (copy_from_user(esi,buf,ESI_LEN)) {
  841. ret_val = -EFAULT;
  842. goto done;
  843. }
  844. memcpy(dev->esi,esi,ESI_LEN);
  845. ret_val =  ESI_LEN;
  846. goto done;
  847. }
  848. case ATM_GETSTATZ:
  849. if (!capable(CAP_NET_ADMIN)) {
  850. ret_val = -EPERM;
  851. goto done;
  852. }
  853. /* fall through */
  854. case ATM_GETSTAT:
  855. size = sizeof(struct atm_dev_stats);
  856. error = fetch_stats(dev,buf,cmd == ATM_GETSTATZ);
  857. if (error) {
  858. ret_val = error;
  859. goto done;
  860. }
  861. break;
  862. case ATM_GETCIRANGE:
  863. size = sizeof(struct atm_cirange);
  864. if (copy_to_user(buf,&dev->ci_range,size)) {
  865. ret_val = -EFAULT;
  866. goto done;
  867. }
  868. break;
  869. case ATM_GETLINKRATE:
  870. size = sizeof(int);
  871. if (copy_to_user(buf,&dev->link_rate,size)) {
  872. ret_val = -EFAULT;
  873. goto done;
  874. }
  875. break;
  876. case ATM_RSTADDR:
  877. if (!capable(CAP_NET_ADMIN)) {
  878. ret_val = -EPERM;
  879. goto done;
  880. }
  881. atm_reset_addr(dev);
  882. break;
  883. case ATM_ADDADDR:
  884. case ATM_DELADDR:
  885. if (!capable(CAP_NET_ADMIN)) {
  886. ret_val = -EPERM;
  887. goto done;
  888. }
  889. {
  890. struct sockaddr_atmsvc addr;
  892. if (copy_from_user(&addr,buf,sizeof(addr))) {
  893. ret_val = -EFAULT;
  894. goto done;
  895. }
  896. if (cmd == ATM_ADDADDR)
  897. ret_val = atm_add_addr(dev,&addr);
  898. else
  899. ret_val = atm_del_addr(dev,&addr);
  900. goto done;
  901. }
  902. case ATM_GETADDR:
  903. size = atm_get_addr(dev,buf,len);
  904. if (size < 0)
  905. ret_val = size;
  906. else
  907. /* may return 0, but later on size == 0 means "don't
  908.    write the length" */
  909. ret_val = put_user(size,
  910.    &((struct atmif_sioc *) arg)->length) ? -EFAULT : 0;
  911. goto done;
  912. case ATM_SETLOOP:
  913. if (__ATM_LM_XTRMT((int) (long) buf) &&
  914.     __ATM_LM_XTLOC((int) (long) buf) >
  915.     __ATM_LM_XTRMT((int) (long) buf)) {
  916. ret_val = -EINVAL;
  917. goto done;
  918. }
  919. /* fall through */
  920. case ATM_SETCIRANGE:
  921. case SONET_GETSTATZ:
  922. case SONET_SETDIAG:
  923. case SONET_CLRDIAG:
  924. case SONET_SETFRAMING:
  925. if (!capable(CAP_NET_ADMIN)) {
  926. ret_val = -EPERM;
  927. goto done;
  928. }
  929. /* fall through */
  930. default:
  931. if (!dev->ops->ioctl) {
  932. ret_val = -EINVAL;
  933. goto done;
  934. }
  935. size = dev->ops->ioctl(dev,cmd,buf);
  936. if (size < 0) {
  937. ret_val = (size == -ENOIOCTLCMD ? -EINVAL : size);
  938. goto done;
  939. }
  940. }
  942. if (size)
  943. ret_val =  put_user(size,&((struct atmif_sioc *) arg)->length) ?
  944. -EFAULT : 0;
  945. else
  946. ret_val = 0;
  948.  done:
  949. spin_unlock (&atm_dev_lock); 
  950. return ret_val;
  951. }
  954. static int atm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos)
  955. {
  956. int error;
  958. /*
  959.  * Don't let the QoS change the already connected AAL type nor the
  960.  * traffic class.
  961.  */
  962. if (qos->aal != vcc->qos.aal ||
  963.     qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
  964.     qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
  965. return -EINVAL;
  966. error = adjust_tp(&qos->txtp,qos->aal);
  967. if (!error) error = adjust_tp(&qos->rxtp,qos->aal);
  968. if (error) return error;
  969. if (!vcc->dev->ops->change_qos) return -EOPNOTSUPP;
  970. if (vcc->family == AF_ATMPVC)
  971. return vcc->dev->ops->change_qos(vcc,qos,ATM_MF_SET);
  972. return svc_change_qos(vcc,qos);
  973. }
  976. static int check_tp(struct atm_trafprm *tp)
  977. {
  978. /* @@@ Should be merged with adjust_tp */
  979. if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS) return 0;
  980. if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
  981.     !tp->max_pcr) return -EINVAL;
  982. if (tp->min_pcr == ATM_MAX_PCR) return -EINVAL;
  983. if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
  984.     tp->min_pcr > tp->max_pcr) return -EINVAL;
  985. /*
  986.  * We allow pcr to be outside [min_pcr,max_pcr], because later
  987.  * adjustment may still push it in the valid range.
  988.  */
  989. return 0;
  990. }
  993. static int check_qos(struct atm_qos *qos)
  994. {
  995. int error;
  997. if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
  998.                 return -EINVAL;
  999. if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
  1000.     qos->txtp.traffic_class && qos->rxtp.traffic_class &&
  1001.     qos->txtp.traffic_class != ATM_ANYCLASS &&
  1002.     qos->rxtp.traffic_class != ATM_ANYCLASS) return -EINVAL;
  1003. error = check_tp(&qos->txtp);
  1004. if (error) return error;
  1005. return check_tp(&qos->rxtp);
  1006. }
  1009. static int atm_do_setsockopt(struct socket *sock,int level,int optname,
  1010.     void *optval,int optlen)
  1011. {
  1012. struct atm_vcc *vcc;
  1013. unsigned long value;
  1014. int error;
  1016. vcc = ATM_SD(sock);
  1017. switch (optname) {
  1018. case SO_ATMQOS:
  1019. {
  1020. struct atm_qos qos;
  1022. if (copy_from_user(&qos,optval,sizeof(qos)))
  1023. return -EFAULT;
  1024. error = check_qos(&qos);
  1025. if (error) return error;
  1026. if (sock->state == SS_CONNECTED)
  1027. return atm_change_qos(vcc,&qos);
  1028. if (sock->state != SS_UNCONNECTED)
  1029. return -EBADFD;
  1030. vcc->qos = qos;
  1031. set_bit(ATM_VF_HASQOS,&vcc->flags);
  1032. return 0;
  1033. }
  1034. case SO_SETCLP:
  1035. if (get_user(value,(unsigned long *) optval))
  1036. return -EFAULT;
  1037. if (value) vcc->atm_options |= ATM_ATMOPT_CLP;
  1038. else vcc->atm_options &= ~ATM_ATMOPT_CLP;
  1039. return 0;
  1040. default:
  1041. if (level == SOL_SOCKET) return -EINVAL;
  1042. break;
  1043. }
  1044. if (!vcc->dev || !vcc->dev->ops->setsockopt) return -EINVAL;
  1045. return vcc->dev->ops->setsockopt(vcc,level,optname,optval,optlen);
  1046. }
  1049. static int atm_do_getsockopt(struct socket *sock,int level,int optname,
  1050.     void *optval,int optlen)
  1051. {
  1052. struct atm_vcc *vcc;
  1054. vcc = ATM_SD(sock);
  1055. switch (optname) {
  1056. case SO_ATMQOS:
  1057. if (!test_bit(ATM_VF_HASQOS,&vcc->flags))
  1058. return -EINVAL;
  1059. return copy_to_user(optval,&vcc->qos,sizeof(vcc->qos)) ?
  1060.     -EFAULT : 0;
  1061. case SO_SETCLP:
  1062. return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 :
  1063.   0,(unsigned long *) optval) ? -EFAULT : 0;
  1064. case SO_ATMPVC:
  1065. {
  1066. struct sockaddr_atmpvc pvc;
  1068. if (!vcc->dev ||
  1069.     !test_bit(ATM_VF_ADDR,&vcc->flags))
  1070. return -ENOTCONN;
  1071. pvc.sap_family = AF_ATMPVC;
  1072. pvc.sap_addr.itf = vcc->dev->number;
  1073. pvc.sap_addr.vpi = vcc->vpi;
  1074. pvc.sap_addr.vci = vcc->vci;
  1075. return copy_to_user(optval,&pvc,sizeof(pvc)) ?
  1076.     -EFAULT : 0;
  1077. }
  1078. default:
  1079. if (level == SOL_SOCKET) return -EINVAL;
  1080. break;
  1081. }
  1082. if (!vcc->dev || !vcc->dev->ops->getsockopt) return -EINVAL;
  1083. return vcc->dev->ops->getsockopt(vcc,level,optname,optval,optlen);
  1084. }
  1087. int atm_setsockopt(struct socket *sock,int level,int optname,char *optval,
  1088.     int optlen)
  1089. {
  1090. if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
  1091. return -EINVAL;
  1092. return atm_do_setsockopt(sock,level,optname,optval,optlen);
  1093. }
  1096. int atm_getsockopt(struct socket *sock,int level,int optname,
  1097.     char *optval,int *optlen)
  1098. {
  1099. int len;
  1101. if (get_user(len,optlen)) return -EFAULT;
  1102. if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
  1103. return -EINVAL;
  1104. return atm_do_getsockopt(sock,level,optname,optval,len);
  1105. }
  1108. /*
  1109.  * lane_mpoa_init.c: A couple of helper functions
  1110.  * to make modular LANE and MPOA client easier to implement
  1111.  */
  1113. /*
  1114.  * This is how it goes:
  1115.  *
  1116.  * if xxxx is not compiled as module, call atm_xxxx_init_ops()
  1117.  *    from here
  1118.  * else call atm_mpoa_init_ops() from init_module() within
  1119.  *    the kernel when xxxx module is loaded
  1120.  *
  1121.  * In either case function pointers in struct atm_xxxx_ops
  1122.  * are initialized to their correct values. Either they
  1123.  * point to functions in the module or in the kernel
  1124.  */
  1125.  
  1126. extern struct atm_mpoa_ops atm_mpoa_ops; /* in common.c */
  1127. extern struct atm_lane_ops atm_lane_ops; /* in common.c */
  1129. #if defined(CONFIG_ATM_MPOA) || defined(CONFIG_ATM_MPOA_MODULE)
  1130. void atm_mpoa_init(void)
  1131. {
  1132. #ifndef CONFIG_ATM_MPOA_MODULE /* not module */
  1133.         atm_mpoa_init_ops(&atm_mpoa_ops);
  1134. #else
  1135. request_module("mpoa");
  1136. #endif
  1138.         return;
  1139. }
  1140. #endif
  1142. #if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
  1143. #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
  1144. struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
  1145. unsigned char *addr) = NULL;
  1146. void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) = NULL;
  1147. #if defined(CONFIG_ATM_LANE_MODULE) || defined(CONFIG_BRIDGE_MODULE)
  1148. EXPORT_SYMBOL(br_fdb_get_hook);
  1149. EXPORT_SYMBOL(br_fdb_put_hook);
  1150. #endif /* defined(CONFIG_ATM_LANE_MODULE) || defined(CONFIG_BRIDGE_MODULE) */
  1151. #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
  1153. void atm_lane_init(void)
  1154. {
  1155. #ifndef CONFIG_ATM_LANE_MODULE /* not module */
  1156.         atm_lane_init_ops(&atm_lane_ops);
  1157. #else
  1158. request_module("lec");
  1159. #endif
  1161.         return;
  1162. }        
  1163. #endif