/drivers/net/bonding/bond_procfs.c

http://github.com/mirrors/linux · C · 312 lines · 258 code · 46 blank · 8 comment · 42 complexity · ede5c58185fec00bbbd921e74b532ad4 MD5 · raw file

  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <linux/proc_fs.h>
  3. #include <linux/export.h>
  4. #include <net/net_namespace.h>
  5. #include <net/netns/generic.h>
  6. #include <net/bonding.h>
  7. #include "bonding_priv.h"
  8. static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
  9. __acquires(RCU)
  10. {
  11. struct bonding *bond = PDE_DATA(file_inode(seq->file));
  12. struct list_head *iter;
  13. struct slave *slave;
  14. loff_t off = 0;
  15. rcu_read_lock();
  16. if (*pos == 0)
  17. return SEQ_START_TOKEN;
  18. bond_for_each_slave_rcu(bond, slave, iter)
  19. if (++off == *pos)
  20. return slave;
  21. return NULL;
  22. }
  23. static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  24. {
  25. struct bonding *bond = PDE_DATA(file_inode(seq->file));
  26. struct list_head *iter;
  27. struct slave *slave;
  28. bool found = false;
  29. ++*pos;
  30. if (v == SEQ_START_TOKEN)
  31. return bond_first_slave_rcu(bond);
  32. bond_for_each_slave_rcu(bond, slave, iter) {
  33. if (found)
  34. return slave;
  35. if (slave == v)
  36. found = true;
  37. }
  38. return NULL;
  39. }
  40. static void bond_info_seq_stop(struct seq_file *seq, void *v)
  41. __releases(RCU)
  42. {
  43. rcu_read_unlock();
  44. }
  45. static void bond_info_show_master(struct seq_file *seq)
  46. {
  47. struct bonding *bond = PDE_DATA(file_inode(seq->file));
  48. const struct bond_opt_value *optval;
  49. struct slave *curr, *primary;
  50. int i;
  51. curr = rcu_dereference(bond->curr_active_slave);
  52. seq_printf(seq, "Bonding Mode: %s",
  53. bond_mode_name(BOND_MODE(bond)));
  54. if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP &&
  55. bond->params.fail_over_mac) {
  56. optval = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC,
  57. bond->params.fail_over_mac);
  58. seq_printf(seq, " (fail_over_mac %s)", optval->string);
  59. }
  60. seq_printf(seq, "\n");
  61. if (bond_mode_uses_xmit_hash(bond)) {
  62. optval = bond_opt_get_val(BOND_OPT_XMIT_HASH,
  63. bond->params.xmit_policy);
  64. seq_printf(seq, "Transmit Hash Policy: %s (%d)\n",
  65. optval->string, bond->params.xmit_policy);
  66. }
  67. if (bond_uses_primary(bond)) {
  68. primary = rcu_dereference(bond->primary_slave);
  69. seq_printf(seq, "Primary Slave: %s",
  70. primary ? primary->dev->name : "None");
  71. if (primary) {
  72. optval = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT,
  73. bond->params.primary_reselect);
  74. seq_printf(seq, " (primary_reselect %s)",
  75. optval->string);
  76. }
  77. seq_printf(seq, "\nCurrently Active Slave: %s\n",
  78. (curr) ? curr->dev->name : "None");
  79. }
  80. seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
  81. "up" : "down");
  82. seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
  83. seq_printf(seq, "Up Delay (ms): %d\n",
  84. bond->params.updelay * bond->params.miimon);
  85. seq_printf(seq, "Down Delay (ms): %d\n",
  86. bond->params.downdelay * bond->params.miimon);
  87. seq_printf(seq, "Peer Notification Delay (ms): %d\n",
  88. bond->params.peer_notif_delay * bond->params.miimon);
  89. /* ARP information */
  90. if (bond->params.arp_interval > 0) {
  91. int printed = 0;
  92. seq_printf(seq, "ARP Polling Interval (ms): %d\n",
  93. bond->params.arp_interval);
  94. seq_printf(seq, "ARP IP target/s (n.n.n.n form):");
  95. for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
  96. if (!bond->params.arp_targets[i])
  97. break;
  98. if (printed)
  99. seq_printf(seq, ",");
  100. seq_printf(seq, " %pI4", &bond->params.arp_targets[i]);
  101. printed = 1;
  102. }
  103. seq_printf(seq, "\n");
  104. }
  105. if (BOND_MODE(bond) == BOND_MODE_8023AD) {
  106. struct ad_info ad_info;
  107. seq_puts(seq, "\n802.3ad info\n");
  108. seq_printf(seq, "LACP rate: %s\n",
  109. (bond->params.lacp_fast) ? "fast" : "slow");
  110. seq_printf(seq, "Min links: %d\n", bond->params.min_links);
  111. optval = bond_opt_get_val(BOND_OPT_AD_SELECT,
  112. bond->params.ad_select);
  113. seq_printf(seq, "Aggregator selection policy (ad_select): %s\n",
  114. optval->string);
  115. if (capable(CAP_NET_ADMIN)) {
  116. seq_printf(seq, "System priority: %d\n",
  117. BOND_AD_INFO(bond).system.sys_priority);
  118. seq_printf(seq, "System MAC address: %pM\n",
  119. &BOND_AD_INFO(bond).system.sys_mac_addr);
  120. if (__bond_3ad_get_active_agg_info(bond, &ad_info)) {
  121. seq_printf(seq,
  122. "bond %s has no active aggregator\n",
  123. bond->dev->name);
  124. } else {
  125. seq_printf(seq, "Active Aggregator Info:\n");
  126. seq_printf(seq, "\tAggregator ID: %d\n",
  127. ad_info.aggregator_id);
  128. seq_printf(seq, "\tNumber of ports: %d\n",
  129. ad_info.ports);
  130. seq_printf(seq, "\tActor Key: %d\n",
  131. ad_info.actor_key);
  132. seq_printf(seq, "\tPartner Key: %d\n",
  133. ad_info.partner_key);
  134. seq_printf(seq, "\tPartner Mac Address: %pM\n",
  135. ad_info.partner_system);
  136. }
  137. }
  138. }
  139. }
  140. static void bond_info_show_slave(struct seq_file *seq,
  141. const struct slave *slave)
  142. {
  143. struct bonding *bond = PDE_DATA(file_inode(seq->file));
  144. seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
  145. seq_printf(seq, "MII Status: %s\n", bond_slave_link_status(slave->link));
  146. if (slave->speed == SPEED_UNKNOWN)
  147. seq_printf(seq, "Speed: %s\n", "Unknown");
  148. else
  149. seq_printf(seq, "Speed: %d Mbps\n", slave->speed);
  150. if (slave->duplex == DUPLEX_UNKNOWN)
  151. seq_printf(seq, "Duplex: %s\n", "Unknown");
  152. else
  153. seq_printf(seq, "Duplex: %s\n", slave->duplex ? "full" : "half");
  154. seq_printf(seq, "Link Failure Count: %u\n",
  155. slave->link_failure_count);
  156. seq_printf(seq, "Permanent HW addr: %*phC\n",
  157. slave->dev->addr_len, slave->perm_hwaddr);
  158. seq_printf(seq, "Slave queue ID: %d\n", slave->queue_id);
  159. if (BOND_MODE(bond) == BOND_MODE_8023AD) {
  160. const struct port *port = &SLAVE_AD_INFO(slave)->port;
  161. const struct aggregator *agg = port->aggregator;
  162. if (agg) {
  163. seq_printf(seq, "Aggregator ID: %d\n",
  164. agg->aggregator_identifier);
  165. seq_printf(seq, "Actor Churn State: %s\n",
  166. bond_3ad_churn_desc(port->sm_churn_actor_state));
  167. seq_printf(seq, "Partner Churn State: %s\n",
  168. bond_3ad_churn_desc(port->sm_churn_partner_state));
  169. seq_printf(seq, "Actor Churned Count: %d\n",
  170. port->churn_actor_count);
  171. seq_printf(seq, "Partner Churned Count: %d\n",
  172. port->churn_partner_count);
  173. if (capable(CAP_NET_ADMIN)) {
  174. seq_puts(seq, "details actor lacp pdu:\n");
  175. seq_printf(seq, " system priority: %d\n",
  176. port->actor_system_priority);
  177. seq_printf(seq, " system mac address: %pM\n",
  178. &port->actor_system);
  179. seq_printf(seq, " port key: %d\n",
  180. port->actor_oper_port_key);
  181. seq_printf(seq, " port priority: %d\n",
  182. port->actor_port_priority);
  183. seq_printf(seq, " port number: %d\n",
  184. port->actor_port_number);
  185. seq_printf(seq, " port state: %d\n",
  186. port->actor_oper_port_state);
  187. seq_puts(seq, "details partner lacp pdu:\n");
  188. seq_printf(seq, " system priority: %d\n",
  189. port->partner_oper.system_priority);
  190. seq_printf(seq, " system mac address: %pM\n",
  191. &port->partner_oper.system);
  192. seq_printf(seq, " oper key: %d\n",
  193. port->partner_oper.key);
  194. seq_printf(seq, " port priority: %d\n",
  195. port->partner_oper.port_priority);
  196. seq_printf(seq, " port number: %d\n",
  197. port->partner_oper.port_number);
  198. seq_printf(seq, " port state: %d\n",
  199. port->partner_oper.port_state);
  200. }
  201. } else {
  202. seq_puts(seq, "Aggregator ID: N/A\n");
  203. }
  204. }
  205. }
  206. static int bond_info_seq_show(struct seq_file *seq, void *v)
  207. {
  208. if (v == SEQ_START_TOKEN) {
  209. seq_printf(seq, "%s\n", bond_version);
  210. bond_info_show_master(seq);
  211. } else
  212. bond_info_show_slave(seq, v);
  213. return 0;
  214. }
  215. static const struct seq_operations bond_info_seq_ops = {
  216. .start = bond_info_seq_start,
  217. .next = bond_info_seq_next,
  218. .stop = bond_info_seq_stop,
  219. .show = bond_info_seq_show,
  220. };
  221. void bond_create_proc_entry(struct bonding *bond)
  222. {
  223. struct net_device *bond_dev = bond->dev;
  224. struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
  225. if (bn->proc_dir) {
  226. bond->proc_entry = proc_create_seq_data(bond_dev->name, 0444,
  227. bn->proc_dir, &bond_info_seq_ops, bond);
  228. if (bond->proc_entry == NULL)
  229. netdev_warn(bond_dev, "Cannot create /proc/net/%s/%s\n",
  230. DRV_NAME, bond_dev->name);
  231. else
  232. memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
  233. }
  234. }
  235. void bond_remove_proc_entry(struct bonding *bond)
  236. {
  237. struct net_device *bond_dev = bond->dev;
  238. struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
  239. if (bn->proc_dir && bond->proc_entry) {
  240. remove_proc_entry(bond->proc_file_name, bn->proc_dir);
  241. memset(bond->proc_file_name, 0, IFNAMSIZ);
  242. bond->proc_entry = NULL;
  243. }
  244. }
  245. /* Create the bonding directory under /proc/net, if doesn't exist yet.
  246. * Caller must hold rtnl_lock.
  247. */
  248. void __net_init bond_create_proc_dir(struct bond_net *bn)
  249. {
  250. if (!bn->proc_dir) {
  251. bn->proc_dir = proc_mkdir(DRV_NAME, bn->net->proc_net);
  252. if (!bn->proc_dir)
  253. pr_warn("Warning: Cannot create /proc/net/%s\n",
  254. DRV_NAME);
  255. }
  256. }
  257. /* Destroy the bonding directory under /proc/net, if empty.
  258. * Caller must hold rtnl_lock.
  259. */
  260. void __net_exit bond_destroy_proc_dir(struct bond_net *bn)
  261. {
  262. if (bn->proc_dir) {
  263. remove_proc_entry(DRV_NAME, bn->net->proc_net);
  264. bn->proc_dir = NULL;
  265. }
  266. }