atalk_proc.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. /*
  2. * atalk_proc.c - proc support for Appletalk
  3. *
  4. * Copyright(c) Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  5. *
  6. * This program is free software; you can redistribute it and/or modify it
  7. * under the terms of the GNU General Public License as published by the
  8. * Free Software Foundation, version 2.
  9. */
  10. #include <linux/init.h>
  11. #include <linux/proc_fs.h>
  12. #include <linux/seq_file.h>
  13. #include <net/sock.h>
  14. #include <linux/atalk.h>
  15. static __inline__ struct atalk_iface *atalk_get_interface_idx(loff_t pos)
  16. {
  17. struct atalk_iface *i;
  18. for (i = atalk_interfaces; pos && i; i = i->next)
  19. --pos;
  20. return i;
  21. }
  22. static void *atalk_seq_interface_start(struct seq_file *seq, loff_t *pos)
  23. {
  24. loff_t l = *pos;
  25. read_lock_bh(&atalk_interfaces_lock);
  26. return l ? atalk_get_interface_idx(--l) : SEQ_START_TOKEN;
  27. }
  28. static void *atalk_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos)
  29. {
  30. struct atalk_iface *i;
  31. ++*pos;
  32. if (v == SEQ_START_TOKEN) {
  33. i = NULL;
  34. if (atalk_interfaces)
  35. i = atalk_interfaces;
  36. goto out;
  37. }
  38. i = v;
  39. i = i->next;
  40. out:
  41. return i;
  42. }
  43. static void atalk_seq_interface_stop(struct seq_file *seq, void *v)
  44. {
  45. read_unlock_bh(&atalk_interfaces_lock);
  46. }
  47. static int atalk_seq_interface_show(struct seq_file *seq, void *v)
  48. {
  49. struct atalk_iface *iface;
  50. if (v == SEQ_START_TOKEN) {
  51. seq_puts(seq, "Interface Address Networks "
  52. "Status\n");
  53. goto out;
  54. }
  55. iface = v;
  56. seq_printf(seq, "%-16s %04X:%02X %04X-%04X %d\n",
  57. iface->dev->name, ntohs(iface->address.s_net),
  58. iface->address.s_node, ntohs(iface->nets.nr_firstnet),
  59. ntohs(iface->nets.nr_lastnet), iface->status);
  60. out:
  61. return 0;
  62. }
  63. static __inline__ struct atalk_route *atalk_get_route_idx(loff_t pos)
  64. {
  65. struct atalk_route *r;
  66. for (r = atalk_routes; pos && r; r = r->next)
  67. --pos;
  68. return r;
  69. }
  70. static void *atalk_seq_route_start(struct seq_file *seq, loff_t *pos)
  71. {
  72. loff_t l = *pos;
  73. read_lock_bh(&atalk_routes_lock);
  74. return l ? atalk_get_route_idx(--l) : SEQ_START_TOKEN;
  75. }
  76. static void *atalk_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
  77. {
  78. struct atalk_route *r;
  79. ++*pos;
  80. if (v == SEQ_START_TOKEN) {
  81. r = NULL;
  82. if (atalk_routes)
  83. r = atalk_routes;
  84. goto out;
  85. }
  86. r = v;
  87. r = r->next;
  88. out:
  89. return r;
  90. }
  91. static void atalk_seq_route_stop(struct seq_file *seq, void *v)
  92. {
  93. read_unlock_bh(&atalk_routes_lock);
  94. }
  95. static int atalk_seq_route_show(struct seq_file *seq, void *v)
  96. {
  97. struct atalk_route *rt;
  98. if (v == SEQ_START_TOKEN) {
  99. seq_puts(seq, "Target Router Flags Dev\n");
  100. goto out;
  101. }
  102. if (atrtr_default.dev) {
  103. rt = &atrtr_default;
  104. seq_printf(seq, "Default %04X:%02X %-4d %s\n",
  105. ntohs(rt->gateway.s_net), rt->gateway.s_node,
  106. rt->flags, rt->dev->name);
  107. }
  108. rt = v;
  109. seq_printf(seq, "%04X:%02X %04X:%02X %-4d %s\n",
  110. ntohs(rt->target.s_net), rt->target.s_node,
  111. ntohs(rt->gateway.s_net), rt->gateway.s_node,
  112. rt->flags, rt->dev->name);
  113. out:
  114. return 0;
  115. }
  116. static __inline__ struct sock *atalk_get_socket_idx(loff_t pos)
  117. {
  118. struct sock *s;
  119. struct hlist_node *node;
  120. sk_for_each(s, node, &atalk_sockets)
  121. if (!pos--)
  122. goto found;
  123. s = NULL;
  124. found:
  125. return s;
  126. }
  127. static void *atalk_seq_socket_start(struct seq_file *seq, loff_t *pos)
  128. {
  129. loff_t l = *pos;
  130. read_lock_bh(&atalk_sockets_lock);
  131. return l ? atalk_get_socket_idx(--l) : SEQ_START_TOKEN;
  132. }
  133. static void *atalk_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
  134. {
  135. struct sock *i;
  136. ++*pos;
  137. if (v == SEQ_START_TOKEN) {
  138. i = sk_head(&atalk_sockets);
  139. goto out;
  140. }
  141. i = sk_next(v);
  142. out:
  143. return i;
  144. }
  145. static void atalk_seq_socket_stop(struct seq_file *seq, void *v)
  146. {
  147. read_unlock_bh(&atalk_sockets_lock);
  148. }
  149. static int atalk_seq_socket_show(struct seq_file *seq, void *v)
  150. {
  151. struct sock *s;
  152. struct atalk_sock *at;
  153. if (v == SEQ_START_TOKEN) {
  154. seq_printf(seq, "Type Local_addr Remote_addr Tx_queue "
  155. "Rx_queue St UID\n");
  156. goto out;
  157. }
  158. s = v;
  159. at = at_sk(s);
  160. seq_printf(seq, "%02X %04X:%02X:%02X %04X:%02X:%02X %08X:%08X "
  161. "%02X %d\n",
  162. s->sk_type, ntohs(at->src_net), at->src_node, at->src_port,
  163. ntohs(at->dest_net), at->dest_node, at->dest_port,
  164. atomic_read(&s->sk_wmem_alloc),
  165. atomic_read(&s->sk_rmem_alloc),
  166. s->sk_state, SOCK_INODE(s->sk_socket)->i_uid);
  167. out:
  168. return 0;
  169. }
  170. static struct seq_operations atalk_seq_interface_ops = {
  171. .start = atalk_seq_interface_start,
  172. .next = atalk_seq_interface_next,
  173. .stop = atalk_seq_interface_stop,
  174. .show = atalk_seq_interface_show,
  175. };
  176. static struct seq_operations atalk_seq_route_ops = {
  177. .start = atalk_seq_route_start,
  178. .next = atalk_seq_route_next,
  179. .stop = atalk_seq_route_stop,
  180. .show = atalk_seq_route_show,
  181. };
  182. static struct seq_operations atalk_seq_socket_ops = {
  183. .start = atalk_seq_socket_start,
  184. .next = atalk_seq_socket_next,
  185. .stop = atalk_seq_socket_stop,
  186. .show = atalk_seq_socket_show,
  187. };
  188. static int atalk_seq_interface_open(struct inode *inode, struct file *file)
  189. {
  190. return seq_open(file, &atalk_seq_interface_ops);
  191. }
  192. static int atalk_seq_route_open(struct inode *inode, struct file *file)
  193. {
  194. return seq_open(file, &atalk_seq_route_ops);
  195. }
  196. static int atalk_seq_socket_open(struct inode *inode, struct file *file)
  197. {
  198. return seq_open(file, &atalk_seq_socket_ops);
  199. }
  200. static const struct file_operations atalk_seq_interface_fops = {
  201. .owner = THIS_MODULE,
  202. .open = atalk_seq_interface_open,
  203. .read = seq_read,
  204. .llseek = seq_lseek,
  205. .release = seq_release,
  206. };
  207. static const struct file_operations atalk_seq_route_fops = {
  208. .owner = THIS_MODULE,
  209. .open = atalk_seq_route_open,
  210. .read = seq_read,
  211. .llseek = seq_lseek,
  212. .release = seq_release,
  213. };
  214. static const struct file_operations atalk_seq_socket_fops = {
  215. .owner = THIS_MODULE,
  216. .open = atalk_seq_socket_open,
  217. .read = seq_read,
  218. .llseek = seq_lseek,
  219. .release = seq_release,
  220. };
  221. static struct proc_dir_entry *atalk_proc_dir;
  222. int __init atalk_proc_init(void)
  223. {
  224. struct proc_dir_entry *p;
  225. int rc = -ENOMEM;
  226. atalk_proc_dir = proc_mkdir("atalk", proc_net);
  227. if (!atalk_proc_dir)
  228. goto out;
  229. atalk_proc_dir->owner = THIS_MODULE;
  230. p = create_proc_entry("interface", S_IRUGO, atalk_proc_dir);
  231. if (!p)
  232. goto out_interface;
  233. p->proc_fops = &atalk_seq_interface_fops;
  234. p = create_proc_entry("route", S_IRUGO, atalk_proc_dir);
  235. if (!p)
  236. goto out_route;
  237. p->proc_fops = &atalk_seq_route_fops;
  238. p = create_proc_entry("socket", S_IRUGO, atalk_proc_dir);
  239. if (!p)
  240. goto out_socket;
  241. p->proc_fops = &atalk_seq_socket_fops;
  242. p = create_proc_entry("arp", S_IRUGO, atalk_proc_dir);
  243. if (!p)
  244. goto out_arp;
  245. p->proc_fops = &atalk_seq_arp_fops;
  246. rc = 0;
  247. out:
  248. return rc;
  249. out_arp:
  250. remove_proc_entry("socket", atalk_proc_dir);
  251. out_socket:
  252. remove_proc_entry("route", atalk_proc_dir);
  253. out_route:
  254. remove_proc_entry("interface", atalk_proc_dir);
  255. out_interface:
  256. remove_proc_entry("atalk", proc_net);
  257. goto out;
  258. }
  259. void __exit atalk_proc_exit(void)
  260. {
  261. remove_proc_entry("interface", atalk_proc_dir);
  262. remove_proc_entry("route", atalk_proc_dir);
  263. remove_proc_entry("socket", atalk_proc_dir);
  264. remove_proc_entry("arp", atalk_proc_dir);
  265. remove_proc_entry("atalk", proc_net);
  266. }