ia64/linux-2.6.18-xen.hg

view net/sctp/proc.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /* SCTP kernel reference Implementation
2 * Copyright (c) 2003 International Business Machines, Corp.
3 *
4 * This file is part of the SCTP kernel reference Implementation
5 *
6 * The SCTP reference implementation is free software;
7 * you can redistribute it and/or modify it under the terms of
8 * the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * The SCTP reference implementation is distributed in the hope that it
13 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14 * ************************
15 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with GNU CC; see the file COPYING. If not, write to
20 * the Free Software Foundation, 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
22 *
23 * Please send any bug reports or fixes you make to the
24 * email address(es):
25 * lksctp developers <lksctp-developers@lists.sourceforge.net>
26 *
27 * Or submit a bug report through the following website:
28 * http://www.sf.net/projects/lksctp
29 *
30 * Written or modified by:
31 * Sridhar Samudrala <sri@us.ibm.com>
32 *
33 * Any bugs reported given to us we will try to fix... any fixes shared will
34 * be incorporated into the next SCTP release.
35 */
37 #include <linux/types.h>
38 #include <linux/seq_file.h>
39 #include <linux/init.h>
40 #include <net/sctp/sctp.h>
42 static struct snmp_mib sctp_snmp_list[] = {
43 SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
44 SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
45 SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
46 SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
47 SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
48 SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
49 SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
50 SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
51 SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
52 SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
53 SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
54 SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
55 SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
56 SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
57 SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
58 SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
59 SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
60 SNMP_MIB_SENTINEL
61 };
63 /* Return the current value of a particular entry in the mib by adding its
64 * per cpu counters.
65 */
66 static unsigned long
67 fold_field(void *mib[], int nr)
68 {
69 unsigned long res = 0;
70 int i;
72 for_each_possible_cpu(i) {
73 res +=
74 *((unsigned long *) (((void *) per_cpu_ptr(mib[0], i)) +
75 sizeof (unsigned long) * nr));
76 res +=
77 *((unsigned long *) (((void *) per_cpu_ptr(mib[1], i)) +
78 sizeof (unsigned long) * nr));
79 }
80 return res;
81 }
83 /* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
84 static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
85 {
86 int i;
88 for (i = 0; sctp_snmp_list[i].name != NULL; i++)
89 seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
90 fold_field((void **)sctp_statistics,
91 sctp_snmp_list[i].entry));
93 return 0;
94 }
96 /* Initialize the seq file operations for 'snmp' object. */
97 static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
98 {
99 return single_open(file, sctp_snmp_seq_show, NULL);
100 }
102 static struct file_operations sctp_snmp_seq_fops = {
103 .owner = THIS_MODULE,
104 .open = sctp_snmp_seq_open,
105 .read = seq_read,
106 .llseek = seq_lseek,
107 .release = single_release,
108 };
110 /* Set up the proc fs entry for 'snmp' object. */
111 int __init sctp_snmp_proc_init(void)
112 {
113 struct proc_dir_entry *p;
115 p = create_proc_entry("snmp", S_IRUGO, proc_net_sctp);
116 if (!p)
117 return -ENOMEM;
119 p->proc_fops = &sctp_snmp_seq_fops;
121 return 0;
122 }
124 /* Cleanup the proc fs entry for 'snmp' object. */
125 void sctp_snmp_proc_exit(void)
126 {
127 remove_proc_entry("snmp", proc_net_sctp);
128 }
130 /* Dump local addresses of an association/endpoint. */
131 static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
132 {
133 struct list_head *pos;
134 struct sctp_association *asoc;
135 struct sctp_sockaddr_entry *laddr;
136 struct sctp_transport *peer;
137 union sctp_addr *addr, *primary = NULL;
138 struct sctp_af *af;
140 if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
141 asoc = sctp_assoc(epb);
142 peer = asoc->peer.primary_path;
143 primary = &peer->saddr;
144 }
146 list_for_each(pos, &epb->bind_addr.address_list) {
147 laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
148 addr = (union sctp_addr *)&laddr->a;
149 af = sctp_get_af_specific(addr->sa.sa_family);
150 if (primary && af->cmp_addr(addr, primary)) {
151 seq_printf(seq, "*");
152 }
153 af->seq_dump_addr(seq, addr);
154 }
155 }
157 /* Dump remote addresses of an association. */
158 static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
159 {
160 struct list_head *pos;
161 struct sctp_transport *transport;
162 union sctp_addr *addr, *primary;
163 struct sctp_af *af;
165 primary = &(assoc->peer.primary_addr);
166 list_for_each(pos, &assoc->peer.transport_addr_list) {
167 transport = list_entry(pos, struct sctp_transport, transports);
168 addr = (union sctp_addr *)&transport->ipaddr;
169 af = sctp_get_af_specific(addr->sa.sa_family);
170 if (af->cmp_addr(addr, primary)) {
171 seq_printf(seq, "*");
172 }
173 af->seq_dump_addr(seq, addr);
174 }
175 }
177 static void * sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
178 {
179 if (*pos >= sctp_ep_hashsize)
180 return NULL;
182 if (*pos < 0)
183 *pos = 0;
185 if (*pos == 0)
186 seq_printf(seq, " ENDPT SOCK STY SST HBKT LPORT UID INODE LADDRS\n");
188 return (void *)pos;
189 }
191 static void sctp_eps_seq_stop(struct seq_file *seq, void *v)
192 {
193 return;
194 }
197 static void * sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
198 {
199 if (++*pos >= sctp_ep_hashsize)
200 return NULL;
202 return pos;
203 }
206 /* Display sctp endpoints (/proc/net/sctp/eps). */
207 static int sctp_eps_seq_show(struct seq_file *seq, void *v)
208 {
209 struct sctp_hashbucket *head;
210 struct sctp_ep_common *epb;
211 struct sctp_endpoint *ep;
212 struct sock *sk;
213 int hash = *(loff_t *)v;
215 if (hash >= sctp_ep_hashsize)
216 return -ENOMEM;
218 head = &sctp_ep_hashtable[hash];
219 sctp_local_bh_disable();
220 read_lock(&head->lock);
221 for (epb = head->chain; epb; epb = epb->next) {
222 ep = sctp_ep(epb);
223 sk = epb->sk;
224 seq_printf(seq, "%8p %8p %-3d %-3d %-4d %-5d %5d %5lu ", ep, sk,
225 sctp_sk(sk)->type, sk->sk_state, hash,
226 epb->bind_addr.port,
227 sock_i_uid(sk), sock_i_ino(sk));
229 sctp_seq_dump_local_addrs(seq, epb);
230 seq_printf(seq, "\n");
231 }
232 read_unlock(&head->lock);
233 sctp_local_bh_enable();
235 return 0;
236 }
238 static struct seq_operations sctp_eps_ops = {
239 .start = sctp_eps_seq_start,
240 .next = sctp_eps_seq_next,
241 .stop = sctp_eps_seq_stop,
242 .show = sctp_eps_seq_show,
243 };
246 /* Initialize the seq file operations for 'eps' object. */
247 static int sctp_eps_seq_open(struct inode *inode, struct file *file)
248 {
249 return seq_open(file, &sctp_eps_ops);
250 }
252 static struct file_operations sctp_eps_seq_fops = {
253 .open = sctp_eps_seq_open,
254 .read = seq_read,
255 .llseek = seq_lseek,
256 .release = seq_release,
257 };
259 /* Set up the proc fs entry for 'eps' object. */
260 int __init sctp_eps_proc_init(void)
261 {
262 struct proc_dir_entry *p;
264 p = create_proc_entry("eps", S_IRUGO, proc_net_sctp);
265 if (!p)
266 return -ENOMEM;
268 p->proc_fops = &sctp_eps_seq_fops;
270 return 0;
271 }
273 /* Cleanup the proc fs entry for 'eps' object. */
274 void sctp_eps_proc_exit(void)
275 {
276 remove_proc_entry("eps", proc_net_sctp);
277 }
280 static void * sctp_assocs_seq_start(struct seq_file *seq, loff_t *pos)
281 {
282 if (*pos >= sctp_assoc_hashsize)
283 return NULL;
285 if (*pos < 0)
286 *pos = 0;
288 if (*pos == 0)
289 seq_printf(seq, " ASSOC SOCK STY SST ST HBKT ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
290 "RPORT LADDRS <-> RADDRS\n");
292 return (void *)pos;
293 }
295 static void sctp_assocs_seq_stop(struct seq_file *seq, void *v)
296 {
297 return;
298 }
301 static void * sctp_assocs_seq_next(struct seq_file *seq, void *v, loff_t *pos)
302 {
303 if (++*pos >= sctp_assoc_hashsize)
304 return NULL;
306 return pos;
307 }
309 /* Display sctp associations (/proc/net/sctp/assocs). */
310 static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
311 {
312 struct sctp_hashbucket *head;
313 struct sctp_ep_common *epb;
314 struct sctp_association *assoc;
315 struct sock *sk;
316 int hash = *(loff_t *)v;
318 if (hash >= sctp_assoc_hashsize)
319 return -ENOMEM;
321 head = &sctp_assoc_hashtable[hash];
322 sctp_local_bh_disable();
323 read_lock(&head->lock);
324 for (epb = head->chain; epb; epb = epb->next) {
325 assoc = sctp_assoc(epb);
326 sk = epb->sk;
327 seq_printf(seq,
328 "%8p %8p %-3d %-3d %-2d %-4d %4d %8d %8d %7d %5lu %-5d %5d ",
329 assoc, sk, sctp_sk(sk)->type, sk->sk_state,
330 assoc->state, hash, assoc->assoc_id,
331 (sk->sk_rcvbuf - assoc->rwnd),
332 assoc->sndbuf_used,
333 sock_i_uid(sk), sock_i_ino(sk),
334 epb->bind_addr.port,
335 assoc->peer.port);
337 seq_printf(seq, " ");
338 sctp_seq_dump_local_addrs(seq, epb);
339 seq_printf(seq, "<-> ");
340 sctp_seq_dump_remote_addrs(seq, assoc);
341 seq_printf(seq, "\n");
342 }
343 read_unlock(&head->lock);
344 sctp_local_bh_enable();
346 return 0;
347 }
349 static struct seq_operations sctp_assoc_ops = {
350 .start = sctp_assocs_seq_start,
351 .next = sctp_assocs_seq_next,
352 .stop = sctp_assocs_seq_stop,
353 .show = sctp_assocs_seq_show,
354 };
356 /* Initialize the seq file operations for 'assocs' object. */
357 static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
358 {
359 return seq_open(file, &sctp_assoc_ops);
360 }
362 static struct file_operations sctp_assocs_seq_fops = {
363 .open = sctp_assocs_seq_open,
364 .read = seq_read,
365 .llseek = seq_lseek,
366 .release = seq_release,
367 };
369 /* Set up the proc fs entry for 'assocs' object. */
370 int __init sctp_assocs_proc_init(void)
371 {
372 struct proc_dir_entry *p;
374 p = create_proc_entry("assocs", S_IRUGO, proc_net_sctp);
375 if (!p)
376 return -ENOMEM;
378 p->proc_fops = &sctp_assocs_seq_fops;
380 return 0;
381 }
383 /* Cleanup the proc fs entry for 'assocs' object. */
384 void sctp_assocs_proc_exit(void)
385 {
386 remove_proc_entry("assocs", proc_net_sctp);
387 }