atalk_proc.c 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * atalk_proc.c - proc support for Appletalk
  4. *
  5. * Copyright(c) Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  6. */
  7. #include <linux/init.h>
  8. #include <linux/proc_fs.h>
  9. #include <linux/seq_file.h>
  10. #include <net/net_namespace.h>
  11. #include <net/sock.h>
  12. #include <linux/atalk.h>
  13. #include <linux/export.h>
  14. static __inline__ struct atalk_iface *atalk_get_interface_idx(loff_t pos)
  15. {
  16. struct atalk_iface *i;
  17. for (i = atalk_interfaces; pos && i; i = i->next)
  18. --pos;
  19. return i;
  20. }
  21. static void *atalk_seq_interface_start(struct seq_file *seq, loff_t *pos)
  22. __acquires(atalk_interfaces_lock)
  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. __releases(atalk_interfaces_lock)
  45. {
  46. read_unlock_bh(&atalk_interfaces_lock);
  47. }
  48. static int atalk_seq_interface_show(struct seq_file *seq, void *v)
  49. {
  50. struct atalk_iface *iface;
  51. if (v == SEQ_START_TOKEN) {
  52. seq_puts(seq, "Interface Address Networks "
  53. "Status\n");
  54. goto out;
  55. }
  56. iface = v;
  57. seq_printf(seq, "%-16s %04X:%02X %04X-%04X %d\n",
  58. iface->dev->name, ntohs(iface->address.s_net),
  59. iface->address.s_node, ntohs(iface->nets.nr_firstnet),
  60. ntohs(iface->nets.nr_lastnet), iface->status);
  61. out:
  62. return 0;
  63. }
  64. static __inline__ struct atalk_route *atalk_get_route_idx(loff_t pos)
  65. {
  66. struct atalk_route *r;
  67. for (r = atalk_routes; pos && r; r = r->next)
  68. --pos;
  69. return r;
  70. }
  71. static void *atalk_seq_route_start(struct seq_file *seq, loff_t *pos)
  72. __acquires(atalk_routes_lock)
  73. {
  74. loff_t l = *pos;
  75. read_lock_bh(&atalk_routes_lock);
  76. return l ? atalk_get_route_idx(--l) : SEQ_START_TOKEN;
  77. }
  78. static void *atalk_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
  79. {
  80. struct atalk_route *r;
  81. ++*pos;
  82. if (v == SEQ_START_TOKEN) {
  83. r = NULL;
  84. if (atalk_routes)
  85. r = atalk_routes;
  86. goto out;
  87. }
  88. r = v;
  89. r = r->next;
  90. out:
  91. return r;
  92. }
  93. static void atalk_seq_route_stop(struct seq_file *seq, void *v)
  94. __releases(atalk_routes_lock)
  95. {
  96. read_unlock_bh(&atalk_routes_lock);
  97. }
  98. static int atalk_seq_route_show(struct seq_file *seq, void *v)
  99. {
  100. struct atalk_route *rt;
  101. if (v == SEQ_START_TOKEN) {
  102. seq_puts(seq, "Target Router Flags Dev\n");
  103. goto out;
  104. }
  105. if (atrtr_default.dev) {
  106. rt = &atrtr_default;
  107. seq_printf(seq, "Default %04X:%02X %-4d %s\n",
  108. ntohs(rt->gateway.s_net), rt->gateway.s_node,
  109. rt->flags, rt->dev->name);
  110. }
  111. rt = v;
  112. seq_printf(seq, "%04X:%02X %04X:%02X %-4d %s\n",
  113. ntohs(rt->target.s_net), rt->target.s_node,
  114. ntohs(rt->gateway.s_net), rt->gateway.s_node,
  115. rt->flags, rt->dev->name);
  116. out:
  117. return 0;
  118. }
  119. static void *atalk_seq_socket_start(struct seq_file *seq, loff_t *pos)
  120. __acquires(atalk_sockets_lock)
  121. {
  122. read_lock_bh(&atalk_sockets_lock);
  123. return seq_hlist_start_head(&atalk_sockets, *pos);
  124. }
  125. static void *atalk_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
  126. {
  127. return seq_hlist_next(v, &atalk_sockets, pos);
  128. }
  129. static void atalk_seq_socket_stop(struct seq_file *seq, void *v)
  130. __releases(atalk_sockets_lock)
  131. {
  132. read_unlock_bh(&atalk_sockets_lock);
  133. }
  134. static int atalk_seq_socket_show(struct seq_file *seq, void *v)
  135. {
  136. struct sock *s;
  137. struct atalk_sock *at;
  138. if (v == SEQ_START_TOKEN) {
  139. seq_printf(seq, "Type Local_addr Remote_addr Tx_queue "
  140. "Rx_queue St UID\n");
  141. goto out;
  142. }
  143. s = sk_entry(v);
  144. at = at_sk(s);
  145. seq_printf(seq, "%02X %04X:%02X:%02X %04X:%02X:%02X %08X:%08X "
  146. "%02X %u\n",
  147. s->sk_type, ntohs(at->src_net), at->src_node, at->src_port,
  148. ntohs(at->dest_net), at->dest_node, at->dest_port,
  149. sk_wmem_alloc_get(s),
  150. sk_rmem_alloc_get(s),
  151. s->sk_state,
  152. from_kuid_munged(seq_user_ns(seq), sock_i_uid(s)));
  153. out:
  154. return 0;
  155. }
  156. static const struct seq_operations atalk_seq_interface_ops = {
  157. .start = atalk_seq_interface_start,
  158. .next = atalk_seq_interface_next,
  159. .stop = atalk_seq_interface_stop,
  160. .show = atalk_seq_interface_show,
  161. };
  162. static const struct seq_operations atalk_seq_route_ops = {
  163. .start = atalk_seq_route_start,
  164. .next = atalk_seq_route_next,
  165. .stop = atalk_seq_route_stop,
  166. .show = atalk_seq_route_show,
  167. };
  168. static const struct seq_operations atalk_seq_socket_ops = {
  169. .start = atalk_seq_socket_start,
  170. .next = atalk_seq_socket_next,
  171. .stop = atalk_seq_socket_stop,
  172. .show = atalk_seq_socket_show,
  173. };
  174. int __init atalk_proc_init(void)
  175. {
  176. if (!proc_mkdir("atalk", init_net.proc_net))
  177. return -ENOMEM;
  178. if (!proc_create_seq("atalk/interface", 0444, init_net.proc_net,
  179. &atalk_seq_interface_ops))
  180. goto out;
  181. if (!proc_create_seq("atalk/route", 0444, init_net.proc_net,
  182. &atalk_seq_route_ops))
  183. goto out;
  184. if (!proc_create_seq("atalk/socket", 0444, init_net.proc_net,
  185. &atalk_seq_socket_ops))
  186. goto out;
  187. if (!proc_create_seq_private("atalk/arp", 0444, init_net.proc_net,
  188. &aarp_seq_ops,
  189. sizeof(struct aarp_iter_state), NULL))
  190. goto out;
  191. return 0;
  192. out:
  193. remove_proc_subtree("atalk", init_net.proc_net);
  194. return -ENOMEM;
  195. }
  196. void atalk_proc_exit(void)
  197. {
  198. remove_proc_subtree("atalk", init_net.proc_net);
  199. }