1 /* 2 * proc_llc.c - proc interface for LLC 3 * 4 * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org> 5 * 2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br> 6 * 7 * This program can be redistributed or modified under the terms of the 8 * GNU General Public License as published by the Free Software Foundation. 9 * This program is distributed without any warranty or implied warranty 10 * of merchantability or fitness for a particular purpose. 11 * 12 * See the GNU General Public License for more details. 13 */ 14 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/proc_fs.h> 18 #include <linux/errno.h> 19 #include <linux/seq_file.h> 20 #include <net/sock.h> 21 #include <net/llc.h> 22 #include <net/llc_c_ac.h> 23 #include <net/llc_c_ev.h> 24 #include <net/llc_c_st.h> 25 #include <net/llc_conn.h> 26 27 static void llc_ui_format_mac(struct seq_file *seq, unsigned char *mac) 28 { 29 seq_printf(seq, "%02X:%02X:%02X:%02X:%02X:%02X", 30 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); 31 } 32 33 static struct sock *llc_get_sk_idx(loff_t pos) 34 { 35 struct list_head *sap_entry; 36 struct llc_sap *sap; 37 struct hlist_node *node; 38 struct sock *sk = NULL; 39 40 list_for_each(sap_entry, &llc_sap_list) { 41 sap = list_entry(sap_entry, struct llc_sap, node); 42 43 read_lock_bh(&sap->sk_list.lock); 44 sk_for_each(sk, node, &sap->sk_list.list) { 45 if (!pos) 46 goto found; 47 --pos; 48 } 49 read_unlock_bh(&sap->sk_list.lock); 50 } 51 sk = NULL; 52 found: 53 return sk; 54 } 55 56 static void *llc_seq_start(struct seq_file *seq, loff_t *pos) 57 { 58 loff_t l = *pos; 59 60 read_lock_bh(&llc_sap_list_lock); 61 return l ? llc_get_sk_idx(--l) : SEQ_START_TOKEN; 62 } 63 64 static void *llc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 65 { 66 struct sock* sk, *next; 67 struct llc_sock *llc; 68 struct llc_sap *sap; 69 70 ++*pos; 71 if (v == SEQ_START_TOKEN) { 72 sk = llc_get_sk_idx(0); 73 goto out; 74 } 75 sk = v; 76 next = sk_next(sk); 77 if (next) { 78 sk = next; 79 goto out; 80 } 81 llc = llc_sk(sk); 82 sap = llc->sap; 83 read_unlock_bh(&sap->sk_list.lock); 84 sk = NULL; 85 for (;;) { 86 if (sap->node.next == &llc_sap_list) 87 break; 88 sap = list_entry(sap->node.next, struct llc_sap, node); 89 read_lock_bh(&sap->sk_list.lock); 90 if (!hlist_empty(&sap->sk_list.list)) { 91 sk = sk_head(&sap->sk_list.list); 92 break; 93 } 94 read_unlock_bh(&sap->sk_list.lock); 95 } 96 out: 97 return sk; 98 } 99 100 static void llc_seq_stop(struct seq_file *seq, void *v) 101 { 102 if (v && v != SEQ_START_TOKEN) { 103 struct sock *sk = v; 104 struct llc_sock *llc = llc_sk(sk); 105 struct llc_sap *sap = llc->sap; 106 107 read_unlock_bh(&sap->sk_list.lock); 108 } 109 read_unlock_bh(&llc_sap_list_lock); 110 } 111 112 static int llc_seq_socket_show(struct seq_file *seq, void *v) 113 { 114 struct sock* sk; 115 struct llc_sock *llc; 116 117 if (v == SEQ_START_TOKEN) { 118 seq_puts(seq, "SKt Mc local_mac_sap remote_mac_sap " 119 " tx_queue rx_queue st uid link\n"); 120 goto out; 121 } 122 sk = v; 123 llc = llc_sk(sk); 124 125 /* FIXME: check if the address is multicast */ 126 seq_printf(seq, "%2X %2X ", sk->sk_type, 0); 127 128 if (llc->dev) 129 llc_ui_format_mac(seq, llc->dev->dev_addr); 130 else 131 seq_printf(seq, "00:00:00:00:00:00"); 132 seq_printf(seq, "@%02X ", llc->sap->laddr.lsap); 133 llc_ui_format_mac(seq, llc->daddr.mac); 134 seq_printf(seq, "@%02X %8d %8d %2d %3d %4d\n", llc->daddr.lsap, 135 atomic_read(&sk->sk_wmem_alloc), 136 atomic_read(&sk->sk_rmem_alloc) - llc->copied_seq, 137 sk->sk_state, 138 sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : -1, 139 llc->link); 140 out: 141 return 0; 142 } 143 144 static char *llc_conn_state_names[] = { 145 [LLC_CONN_STATE_ADM] = "adm", 146 [LLC_CONN_STATE_SETUP] = "setup", 147 [LLC_CONN_STATE_NORMAL] = "normal", 148 [LLC_CONN_STATE_BUSY] = "busy", 149 [LLC_CONN_STATE_REJ] = "rej", 150 [LLC_CONN_STATE_AWAIT] = "await", 151 [LLC_CONN_STATE_AWAIT_BUSY] = "await_busy", 152 [LLC_CONN_STATE_AWAIT_REJ] = "await_rej", 153 [LLC_CONN_STATE_D_CONN] = "d_conn", 154 [LLC_CONN_STATE_RESET] = "reset", 155 [LLC_CONN_STATE_ERROR] = "error", 156 [LLC_CONN_STATE_TEMP] = "temp", 157 }; 158 159 static int llc_seq_core_show(struct seq_file *seq, void *v) 160 { 161 struct sock* sk; 162 struct llc_sock *llc; 163 164 if (v == SEQ_START_TOKEN) { 165 seq_puts(seq, "Connection list:\n" 166 "dsap state retr txw rxw pf ff sf df rs cs " 167 "tack tpfc trs tbs blog busr\n"); 168 goto out; 169 } 170 sk = v; 171 llc = llc_sk(sk); 172 173 seq_printf(seq, " %02X %-10s %3d %3d %3d %2d %2d %2d %2d %2d %2d " 174 "%4d %4d %3d %3d %4d %4d\n", 175 llc->daddr.lsap, llc_conn_state_names[llc->state], 176 llc->retry_count, llc->k, llc->rw, llc->p_flag, llc->f_flag, 177 llc->s_flag, llc->data_flag, llc->remote_busy_flag, 178 llc->cause_flag, timer_pending(&llc->ack_timer.timer), 179 timer_pending(&llc->pf_cycle_timer.timer), 180 timer_pending(&llc->rej_sent_timer.timer), 181 timer_pending(&llc->busy_state_timer.timer), 182 !!sk->sk_backlog.tail, !!sock_owned_by_user(sk)); 183 out: 184 return 0; 185 } 186 187 static struct seq_operations llc_seq_socket_ops = { 188 .start = llc_seq_start, 189 .next = llc_seq_next, 190 .stop = llc_seq_stop, 191 .show = llc_seq_socket_show, 192 }; 193 194 static struct seq_operations llc_seq_core_ops = { 195 .start = llc_seq_start, 196 .next = llc_seq_next, 197 .stop = llc_seq_stop, 198 .show = llc_seq_core_show, 199 }; 200 201 static int llc_seq_socket_open(struct inode *inode, struct file *file) 202 { 203 return seq_open(file, &llc_seq_socket_ops); 204 } 205 206 static int llc_seq_core_open(struct inode *inode, struct file *file) 207 { 208 return seq_open(file, &llc_seq_core_ops); 209 } 210 211 static const struct file_operations llc_seq_socket_fops = { 212 .owner = THIS_MODULE, 213 .open = llc_seq_socket_open, 214 .read = seq_read, 215 .llseek = seq_lseek, 216 .release = seq_release, 217 }; 218 219 static const struct file_operations llc_seq_core_fops = { 220 .owner = THIS_MODULE, 221 .open = llc_seq_core_open, 222 .read = seq_read, 223 .llseek = seq_lseek, 224 .release = seq_release, 225 }; 226 227 static struct proc_dir_entry *llc_proc_dir; 228 229 int __init llc_proc_init(void) 230 { 231 int rc = -ENOMEM; 232 struct proc_dir_entry *p; 233 234 llc_proc_dir = proc_mkdir("llc", proc_net); 235 if (!llc_proc_dir) 236 goto out; 237 llc_proc_dir->owner = THIS_MODULE; 238 239 p = create_proc_entry("socket", S_IRUGO, llc_proc_dir); 240 if (!p) 241 goto out_socket; 242 243 p->proc_fops = &llc_seq_socket_fops; 244 245 p = create_proc_entry("core", S_IRUGO, llc_proc_dir); 246 if (!p) 247 goto out_core; 248 249 p->proc_fops = &llc_seq_core_fops; 250 251 rc = 0; 252 out: 253 return rc; 254 out_core: 255 remove_proc_entry("socket", llc_proc_dir); 256 out_socket: 257 remove_proc_entry("llc", proc_net); 258 goto out; 259 } 260 261 void llc_proc_exit(void) 262 { 263 remove_proc_entry("socket", llc_proc_dir); 264 remove_proc_entry("core", llc_proc_dir); 265 remove_proc_entry("llc", proc_net); 266 } 267