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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
wanproc.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：27k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

wanproc.c：源码内容
  1. /*****************************************************************************
  2. * wanproc.c WAN Router Module. /proc filesystem interface.
  3. *
  4. * This module is completely hardware-independent and provides
  5. * access to the router using Linux /proc filesystem.
  6. *
  7. * Author:  Gideon Hack
  8. *
  9. * Copyright: (c) 1995-1999 Sangoma Technologies Inc.
  10. *
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License
  13. * as published by the Free Software Foundation; either version
  14. * 2 of the License, or (at your option) any later version.
  15. * ============================================================================
  16. * Jun 02, 1999  Gideon Hack Updates for Linux 2.2.X kernels.
  17. * Jun 29, 1997 Alan Cox Merged with 1.0.3 vendor code
  18. * Jan 29, 1997 Gene Kozin v1.0.1. Implemented /proc read routines
  19. * Jan 30, 1997 Alan Cox Hacked around for 2.1
  20. * Dec 13, 1996 Gene Kozin Initial version (based on Sangoma's WANPIPE)
  21. *****************************************************************************/
  23. #include <linux/version.h>
  24. #include <linux/config.h>
  25. #include <linux/stddef.h> /* offsetof(), etc. */
  26. #include <linux/errno.h> /* return codes */
  27. #include <linux/kernel.h>
  28. #include <linux/slab.h> /* kmalloc(), kfree() */
  29. #include <linux/mm.h> /* verify_area(), etc. */
  30. #include <linux/string.h> /* inline mem*, str* functions */
  31. #include <asm/byteorder.h> /* htons(), etc. */
  32. #include <asm/io.h>
  33. #include <linux/wanrouter.h> /* WAN router API definitions */
  37. #if defined(LINUX_2_1) || defined(LINUX_2_4) 
  38.  #include <linux/init.h> /* __initfunc et al. */
  39.  #include <asm/uaccess.h>       /* copy_to_user */
  40.  #define PROC_STATS_FORMAT "%30s: %12lun"
  41. #else
  42.  #define PROC_STATS_FORMAT "%30s: %12un"
  43.  #include <asm/segment.h> /* kernel <-> user copy */
  44. #endif
  47. /****** Defines and Macros **************************************************/
  49. #define PROC_BUFSZ 4000 /* buffer size for printing proc info */
  51. #define PROT_DECODE(prot) ((prot == WANCONFIG_FR) ? " FR" :
  52.       (prot == WANCONFIG_X25) ? " X25" : 
  53.          (prot == WANCONFIG_PPP) ? " PPP" : 
  54.     (prot == WANCONFIG_CHDLC) ? " CHDLC": 
  55.        (prot == WANCONFIG_MPPP) ? " MPPP" : 
  56.            " Unknown" )
  58. /****** Data Types **********************************************************/
  60. typedef struct wan_stat_entry
  61. {
  62. struct wan_stat_entry *next;
  63. char *description; /* description string */
  64. void *data; /* -> data */
  65. unsigned data_type; /* data type */
  66. } wan_stat_entry_t;
  68. /****** Function Prototypes *************************************************/
  70. #ifdef CONFIG_PROC_FS
  73. #ifdef LINUX_2_4  /* Start of LINUX 2.4.X code */
  76. /* Proc filesystem interface */
  77. static int router_proc_perms(struct inode *, int);
  78. static ssize_t router_proc_read(struct file* file, char* buf, size_t count,  loff_t *ppos);
  80. /* Methods for preparing data for reading proc entries */
  82. static int config_get_info(char* buf, char** start, off_t offs, int len);
  83. static int status_get_info(char* buf, char** start, off_t offs, int len);
  84. static int wandev_get_info(char* buf, char** start, off_t offs, int len);
  86. /* Miscellaneous */
  88. /*
  89.  * Structures for interfacing with the /proc filesystem.
  90.  * Router creates its own directory /proc/net/router with the folowing
  91.  * entries:
  92.  * config device configuration
  93.  * status global device statistics
  94.  * <device> entry for each WAN device
  95.  */
  97. /*
  98.  * Generic /proc/net/router/<file> file and inode operations 
  99.  */
  100. static struct file_operations router_fops =
  101. {
  102. read: router_proc_read,
  103. };
  105. static struct inode_operations router_inode =
  106. {
  107. permission: router_proc_perms,
  108. };
  110. /*
  111.  * /proc/net/router/<device> file operations
  112.  */
  114. static struct file_operations wandev_fops =
  115. {
  116. read: router_proc_read,
  117. ioctl: wanrouter_ioctl,
  118. };
  120. /*
  121.  * /proc/net/router 
  122.  */
  124. static struct proc_dir_entry *proc_router;
  126. /* Strings */
  127. static char conf_hdr[] =
  128. "Device name    | port |IRQ|DMA|  mem.addr  |mem.size|"
  129. "option1|option2|option3|option4n";
  131. static char stat_hdr[] =
  132. "Device name    |protocol|station|interface|clocking|baud rate"
  133. "| MTU |ndev|link staten";
  136. /*
  137.  * Interface functions
  138.  */
  140. /*
  141.  * Initialize router proc interface.
  142.  */
  144. int __init wanrouter_proc_init (void)
  145. {
  146. struct proc_dir_entry *p;
  147. proc_router = proc_mkdir(ROUTER_NAME, proc_net);
  148. if (!proc_router)
  149. goto fail;
  151. p = create_proc_entry("config",0,proc_router);
  152. if (!p)
  153. goto fail_config;
  154. p->proc_fops = &router_fops;
  155. p->proc_iops = &router_inode;
  156. p->get_info = config_get_info;
  157. p = create_proc_entry("status",0,proc_router);
  158. if (!p)
  159. goto fail_stat;
  160. p->proc_fops = &router_fops;
  161. p->proc_iops = &router_inode;
  162. p->get_info = status_get_info;
  163. return 0;
  164. fail_stat:
  165. remove_proc_entry("config", proc_router);
  166. fail_config:
  167. remove_proc_entry(ROUTER_NAME, proc_net);
  168. fail:
  169. return -ENOMEM;
  170. }
  172. /*
  173.  * Clean up router proc interface.
  174.  */
  176. void wanrouter_proc_cleanup (void)
  177. {
  178. remove_proc_entry("config", proc_router);
  179. remove_proc_entry("status", proc_router);
  180. remove_proc_entry(ROUTER_NAME,proc_net);
  181. }
  183. /*
  184.  * Add directory entry for WAN device.
  185.  */
  187. int wanrouter_proc_add (wan_device_t* wandev)
  188. {
  189. if (wandev->magic != ROUTER_MAGIC)
  190. return -EINVAL;
  192. wandev->dent = create_proc_entry(wandev->name, 0, proc_router);
  193. if (!wandev->dent)
  194. return -ENOMEM;
  195. wandev->dent->proc_fops = &wandev_fops;
  196. wandev->dent->proc_iops = &router_inode;
  197. wandev->dent->get_info = wandev_get_info;
  198. wandev->dent->data = wandev;
  199. return 0;
  200. }
  202. /*
  203.  * Delete directory entry for WAN device.
  204.  */
  205.  
  206. int wanrouter_proc_delete(wan_device_t* wandev)
  207. {
  208. if (wandev->magic != ROUTER_MAGIC)
  209. return -EINVAL;
  210. remove_proc_entry(wandev->name, proc_router);
  211. return 0;
  212. }
  214. /****** Proc filesystem entry points ****************************************/
  216. /*
  217.  * Verify access rights.
  218.  */
  220. static int router_proc_perms (struct inode* inode, int op)
  221. {
  222. return 0;
  223. }
  225. /*
  226.  * Read router proc directory entry.
  227.  * This is universal routine for reading all entries in /proc/net/wanrouter
  228.  * directory.  Each directory entry contains a pointer to the 'method' for
  229.  * preparing data for that entry.
  230.  * o verify arguments
  231.  * o allocate kernel buffer
  232.  * o call get_info() to prepare data
  233.  * o copy data to user space
  234.  * o release kernel buffer
  235.  *
  236.  * Return: number of bytes copied to user space (0, if no data)
  237.  * <0 error
  238.  */
  240. static ssize_t router_proc_read(struct file* file, char* buf, size_t count,
  241. loff_t *ppos)
  242. {
  243. struct inode *inode = file->f_dentry->d_inode;
  244. struct proc_dir_entry* dent;
  245. char* page;
  246. int pos, offs, len;
  248. if (count <= 0)
  249. return 0;
  251. dent = inode->u.generic_ip;
  252. if ((dent == NULL) || (dent->get_info == NULL))
  253. return 0;
  255. page = kmalloc(PROC_BUFSZ, GFP_KERNEL);
  256. if (page == NULL)
  257. return -ENOBUFS;
  259. pos = dent->get_info(page, dent->data, 0, 0);
  260. offs = file->f_pos;
  261. if (offs < pos) {
  262. len = min_t(unsigned int, pos - offs, count);
  263. if (copy_to_user(buf, (page + offs), len)) {
  264. kfree(page);
  265. return -EFAULT;
  266. }
  267. file->f_pos += len;
  268. }
  269. else
  270. len = 0;
  271. kfree(page);
  272. return len;
  273. }
  275. /*
  276.  * Prepare data for reading 'Config' entry.
  277.  * Return length of data.
  278.  */
  280. static int config_get_info(char* buf, char** start, off_t offs, int len)
  281. {
  282. int cnt = sizeof(conf_hdr) - 1;
  283. wan_device_t* wandev;
  284. strcpy(buf, conf_hdr);
  285. for (wandev = router_devlist;
  286.      wandev && (cnt < (PROC_BUFSZ - 120));
  287.      wandev = wandev->next) {
  288. if (wandev->state) cnt += sprintf(&buf[cnt],
  289. "%-15s|0x%-4X|%3u|%3u| 0x%-8lX |0x%-6X|%7u|%7u|%7u|%7un",
  290. wandev->name,
  291. wandev->ioport,
  292. wandev->irq,
  293. wandev->dma,
  294. wandev->maddr,
  295. wandev->msize,
  296. wandev->hw_opt[0],
  297. wandev->hw_opt[1],
  298. wandev->hw_opt[2],
  299. wandev->hw_opt[3]);
  300. }
  302. return cnt;
  303. }
  305. /*
  306.  * Prepare data for reading 'Status' entry.
  307.  * Return length of data.
  308.  */
  310. static int status_get_info(char* buf, char** start, off_t offs, int len)
  311. {
  312. int cnt = 0;
  313. wan_device_t* wandev;
  315. //cnt += sprintf(&buf[cnt], "nSTATUS:nn");
  316. strcpy(&buf[cnt], stat_hdr);
  317. cnt += sizeof(stat_hdr) - 1;
  319. for (wandev = router_devlist;
  320.      wandev && (cnt < (PROC_BUFSZ - 80));
  321.      wandev = wandev->next) {
  322. if (!wandev->state) continue;
  323. cnt += sprintf(&buf[cnt],
  324. "%-15s|%-8s|%-7s|%-9s|%-8s|%9u|%5u|%3u |",
  325. wandev->name,
  326. PROT_DECODE(wandev->config_id),
  327. wandev->config_id == WANCONFIG_FR ? 
  328. (wandev->station ? " Node" : " CPE") :
  329. (wandev->config_id == WANCONFIG_X25 ?
  330. (wandev->station ? " DCE" : " DTE") :
  331. (" N/A")),
  332. wandev->interface ? " V.35" : " RS-232",
  333. wandev->clocking ? "internal" : "external",
  334. wandev->bps,
  335. wandev->mtu,
  336. wandev->ndev);
  338. switch (wandev->state) {
  340. case WAN_UNCONFIGURED:
  341. cnt += sprintf(&buf[cnt], "%-12sn", "unconfigured");
  342. break;
  344. case WAN_DISCONNECTED:
  345. cnt += sprintf(&buf[cnt], "%-12sn", "disconnected");
  346. break;
  348. case WAN_CONNECTING:
  349. cnt += sprintf(&buf[cnt], "%-12sn", "connecting");
  350. break;
  352. case WAN_CONNECTED:
  353. cnt += sprintf(&buf[cnt], "%-12sn", "connected");
  354. break;
  356. default:
  357. cnt += sprintf(&buf[cnt], "%-12sn", "invalid");
  358. break;
  359. }
  360. }
  361. return cnt;
  362. }
  364. /*
  365.  * Prepare data for reading <device> entry.
  366.  * Return length of data.
  367.  *
  368.  * On entry, the 'start' argument will contain a pointer to WAN device
  369.  * data space.
  370.  */
  372. static int wandev_get_info(char* buf, char** start, off_t offs, int len)
  373. {
  374. wan_device_t* wandev = (void*)start;
  375. int cnt = 0;
  376. int rslt = 0;
  378. if ((wandev == NULL) || (wandev->magic != ROUTER_MAGIC))
  379. return 0;
  380. if (!wandev->state)
  381. return sprintf(&buf[cnt], "device is not configured!n");
  383. /* Update device statistics */
  384. if (wandev->update) {
  386. rslt = wandev->update(wandev);
  387. if(rslt) {
  388. switch (rslt) {
  389. case -EAGAIN:
  390. return sprintf(&buf[cnt], "Device is busy!n");
  392. default:
  393. return sprintf(&buf[cnt],
  394. "Device is not configured!n");
  395. }
  396. }
  397. }
  399. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  400. "total packets received", wandev->stats.rx_packets);
  401. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  402. "total packets transmitted", wandev->stats.tx_packets);
  403. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  404. "total bytes received", wandev->stats.rx_bytes);
  405. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  406. "total bytes transmitted", wandev->stats.tx_bytes);
  407. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  408. "bad packets received", wandev->stats.rx_errors);
  409. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  410. "packet transmit problems", wandev->stats.tx_errors);
  411. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  412. "received frames dropped", wandev->stats.rx_dropped);
  413. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  414. "transmit frames dropped", wandev->stats.tx_dropped);
  415. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  416. "multicast packets received", wandev->stats.multicast);
  417. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  418. "transmit collisions", wandev->stats.collisions);
  419. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  420. "receive length errors", wandev->stats.rx_length_errors);
  421. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  422. "receiver overrun errors", wandev->stats.rx_over_errors);
  423. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  424. "CRC errors", wandev->stats.rx_crc_errors);
  425. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  426. "frame format errors (aborts)", wandev->stats.rx_frame_errors);
  427. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  428. "receiver fifo overrun", wandev->stats.rx_fifo_errors);
  429. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  430. "receiver missed packet", wandev->stats.rx_missed_errors);
  431. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  432. "aborted frames transmitted", wandev->stats.tx_aborted_errors);
  433. return cnt;
  434. }
  437. #else /* ------------------- END OF LINUX 2.4.X VERSION -------------*/
  441. /* Proc filesystem interface */
  442. static int router_proc_perms(struct inode *, int);
  443. #ifdef LINUX_2_1
  444. static ssize_t router_proc_read(struct file *file, char *buf, size_t count,  loff_t *ppos);
  445. #else
  446. static int router_proc_read(
  447. struct inode* inode, struct file* file, char* buf, int count);
  448. static int device_write(
  449. struct inode* inode, struct file* file, const char* buf, int count);
  450. #endif
  452. /* Methods for preparing data for reading proc entries */
  453. static int config_get_info(char* buf, char** start, off_t offs, int len,
  454. int dummy);
  455. static int status_get_info(char* buf, char** start, off_t offs, int len,
  456. int dummy);
  457. static int wandev_get_info(char* buf, char** start, off_t offs, int len,
  458. int dummy);
  460. /* Miscellaneous */
  462. /*
  463.  * Global Data
  464.  */
  466. /*
  467.  * Names of the proc directory entries 
  468.  */
  470. static char name_root[] = ROUTER_NAME;
  471. static char name_conf[] = "config";
  472. static char name_stat[] = "status";
  474. /*
  475.  * Structures for interfacing with the /proc filesystem.
  476.  * Router creates its own directory /proc/net/router with the folowing
  477.  * entries:
  478.  * config device configuration
  479.  * status global device statistics
  480.  * <device> entry for each WAN device
  481.  */
  483. /*
  484.  * Generic /proc/net/router/<file> file and inode operations 
  485.  */
  486. #ifdef LINUX_2_1
  487. static struct file_operations router_fops =
  488. {
  489. NULL, /* lseek   */
  490. router_proc_read, /* read    */
  491. NULL, /* write   */
  492. NULL, /* readdir */
  493. NULL, /* select  */
  494. NULL, /* ioctl   */
  495. NULL, /* mmap    */
  496. NULL, /* no special open code    */
  497. NULL, /* flush */
  498. NULL, /* no special release code */
  499. NULL /* can't fsync */
  500. };
  501. #else
  502. static struct file_operations router_fops =
  503. {
  504. NULL,                   /* lseek   */
  505. router_proc_read,       /* read    */
  506. NULL,                   /* write   */
  507. NULL,                   /* readdir */
  508. NULL,                   /* select  */
  509. NULL,                   /* ioctl   */
  510. NULL,                   /* mmap    */
  511. NULL,                   /* no special open code    */
  512. NULL,                   /* no special release code */
  513. NULL                    /* can't fsync */
  514. };
  515. #endif
  517. static struct inode_operations router_inode =
  518. {
  519. &router_fops,
  520. NULL, /* create */
  521. NULL, /* lookup */
  522. NULL, /* link */
  523. NULL, /* unlink */
  524. NULL, /* symlink */
  525. NULL, /* mkdir */
  526. NULL, /* rmdir */
  527. NULL, /* mknod */
  528. NULL, /* rename */
  529. NULL, /* follow link */
  530. NULL, /* readlink */
  531. NULL, /* readpage */
  532. NULL, /* writepage */
  533. NULL, /* bmap */
  534. NULL, /* truncate */
  535. router_proc_perms
  536. };
  538. /*
  539.  * /proc/net/router/<device> file and inode operations
  540.  */
  542. #ifdef LINUX_2_1
  543. static struct file_operations wandev_fops =
  544. {
  545. NULL, /* lseek   */
  546. router_proc_read, /* read    */
  547. NULL, /* write   */
  548. NULL, /* readdir */
  549. NULL, /* select  */
  550. wanrouter_ioctl, /* ioctl   */
  551. NULL, /* mmap    */
  552. NULL, /* no special open code    */
  553. NULL, /* flush */
  554. NULL, /* no special release code */
  555. NULL /* can't fsync */
  556. };
  557. #else
  558. static struct file_operations wandev_fops =
  559. {
  560. NULL,                   /* lseek   */
  561. router_proc_read,       /* read    */
  562. device_write,           /* write   */
  563. NULL,                   /* readdir */
  564. NULL,                   /* select  */
  565. wanrouter_ioctl,        /* ioctl   */
  566. NULL,                   /* mmap    */
  567. NULL,                   /* no special open code    */
  568. NULL,                   /* no special release code */
  569. NULL                    /* can't fsync */
  570. };
  571. #endif
  573. static struct inode_operations wandev_inode =
  574. {
  575. &wandev_fops,
  576. NULL, /* create */
  577. NULL, /* lookup */
  578. NULL, /* link */
  579. NULL, /* unlink */
  580. NULL, /* symlink */
  581. NULL, /* mkdir */
  582. NULL, /* rmdir */
  583. NULL, /* mknod */
  584. NULL, /* rename */
  585. NULL, /* readlink */
  586. NULL, /* follow_link */
  587. NULL, /* readpage */
  588. NULL, /* writepage */
  589. NULL, /* bmap */
  590. NULL, /* truncate */
  591. router_proc_perms
  592. };
  594. /*
  595.  * Proc filesystem derectory entries.
  596.  */
  598. /*
  599.  * /proc/net/router 
  600.  */
  601.  
  602. static struct proc_dir_entry proc_router =
  603. {
  604. 0, /* .low_ino */
  605. sizeof(name_root) - 1, /* .namelen */
  606. name_root, /* .name */
  607. 0555 | S_IFDIR, /* .mode */
  608. 2, /* .nlink */
  609. 0, /* .uid */
  610. 0, /* .gid */
  611. 0, /* .size */
  612. &proc_dir_inode_operations, /* .ops */
  613. NULL, /* .get_info */
  614. NULL, /* .fill_node */
  615. NULL, /* .next */
  616. NULL, /* .parent */
  617. NULL, /* .subdir */
  618. NULL, /* .data */
  619. };
  621. /*
  622.  * /proc/net/router/config 
  623.  */
  624.  
  625. static struct proc_dir_entry proc_router_conf =
  626. {
  627. 0, /* .low_ino */
  628. sizeof(name_conf) - 1, /* .namelen */
  629. name_conf, /* .name */
  630. 0444 | S_IFREG, /* .mode */
  631. 1, /* .nlink */
  632. 0, /* .uid */
  633. 0, /* .gid */
  634. 0, /* .size */
  635. &router_inode, /* .ops */
  636. &config_get_info, /* .get_info */
  637. NULL, /* .fill_node */
  638. NULL, /* .next */
  639. NULL, /* .parent */
  640. NULL, /* .subdir */
  641. NULL, /* .data */
  642. };
  644. /*
  645.  * /proc/net/router/status 
  646.  */
  647.  
  648. static struct proc_dir_entry proc_router_stat =
  649. {
  650. 0, /* .low_ino */
  651. sizeof(name_stat) - 1, /* .namelen */
  652. name_stat, /* .name */
  653. 0444 | S_IFREG, /* .mode */
  654. 1, /* .nlink */
  655. 0, /* .uid */
  656. 0, /* .gid */
  657. 0, /* .size */
  658. &router_inode, /* .ops */
  659. status_get_info, /* .get_info */
  660. NULL, /* .fill_node */
  661. NULL, /* .next */
  662. NULL, /* .parent */
  663. NULL, /* .subdir */
  664. NULL, /* .data */
  665. };
  667. /* Strings */
  668. static char conf_hdr[] =
  669. "Device name    | port |IRQ|DMA|  mem.addr  |mem.size|"
  670. "option1|option2|option3|option4n";
  672. static char stat_hdr[] =
  673. "Device name    |protocol|station|interface|clocking|baud rate| MTU |ndev"
  674. "|link staten";
  677. /*
  678.  * Interface functions
  679.  */
  681. /*
  682.  * Initialize router proc interface.
  683.  */
  685. #ifdef LINUX_2_1
  686. __initfunc(int wanrouter_proc_init (void))
  687. {
  688. int err = proc_register(proc_net, &proc_router);
  690. if (!err) {
  691. proc_register(&proc_router, &proc_router_conf);
  692. proc_register(&proc_router, &proc_router_stat);
  693. }
  694. return err;
  695. }
  696. #else
  697. int wanrouter_proc_init (void)
  698. {
  699. int err = proc_register_dynamic(&proc_net, &proc_router);
  701. if (!err) {
  702. proc_register_dynamic(&proc_router, &proc_router_conf);
  703. proc_register_dynamic(&proc_router, &proc_router_stat);
  704. }
  705. return err;
  706. }
  707. #endif
  709. /*
  710.  * Clean up router proc interface.
  711.  */
  713. void wanrouter_proc_cleanup (void)
  714. {
  715. proc_unregister(&proc_router, proc_router_conf.low_ino);
  716. proc_unregister(&proc_router, proc_router_stat.low_ino);
  717. #ifdef LINUX_2_1
  718. proc_unregister(proc_net, proc_router.low_ino);
  719. #else
  720. proc_unregister(&proc_net, proc_router.low_ino);
  721. #endif
  722. }
  724. /*
  725.  * Add directory entry for WAN device.
  726.  */
  728. int wanrouter_proc_add (wan_device_t* wandev)
  729. {
  730. if (wandev->magic != ROUTER_MAGIC)
  731. return -EINVAL;
  733. memset(&wandev->dent, 0, sizeof(wandev->dent));
  734. wandev->dent.namelen = strlen(wandev->name);
  735. wandev->dent.name = wandev->name;
  736. wandev->dent.mode = 0444 | S_IFREG;
  737. wandev->dent.nlink = 1;
  738. wandev->dent.ops = &wandev_inode;
  739. wandev->dent.get_info = &wandev_get_info;
  740. wandev->dent.data = wandev;
  741. #ifdef LINUX_2_1
  742. return proc_register(&proc_router, &wandev->dent);
  743. #else
  744. return proc_register_dynamic(&proc_router, &wandev->dent);
  745. #endif
  746. }
  748. /*
  749.  * Delete directory entry for WAN device.
  750.  */
  751.  
  752. int wanrouter_proc_delete(wan_device_t* wandev)
  753. {
  754. if (wandev->magic != ROUTER_MAGIC)
  755. return -EINVAL;
  756. proc_unregister(&proc_router, wandev->dent.low_ino);
  757. return 0;
  758. }
  760. /****** Proc filesystem entry points ****************************************/
  762. /*
  763.  * Verify access rights.
  764.  */
  766. static int router_proc_perms (struct inode* inode, int op)
  767. {
  768. return 0;
  769. }
  771. /*
  772.  * Read router proc directory entry.
  773.  * This is universal routine for reading all entries in /proc/net/wanrouter
  774.  * directory.  Each directory entry contains a pointer to the 'method' for
  775.  * preparing data for that entry.
  776.  * o verify arguments
  777.  * o allocate kernel buffer
  778.  * o call get_info() to prepare data
  779.  * o copy data to user space
  780.  * o release kernel buffer
  781.  *
  782.  * Return: number of bytes copied to user space (0, if no data)
  783.  * <0 error
  784.  */
  785. #ifdef LINUX_2_1
  786. static ssize_t router_proc_read(struct file* file, char* buf, size_t count,
  787. loff_t *ppos)
  788. {
  789. struct inode *inode = file->f_dentry->d_inode;
  790. struct proc_dir_entry* dent;
  791. char* page;
  792. int pos, offs, len;
  794. if (count <= 0)
  795. return 0;
  797. dent = inode->u.generic_ip;
  798. if ((dent == NULL) || (dent->get_info == NULL))
  799. return 0;
  801. page = kmalloc(PROC_BUFSZ, GFP_KERNEL);
  802. if (page == NULL)
  803. return -ENOBUFS;
  805. pos = dent->get_info(page, dent->data, 0, 0, 0);
  806. offs = file->f_pos;
  807. if (offs < pos) {
  808. len = min_t(unsigned int, pos - offs, count);
  809. if (copy_to_user(buf, (page + offs), len)) {
  810. kfree(page);
  811. return -EFAULT;
  812. }
  813. file->f_pos += len;
  814. }
  815. else
  816. len = 0;
  817. kfree(page);
  818. return len;
  819. }
  821. #else
  822. static int router_proc_read(
  823. struct inode* inode, struct file* file, char* buf, int count)
  824. {
  825. struct proc_dir_entry* dent;
  826. char* page;
  827. int err, pos, offs, len;
  829. if (count <= 0)
  830. return 0;
  831. dent = inode->u.generic_ip;
  832. if ((dent == NULL) || (dent->get_info == NULL))
  833. return -ENODATA;
  834. err = verify_area(VERIFY_WRITE, buf, count);
  835. if (err) return err;
  837. page = kmalloc(PROC_BUFSZ, GFP_KERNEL);
  838. if (page == NULL)
  839. return -ENOMEM;
  841. pos = dent->get_info(page, dent->data, 0, 0, 0);
  842. offs = file->f_pos;
  843. if (offs < pos) {
  844. len = min_t(unsigned int, pos - offs, count);
  845. memcpy_tofs((void*)buf, (void*)(page + offs), len);
  846. file->f_pos += len;
  847. }
  848. else len = 0;
  849. kfree(page);
  850. return len;
  851. }
  852. #endif
  855. /*
  856.  * Prepare data for reading 'Config' entry.
  857.  * Return length of data.
  858.  */
  860. static int config_get_info(char* buf, char** start, off_t offs, int len, 
  861. int dummy)
  862. {
  863. int cnt = sizeof(conf_hdr) - 1;
  864. wan_device_t* wandev;
  865. strcpy(buf, conf_hdr);
  866. for (wandev = router_devlist;
  867.      wandev && (cnt < (PROC_BUFSZ - 120));
  868.      wandev = wandev->next) {
  869. if (wandev->state) cnt += sprintf(&buf[cnt],
  870. "%-15s|0x%-4X|%3u|%3u| 0x%-8lX |0x%-6X|%7u|%7u|%7u|%7un",
  871. wandev->name,
  872. wandev->ioport,
  873. wandev->irq,
  874. wandev->dma,
  875. wandev->maddr,
  876. wandev->msize,
  877. wandev->hw_opt[0],
  878. wandev->hw_opt[1],
  879. wandev->hw_opt[2],
  880. wandev->hw_opt[3]);
  881. }
  883. return cnt;
  884. }
  886. /*
  887.  * Prepare data for reading 'Status' entry.
  888.  * Return length of data.
  889.  */
  891. static int status_get_info(char* buf, char** start, off_t offs, int len, 
  892. int dummy)
  893. {
  894. int cnt = 0;
  895. wan_device_t* wandev;
  897. //cnt += sprintf(&buf[cnt], "nSTATUS:nn");
  898. strcpy(&buf[cnt], stat_hdr);
  899. cnt += sizeof(stat_hdr) - 1;
  901. for (wandev = router_devlist;
  902.      wandev && (cnt < (PROC_BUFSZ - 80));
  903.      wandev = wandev->next) {
  904. if (!wandev->state) continue;
  905. cnt += sprintf(&buf[cnt],
  906. "%-15s|%-8s|%-7s|%-9s|%-8s|%9u|%5u|%3u |",
  907. wandev->name,
  908. PROT_DECODE(wandev->config_id),
  909. wandev->config_id == WANCONFIG_FR ? 
  910. (wandev->station ? " Node" : " CPE") :
  911. (wandev->config_id == WANCONFIG_X25 ?
  912. (wandev->station ? " DCE" : " DTE") :
  913. (" N/A")),
  914. wandev->interface ? " V.35" : " RS-232",
  915. wandev->clocking ? "internal" : "external",
  916. wandev->bps,
  917. wandev->mtu,
  918. wandev->ndev);
  920. switch (wandev->state) {
  922. case WAN_UNCONFIGURED:
  923. cnt += sprintf(&buf[cnt], "%-12sn", "unconfigured");
  924. break;
  926. case WAN_DISCONNECTED:
  927. cnt += sprintf(&buf[cnt], "%-12sn", "disconnected");
  928. break;
  930. case WAN_CONNECTING:
  931. cnt += sprintf(&buf[cnt], "%-12sn", "connecting");
  932. break;
  934. case WAN_CONNECTED:
  935. cnt += sprintf(&buf[cnt], "%-12sn", "connected");
  936. break;
  938. case WAN_FT1_READY:
  939. cnt += sprintf(&buf[cnt], "%-12sn", "ft1 ready");
  940. break;
  942. default:
  943. cnt += sprintf(&buf[cnt], "%-12sn", "invalid");
  944. break;
  945. }
  946. }
  947. return cnt;
  948. }
  950. /*
  951.  * Prepare data for reading <device> entry.
  952.  * Return length of data.
  953.  *
  954.  * On entry, the 'start' argument will contain a pointer to WAN device
  955.  * data space.
  956.  */
  958. static int wandev_get_info(char* buf, char** start, off_t offs, int len, 
  959. int dummy)
  960. {
  961. wan_device_t* wandev = (void*)start;
  962. int cnt = 0;
  963. int rslt = 0;
  965. if ((wandev == NULL) || (wandev->magic != ROUTER_MAGIC))
  966. return 0;
  967. if (!wandev->state)
  968. return sprintf(&buf[cnt], "Device is not configured!n");
  970. /* Update device statistics */
  971. if (wandev->update) {
  973. rslt = wandev->update(wandev);
  974. if(rslt) {
  975. switch (rslt) {
  976. case -EAGAIN:
  977. return sprintf(&buf[cnt], "Device is busy!n");
  979. default:
  980. return sprintf(&buf[cnt],
  981. "Device is not configured!n");
  982. }
  983. }
  984. }
  986. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  987. "total packets received", wandev->stats.rx_packets);
  988. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  989. "total packets transmitted", wandev->stats.tx_packets);
  990. #ifdef LINUX_2_1
  991. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  992. "total bytes received", wandev->stats.rx_bytes);
  993. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  994. "total bytes transmitted", wandev->stats.tx_bytes);
  995. #endif
  996. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  997. "bad packets received", wandev->stats.rx_errors);
  998. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  999. "packet transmit problems", wandev->stats.tx_errors);
  1000. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1001. "received frames dropped", wandev->stats.rx_dropped);
  1002. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1003. "transmit frames dropped", wandev->stats.tx_dropped);
  1004. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1005. "multicast packets received", wandev->stats.multicast);
  1006. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1007. "transmit collisions", wandev->stats.collisions);
  1008. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1009. "receive length errors", wandev->stats.rx_length_errors);
  1010. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1011. "receiver overrun errors", wandev->stats.rx_over_errors);
  1012. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1013. "CRC errors", wandev->stats.rx_crc_errors);
  1014. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1015. "frame format errors (aborts)", wandev->stats.rx_frame_errors);
  1016. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1017. "receiver fifo overrun", wandev->stats.rx_fifo_errors);
  1018. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1019. "receiver missed packet", wandev->stats.rx_missed_errors);
  1020. cnt += sprintf(&buf[cnt], PROC_STATS_FORMAT,
  1021. "aborted frames transmitted", wandev->stats.tx_aborted_errors);
  1023. return cnt;
  1024. }
  1026. #endif /* End of ifdef LINUX_2_4 */
  1029. #else
  1031. /*
  1032.  * No /proc - output stubs
  1033.  */
  1035. int __init wanrouter_proc_init(void)
  1036. {
  1037. return 0;
  1038. }
  1040. void wanrouter_proc_cleanup(void)
  1041. {
  1042. return;
  1043. }
  1045. int wanrouter_proc_add(wan_device_t *wandev)
  1046. {
  1047. return 0;
  1048. }
  1050. int wanrouter_proc_delete(wan_device_t *wandev)
  1051. {
  1052. return 0;
  1053. }
  1055. #endif
  1057. /*============================================================================
  1058.  * Write WAN device ???.
  1059.  * o Find WAN device associated with this node
  1060.  */
  1061. #ifdef LINUX_2_0
  1062. static int device_write(
  1063.         struct inode* inode, struct file* file, const char* buf, int count)
  1064. {
  1065.         int err = verify_area(VERIFY_READ, buf, count);
  1066.         struct proc_dir_entry* dent;
  1067.         wan_device_t* wandev;
  1069.         if (err) return err;
  1071.         dent = inode->u.generic_ip;
  1072.         if ((dent == NULL) || (dent->data == NULL))
  1073.                 return -ENODATA;
  1075.         wandev = dent->data;
  1077.         printk(KERN_ERR "%s: writing %d bytes to %s...n",
  1078.                 name_root, count, dent->name);
  1079.         
  1080. return 0;
  1081. }
  1082. #endif
  1084. /*
  1085.  * End
  1086.  */
  1087.