Merge master.kernel.org:/home/acme/BK/llc-2.5

into nuts.ninka.net:/home/davem/src/BK/net-2.5

include/net/ipx.h

+#ifndef _NET_INET_IPX_H_
+#define _NET_INET_IPX_H_
 /*
  *	The following information is in its entirety obtained from:
  *
@@ -7,9 +9,6 @@
  *	Which is available from ftp.novell.com
  */
 
-#ifndef _NET_INET_IPX_H_
-#define _NET_INET_IPX_H_
-
 #include <linux/netdevice.h>
 #include <net/datalink.h>
 #include <linux/ipx.h>
@@ -25,8 +24,7 @@ struct ipx_address {
 
 #define IPX_MAX_PPROP_HOPS 8
 
-struct ipxhdr
-{
+struct ipxhdr {
 	__u16           ipx_checksum __attribute__ ((packed));
 #define IPX_NO_CHECKSUM	0xFFFF
 	__u16           ipx_pktsize __attribute__ ((packed));
@@ -110,4 +108,17 @@ struct ipx_opt {
 #define IPX_MIN_EPHEMERAL_SOCKET	0x4000
 #define IPX_MAX_EPHEMERAL_SOCKET	0x7fff
 
+extern struct ipx_route *ipx_routes;
+extern rwlock_t ipx_routes_lock;
+
+extern struct ipx_interface *ipx_interfaces;
+extern spinlock_t ipx_interfaces_lock;
+
+extern struct ipx_interface *ipx_primary_net;
+
+extern int ipx_proc_init(void);
+extern void ipx_proc_exit(void);
+
+extern const char *ipx_frame_name(unsigned short);
+extern const char *ipx_device_name(struct ipx_interface *intrfc);
 #endif /* def _NET_INET_IPX_H_ */

include/net/llc_main.h

@@ -57,10 +57,11 @@ extern struct llc_sap *llc_sap_alloc(void);
 extern void llc_sap_save(struct llc_sap *sap);
 extern void llc_free_sap(struct llc_sap *sap);
 extern struct llc_sap *llc_sap_find(u8 lsap);
-extern struct llc_station *llc_station_get(void);
 extern void llc_station_state_process(struct llc_station *station,
 				      struct sk_buff *skb);
 extern void llc_station_send_pdu(struct llc_station *station,
 				 struct sk_buff *skb);
 extern struct sk_buff *llc_alloc_frame(void);
+
+extern struct llc_station llc_main_station;
 #endif /* LLC_MAIN_H */

include/net/llc_proc.h

+#ifndef LLC_PROC_H
+#define LLC_PROC_H
+/*
+ * Copyright (c) 1997 by Procom Technology, Inc.
+ * 		 2002 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *
+ * This program can be redistributed or modified under the terms of the
+ * GNU General Public License as published by the Free Software Foundation.
+ * This program is distributed without any warranty or implied warranty
+ * of merchantability or fitness for a particular purpose.
+ *
+ * See the GNU General Public License for more details.
+ */
+
+extern int llc_proc_init(void);
+extern void llc_proc_exit(void);
+
+#endif /* LLC_PROC_H */

net/ipx/ChangeLog

+ Revision 0.21:	Uses the new generic socket option code.
+
+ Revision 0.22:	Gcc clean ups and drop out device registration. Use the
+ 		new multi-protocol edition of hard_header
+
+ Revision 0.23: IPX /proc by Mark Evans. Adding a route will
+ 		will overwrite any existing route to the same network.
+
+ Revision 0.24:	Supports new /proc with no 4K limit
+
+ Revision 0.25:	Add ephemeral sockets, passive local network
+ 		identification, support for local net 0 and
+ 		multiple datalinks <Greg Page>
+
+ Revision 0.26: Device drop kills IPX routes via it. (needed for module)
+
+ Revision 0.27: Autobind <Mark Evans>
+
+ Revision 0.28: Small fix for multiple local networks <Thomas Winder>
+
+ Revision 0.29: Assorted major errors removed <Mark Evans>
+ 		Small correction to promisc mode error fix <Alan Cox>
+ 		Asynchronous I/O support. Changed to use notifiers
+ 		and the newer packet_type stuff. Assorted major
+ 		fixes <Alejandro Liu>
+
+ Revision 0.30:	Moved to net/ipx/...	<Alan Cox>
+ 		Don't set address length on recvfrom that errors.
+ 		Incorrect verify_area.
+
+ Revision 0.31:	New sk_buffs. This still needs a lot of 
+ 		testing. <Alan Cox>
+
+ Revision 0.32: Using sock_alloc_send_skb, firewall hooks. <Alan Cox>
+ 		Supports sendmsg/recvmsg
+
+ Revision 0.33:	Internal network support, routing changes, uses a
+ 		protocol private area for ipx data.
+
+ Revision 0.34:	Module support. <Jim Freeman>
+
+ Revision 0.35: Checksum support. <Neil Turton>, hooked in by <Alan Cox>
+ 		Handles WIN95 discovery packets <Volker Lendecke>
+
+ Revision 0.36:	Internal bump up for 2.1
+
+ Revision 0.37:	Began adding POSIXisms.
+
+ Revision 0.38: Asynchronous socket stuff made current.
+
+ Revision 0.39: SPX interfaces
+
+ Revision 0.40: Tiny SIOCGSTAMP fix (chris@cybernet.co.nz)
+
+ Revision 0.41: 802.2TR removed (p.norton@computer.org)
+ 		Fixed connecting to primary net,
+ 		Automatic binding on send & receive,
+ 		Martijn van Oosterhout <kleptogimp@geocities.com>
+
+ Revision 042:  Multithreading - use spinlocks and refcounting to
+ 		protect some structures: ipx_interface sock list, list
+ 		of ipx interfaces, etc. 
+ 		Bugfixes - do refcounting on net_devices, check function
+ 		results, etc. Thanks to davem and freitag for
+ 		suggestions and guidance.
+ 		Arnaldo Carvalho de Melo <acme@conectiva.com.br>,
+ 		November, 2000
+
+ Revision 043:	Shared SKBs, don't mangle packets, some cleanups
+ 		Arnaldo Carvalho de Melo <acme@conectiva.com.br>,
+ 		December, 2000
+
+ Revision 044:	Call ipxitf_hold on NETDEV_UP - acme
+
+ Revision 045:	fix PPROP routing bug - acme
+
+ Revision 046:	Further fixes to PPROP, ipxitf_create_internal was
+ 		doing an unneeded MOD_INC_USE_COUNT, implement
+ 		sysctl for ipx_pprop_broacasting, fix the ipx sysctl
+ 		handling, making it dynamic, some cleanups, thanks to
+ 		Petr Vandrovec for review and good suggestions. (acme)
+
+ Revision 047:	Cleanups, CodingStyle changes, move the ncp connection
+ 		hack out of line - acme
+
+ Revision 048:	Use sk->protinfo to store the pointer to IPX private
+ 		area, remove af_ipx from sk->protinfo and move ipx_opt
+ 		to include/net/ipx.h, use IPX_SK like DecNET, etc - acme
+
+ Revision 049:	SPX support dropped, see comment in ipx_create - acme
+
+ Revision 050:	Use seq_file for proc stuff, moving it to ipx_proc.c - acme
+
+Other fixes:
+ 
+ Protect the module by a MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT pair. Also, now
+ usage count is managed this way:
+ -Count one if the auto_interface mode is on
+ -Count one per configured interface
+ 
+ Jacques Gelinas (jacques@solucorp.qc.ca)

net/ipx/Makefile

@@ -4,7 +4,7 @@
 
 obj-$(CONFIG_IPX) += ipx.o
 
-ipx-y			:= af_ipx.o
+ipx-y			:= af_ipx.o ipx_proc.o
 ipx-$(CONFIG_SYSCTL)	+= sysctl_net_ipx.o
 ipx-objs		:= $(ipx-y)
 

net/ipx/ipx_proc.c

+/*
+ *	IPX proc routines
+ *
+ * 	Copyright(C) Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 2002
+ */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+#include <linux/spinlock.h>
+#include <linux/seq_file.h>
+#include <linux/tcp.h>
+#include <net/ipx.h>
+
+#ifdef CONFIG_PROC_FS
+static __inline__ struct ipx_interface *ipx_get_interface_idx(loff_t pos)
+{
+	struct ipx_interface *i;
+
+	for (i = ipx_interfaces; pos && i; i = i->if_next)
+		--pos;
+
+	return i;
+}
+
+static void *ipx_seq_interface_start(struct seq_file *seq, loff_t *pos)
+{
+	loff_t l = *pos;
+
+	spin_lock_bh(&ipx_interfaces_lock);
+	return l ? ipx_get_interface_idx(--l) : (void *)1;
+}
+
+static void *ipx_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	struct ipx_interface *i;
+
+	++*pos;
+	if (v == (void *)1) {
+		i = NULL;
+		if (ipx_interfaces)
+			i = ipx_interfaces;
+		goto out;
+	}
+	i = v;
+	i = i->if_next;
+out:
+	return i;
+}
+
+static void ipx_seq_interface_stop(struct seq_file *seq, void *v)
+{
+	spin_unlock_bh(&ipx_interfaces_lock);
+}
+
+static int ipx_seq_interface_show(struct seq_file *seq, void *v)
+{
+	struct ipx_interface *i;
+
+	if (v == (void *)1) {
+		seq_puts(seq, "Network    Node_Address   Primary  Device     "
+			      "Frame_Type");
+#ifdef IPX_REFCNT_DEBUG
+		seq_puts(seq, "  refcnt");
+#endif
+		seq_puts(seq, "\n");
+		goto out;
+	}
+
+	i = v;
+	seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(i->if_netnum));
+	seq_printf(seq, "%02X%02X%02X%02X%02X%02X   ",
+			i->if_node[0], i->if_node[1], i->if_node[2],
+			i->if_node[3], i->if_node[4], i->if_node[5]);
+	seq_printf(seq, "%-9s", i == ipx_primary_net ? "Yes" : "No");
+	seq_printf(seq, "%-11s", ipx_device_name(i));
+	seq_printf(seq, "%-9s", ipx_frame_name(i->if_dlink_type));
+#ifdef IPX_REFCNT_DEBUG
+	seq_printf(seq, "%6d", atomic_read(&i->refcnt));
+#endif
+	seq_puts(seq, "\n");
+out:
+	return 0;
+}
+
+static __inline__ struct ipx_route *ipx_get_route_idx(loff_t pos)
+{
+	struct ipx_route *r;
+
+	for (r = ipx_routes; pos && r; r = r->ir_next)
+		--pos;
+
+	return r;
+}
+
+static void *ipx_seq_route_start(struct seq_file *seq, loff_t *pos)
+{
+	loff_t l = *pos;
+	read_lock_bh(&ipx_routes_lock);
+	return l ? ipx_get_route_idx(--l) : (void *)1;
+}
+
+static void *ipx_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	struct ipx_route *r;
+
+	++*pos;
+	if (v == (void *)1) {
+		r = NULL;
+		if (ipx_routes)
+			r = ipx_routes;
+		goto out;
+	}
+	r = v;
+	r = r->ir_next;
+out:
+	return r;
+}
+
+static void ipx_seq_route_stop(struct seq_file *seq, void *v)
+{
+	read_unlock_bh(&ipx_routes_lock);
+}
+
+static int ipx_seq_route_show(struct seq_file *seq, void *v)
+{
+	struct ipx_route *rt;
+
+	if (v == (void *)1) {
+		seq_puts(seq, "Network    Router_Net   Router_Node\n");
+		goto out;
+	}
+	rt = v;
+	seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(rt->ir_net));
+	if (rt->ir_routed)
+		seq_printf(seq, "%08lX     %02X%02X%02X%02X%02X%02X\n",
+			   (long unsigned int)ntohl(rt->ir_intrfc->if_netnum),
+			   rt->ir_router_node[0], rt->ir_router_node[1],
+			   rt->ir_router_node[2], rt->ir_router_node[3],
+			   rt->ir_router_node[4], rt->ir_router_node[5]);
+	else
+		seq_puts(seq, "Directly     Connected\n");
+out:
+	return 0;
+}
+
+static __inline__ struct sock *ipx_get_socket_idx(loff_t pos)
+{
+	struct sock *s = NULL;
+	struct ipx_interface *i;
+
+	for (i = ipx_interfaces; pos && i; i = i->if_next) {
+		spin_lock_bh(&i->if_sklist_lock);
+		for (s = i->if_sklist; pos && s; s = s->next)
+			--pos;
+		if (!pos) {
+			if (!s)
+				spin_unlock_bh(&i->if_sklist_lock);
+			break;
+		}
+		spin_unlock_bh(&i->if_sklist_lock);
+	}
+
+	return s;
+}
+
+static void *ipx_seq_socket_start(struct seq_file *seq, loff_t *pos)
+{
+	loff_t l = *pos;
+
+	spin_lock_bh(&ipx_interfaces_lock);
+	return l ? ipx_get_socket_idx(--l) : (void *)1;
+}
+
+static void *ipx_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	struct sock* sk;
+	struct ipx_interface *i;
+	struct ipx_opt *ipxs;
+
+	++*pos;
+	if (v == (void *)1) {
+		sk = NULL;
+		if (!ipx_interfaces)
+			goto out;
+		sk = ipx_interfaces->if_sklist;
+		if (sk)
+			spin_lock_bh(&ipx_interfaces->if_sklist_lock);
+		goto out;
+	}
+	sk = v;
+	if (sk->next) {
+		sk = sk->next;
+		goto out;
+	}
+	ipxs = ipx_sk(sk);
+	i = ipxs->intrfc;
+	spin_unlock_bh(&i->if_sklist_lock);
+	sk = NULL;
+	for (;;) {
+		if (!i->if_next)
+			break;
+		i = i->if_next;
+		spin_lock_bh(&i->if_sklist_lock);
+		if (i->if_sklist) {
+			sk = i->if_sklist;
+			break;
+		}
+		spin_unlock_bh(&i->if_sklist_lock);
+	}
+out:
+	return sk;
+}
+
+static int ipx_seq_socket_show(struct seq_file *seq, void *v)
+{
+	struct sock *s;
+	struct ipx_opt *ipxs;
+
+	if (v == (void *)1) {
+#ifdef CONFIG_IPX_INTERN
+		seq_puts(seq, "Local_Address               "
+			      "Remote_Address              Tx_Queue  "
+			      "Rx_Queue  State  Uid\n");
+#else
+		seq_puts(seq, "Local_Address  Remote_Address              "
+			      "Tx_Queue  Rx_Queue  State  Uid\n");
+#endif
+		goto out;
+	}
+
+	s = v;
+	ipxs = ipx_sk(s);
+#ifdef CONFIG_IPX_INTERN
+	seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
+		   (unsigned long)htonl(ipxs->intrfc->if_netnum),
+		   ipxs->node[0], ipxs->node[1], ipxs->node[2], ipxs->node[3],
+		   ipxs->node[4], ipxs->node[5], htons(ipxs->port));
+#else
+	seq_printf(seq, "%08lX:%04X  ", (unsigned long) htonl(ipxs->intrfc->if_netnum),
+		   htons(ipxs->port));
+#endif	/* CONFIG_IPX_INTERN */
+	if (s->state != TCP_ESTABLISHED)
+		seq_printf(seq, "%-28s", "Not_Connected");
+	else {
+		seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
+			   (unsigned long)htonl(ipxs->dest_addr.net),
+			   ipxs->dest_addr.node[0], ipxs->dest_addr.node[1],
+			   ipxs->dest_addr.node[2], ipxs->dest_addr.node[3],
+			   ipxs->dest_addr.node[4], ipxs->dest_addr.node[5],
+			   htons(ipxs->dest_addr.sock));
+	}
+
+	seq_printf(seq, "%08X  %08X  %02X     %03d\n",
+		   atomic_read(&s->wmem_alloc), atomic_read(&s->rmem_alloc),
+		   s->state, SOCK_INODE(s->socket)->i_uid);
+out:
+	return 0;
+}
+
+struct seq_operations ipx_seq_interface_ops = {
+	.start  = ipx_seq_interface_start,
+	.next   = ipx_seq_interface_next,
+	.stop   = ipx_seq_interface_stop,
+	.show   = ipx_seq_interface_show,
+};
+
+struct seq_operations ipx_seq_route_ops = {
+	.start  = ipx_seq_route_start,
+	.next   = ipx_seq_route_next,
+	.stop   = ipx_seq_route_stop,
+	.show   = ipx_seq_route_show,
+};
+
+struct seq_operations ipx_seq_socket_ops = {
+	.start  = ipx_seq_socket_start,
+	.next   = ipx_seq_socket_next,
+	.stop   = ipx_seq_interface_stop,
+	.show   = ipx_seq_socket_show,
+};
+
+static int ipx_seq_route_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &ipx_seq_route_ops);
+}
+
+static int ipx_seq_interface_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &ipx_seq_interface_ops);
+}
+
+static int ipx_seq_socket_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &ipx_seq_socket_ops);
+}
+
+static struct file_operations ipx_seq_interface_fops = {
+	.open           = ipx_seq_interface_open,
+	.read           = seq_read,
+	.llseek         = seq_lseek,
+	.release        = seq_release,
+};
+
+static struct file_operations ipx_seq_route_fops = {
+	.open           = ipx_seq_route_open,
+	.read           = seq_read,
+	.llseek         = seq_lseek,
+	.release        = seq_release,
+};
+
+static struct file_operations ipx_seq_socket_fops = {
+	.open           = ipx_seq_socket_open,
+	.read           = seq_read,
+	.llseek         = seq_lseek,
+	.release        = seq_release,
+};
+
+static int ipx_proc_perms(struct inode* inode, int op)
+{
+	return 0;
+}
+
+static struct inode_operations ipx_seq_inode = {
+	.permission     = ipx_proc_perms,
+};
+
+static struct proc_dir_entry *ipx_proc_dir;
+
+int __init ipx_proc_init(void)
+{
+	struct proc_dir_entry *p;
+	int rc = -ENOMEM;
+       
+	ipx_proc_dir = proc_mkdir("ipx", proc_net);
+
+	if (!ipx_proc_dir)
+		goto out;
+	p = create_proc_entry("interface", 0, ipx_proc_dir);
+	if (!p)
+		goto out_interface;
+
+	p->proc_fops = &ipx_seq_interface_fops;
+	p->proc_iops = &ipx_seq_inode;
+	p = create_proc_entry("route", 0, ipx_proc_dir);
+	if (!p)
+		goto out_route;
+
+	p->proc_fops = &ipx_seq_route_fops;
+	p->proc_iops = &ipx_seq_inode;
+	p = create_proc_entry("socket", 0, ipx_proc_dir);
+	if (!p)
+		goto out_socket;
+
+	p->proc_fops = &ipx_seq_socket_fops;
+	p->proc_iops = &ipx_seq_inode;
+
+	rc = 0;
+out:
+	return rc;
+out_socket:
+	remove_proc_entry("route", ipx_proc_dir);
+out_route:
+	remove_proc_entry("interface", ipx_proc_dir);
+out_interface:
+	remove_proc_entry("ipx", proc_net);
+	goto out;
+}
+
+void __exit ipx_proc_exit(void)
+{
+	remove_proc_entry("interface", ipx_proc_dir);
+	remove_proc_entry("route", ipx_proc_dir);
+	remove_proc_entry("socket", ipx_proc_dir);
+	remove_proc_entry("ipx", proc_net);
+}
+
+#else /* CONFIG_PROC_FS */
+
+int __init ipx_proc_init(void)
+{
+	return 0;
+}
+
+void __exit ipx_proc_exit(void)
+{
+}
+
+#endif /* CONFIG_PROC_FS */

net/llc/Makefile

@@ -16,7 +16,7 @@ obj-$(CONFIG_LLC) += llc.o
 
 llc-y := llc_if.o llc_c_ev.o llc_c_ac.o llc_mac.o llc_sap.o llc_s_st.o \
 	 llc_main.o llc_s_ac.o llc_conn.o llc_c_st.o llc_stat.o llc_actn.o \
-	 llc_s_ev.o llc_evnt.o llc_pdu.o
+	 llc_s_ev.o llc_evnt.o llc_pdu.o llc_proc.o
 llc-$(CONFIG_LLC_UI)	+= af_llc.o
 llc-objs	 	:= $(llc-y)
 

net/llc/af_llc.c

@@ -22,27 +22,12 @@
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/socket.h>
-#include <linux/sockios.h>
-#include <asm/uaccess.h>
-#include <asm/ioctls.h>
-#include <linux/proc_fs.h>
-#include <linux/in.h>
 #include <linux/tcp.h>
-#include <linux/netdevice.h>
-#include <linux/inetdevice.h>
-#include <linux/errno.h>
-#include <net/sock.h>
-#include <net/llc_if.h>
 #include <net/llc_sap.h>
 #include <net/llc_pdu.h>
 #include <net/llc_conn.h>
 #include <net/llc_mac.h>
 #include <net/llc_main.h>
-#include <linux/llc.h>
-#include <linux/if_arp.h>
 #include <linux/rtnetlink.h>
 #include <linux/init.h>
 
@@ -1027,94 +1012,6 @@ static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
 	return rc;
 }
 
-#ifdef CONFIG_PROC_FS
-#define MAC_FORMATTED_SIZE 17
-static void llc_ui_format_mac(char *bf, unsigned char *mac)
-{
-	sprintf(bf, "%02X:%02X:%02X:%02X:%02X:%02X",
-		mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-}
-
-/**
- *	llc_ui_get_info - return info to procfs
- *	@buffer: where to put the formatted output
- *	@start: starting from
- *	@offset: offset into buffer.
- *	@length: size of the buffer
- *
- *	Get the output of the local llc ui socket list to the caller.
- *	Returns the length of data wrote to buffer.
- */
-static int llc_ui_get_info(char *buffer, char **start, off_t offset, int length)
-{
-	off_t pos = 0;
-	off_t begin = 0;
-	struct llc_sap *sap;
-	struct sock *sk;
-	struct list_head *sap_entry;
-	struct llc_station *station = llc_station_get();
-	int len = sprintf(buffer, "SKt Mc local_mac_sap        "
-				  "remote_mac_sap       tx_queue rx_queue st uid "
-				  "link\n");
-
-	/* Output the LLC socket data for the /proc filesystem */
-	read_lock_bh(&station->sap_list.lock);
-	list_for_each(sap_entry, &station->sap_list.list) {
-		sap = list_entry(sap_entry, struct llc_sap, node);
-
-		read_lock_bh(&sap->sk_list.lock);
-		for (sk = sap->sk_list.list; sk; sk = sk->next) {
-			struct llc_opt *llc = llc_sk(sk);
-
-			len += sprintf(buffer + len, "%2X  %2X ", sk->type,
-				       !llc_mac_null(llc->addr.sllc_mmac));
-			if (llc->dev && llc_mac_null(llc->addr.sllc_mmac))
-				llc_ui_format_mac(buffer + len,
-						  llc->dev->dev_addr);
-			else {
-				if (!llc_mac_null(llc->addr.sllc_mmac))
-					llc_ui_format_mac(buffer + len,
-							  llc->addr.sllc_mmac);
-				else
-					sprintf(buffer + len,
-						"00:00:00:00:00:00");
-			}
-			len += MAC_FORMATTED_SIZE;
-			len += sprintf(buffer + len, "@%02X ", sap->laddr.lsap);
-			llc_ui_format_mac(buffer + len, llc->addr.sllc_dmac);
-			len += MAC_FORMATTED_SIZE;
-			len += sprintf(buffer + len,
-					"@%02X %8d %8d %2d %3d ",
-					llc->addr.sllc_dsap,
-					atomic_read(&sk->wmem_alloc),
-					atomic_read(&sk->rmem_alloc),
-					sk->state,
-					sk->socket ?
-					  SOCK_INODE(sk->socket)->i_uid : -1);
-			len += sprintf(buffer + len, "%4d\n", llc->link);
-			/* Are we still dumping unwanted data then discard the record */
-			pos = begin + len;
-
-			if (pos < offset) {
-				len = 0; /* Keep dumping into the buffer start */
-				begin = pos;
-			}
-			if (pos > offset + length) /* We have dumped enough */
-				break;
-		}
-		read_unlock_bh(&sap->sk_list.lock);
-	}
-	read_unlock_bh(&station->sap_list.lock);
-
-	/* The data in question runs from begin to begin + len */
-	*start = buffer + offset - begin; /* Start of wanted data */
-	len -= offset - begin; /* Remove unwanted header data from length */
-	if (len > length)
-		len = length; /* Remove unwanted tail data from length */
-	return len;
-}
-#endif /* CONFIG_PROC_FS */
-
 static struct net_proto_family llc_ui_family_ops = {
 	.family = PF_LLC,
 	.create = llc_ui_create,
@@ -1147,13 +1044,11 @@ int __init llc_ui_init(void)
 {
 	llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
 	sock_register(&llc_ui_family_ops);
-	proc_net_create("llc", 0, llc_ui_get_info);
 	printk(llc_ui_banner);
 	return 0;
 }
 
 void __exit llc_ui_exit(void)
 {
-	proc_net_remove("llc");
 	sock_unregister(PF_LLC);
 }

net/llc/llc_if.c

@@ -56,7 +56,7 @@ struct llc_sap *llc_sap_open(u8 lsap, int (*func)(struct sk_buff *skb,
 	/* allocated a SAP; initialize it and clear out its memory pool */
 	sap->laddr.lsap = lsap;
 	sap->rcv_func	= func;
-	sap->station	= llc_station_get();
+	sap->station	= &llc_main_station;
 	/* initialized SAP; add it to list of SAPs this station manages */
 	llc_sap_save(sap);
 out:

net/llc/llc_mac.c

@@ -197,12 +197,11 @@ static void fix_up_incoming_skb(struct sk_buff *skb)
  */
 static void llc_station_rcv(struct sk_buff *skb)
 {
-	struct llc_station *station = llc_station_get();
 	struct llc_station_state_ev *ev = llc_station_ev(skb);
 
 	ev->type   = LLC_STATION_EV_TYPE_PDU;
 	ev->reason = 0;
-	llc_station_state_process(station, skb);
+	llc_station_state_process(&llc_main_station, skb);
 }
 
 

net/llc/llc_main.c

@@ -3,7 +3,7 @@
  * 	and connections of the LLC.
  *
  * Copyright (c) 1997 by Procom Technology, Inc.
- * 		 2001 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ * 		 2001, 2002 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  *
  * This program can be redistributed or modified under the terms of the
  * GNU General Public License as published by the Free Software Foundation.
@@ -12,14 +12,9 @@
  *
  * See the GNU General Public License for more details.
  */
-#include <linux/kernel.h>
-#include <linux/netdevice.h>
-#include <net/sock.h>
-#include <linux/sched.h>
+#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/proc_fs.h>
-#include <net/llc_if.h>
 #include <net/llc_sap.h>
 #include <net/llc_conn.h>
 #include <net/llc_main.h>
@@ -33,7 +28,7 @@
 #include <net/llc_s_ev.h>
 #include <net/llc_s_st.h>
 #include <net/llc_mac.h>
-#include <linux/llc.h>
+#include <net/llc_proc.h>
 
 /* static function prototypes */
 static void llc_station_service_events(struct llc_station *station);
@@ -50,7 +45,7 @@ static struct llc_station_state_trans *
 						    struct sk_buff *skb);
 static int llc_rtn_all_conns(struct llc_sap *sap);
 
-static struct llc_station llc_main_station;	/* only one of its kind */
+struct llc_station llc_main_station;	/* only one of its kind */
 
 #undef LLC_REFCNT_DEBUG
 #ifdef LLC_REFCNT_DEBUG
@@ -339,16 +334,6 @@ static int llc_rtn_all_conns(struct llc_sap *sap)
 	return rc;
 }
 
-/**
- *	llc_station_get - get addr of global station.
- *
- *	Returns address of a place to copy the global station to it.
- */
-struct llc_station *llc_station_get(void)
-{
-	return &llc_main_station;
-}
-
 /**
  *	llc_station_state_process: queue event and try to process queue.
  *	@station: Address of the station
@@ -537,80 +522,6 @@ struct sk_buff *llc_alloc_frame(void)
 	return skb;
 }
 
-static char *llc_conn_state_names[] = {
-	[LLC_CONN_STATE_ADM] =        "adm", 
-	[LLC_CONN_STATE_SETUP] =      "setup", 
-	[LLC_CONN_STATE_NORMAL] =     "normal",
-	[LLC_CONN_STATE_BUSY] =       "busy", 
-	[LLC_CONN_STATE_REJ] =        "rej", 
-	[LLC_CONN_STATE_AWAIT] =      "await", 
-	[LLC_CONN_STATE_AWAIT_BUSY] = "await_busy",
-	[LLC_CONN_STATE_AWAIT_REJ] =  "await_rej",
-	[LLC_CONN_STATE_D_CONN]	=     "d_conn",
-	[LLC_CONN_STATE_RESET] =      "reset", 
-	[LLC_CONN_STATE_ERROR] =      "error", 
-	[LLC_CONN_STATE_TEMP] =       "temp", 
-};
-
-static int llc_proc_get_info(char *bf, char **start, off_t offset, int length)
-{
-	struct list_head *sap_entry;
-	struct sock *sk;
-	off_t begin = 0, pos = 0;
-	int len = 0;
-
-	read_lock_bh(&llc_main_station.sap_list.lock);
-	list_for_each(sap_entry, &llc_main_station.sap_list.list) {
-		struct llc_sap *sap = list_entry(sap_entry, struct llc_sap,
-						 node);
-
-		len += sprintf(bf + len, "lsap=%02X\n", sap->laddr.lsap);
-		read_lock_bh(&sap->sk_list.lock);
-		if (!sap->sk_list.list) {
-			len += sprintf(bf + len, "no connections\n");
-			goto unlock;
-		}
-		len += sprintf(bf + len, "connection list:\n"
-					 "dsap state      retr txw rxw "
-					 "pf ff sf df rs cs "
-					 "tack tpfc trs tbs blog busr\n");
-		for (sk = sap->sk_list.list; sk; sk = sk->next) {
-			struct llc_opt *llc = llc_sk(sk);
-
-			len += sprintf(bf + len, " %02X  %-10s %3d  %3d %3d "
-						 "%2d %2d %2d "
-						 "%2d %2d %2d "
-						 "%4d %4d %3d %3d %4d %4d\n",
-				       llc->daddr.lsap,
-				       llc_conn_state_names[llc->state],
-				       llc->retry_count, llc->k, llc->rw,
-				       llc->p_flag, llc->f_flag, llc->s_flag,
-				       llc->data_flag, llc->remote_busy_flag,
-				       llc->cause_flag,
-				       timer_pending(&llc->ack_timer.timer),
-				       timer_pending(&llc->pf_cycle_timer.timer),
-				       timer_pending(&llc->rej_sent_timer.timer),
-				       timer_pending(&llc->busy_state_timer.timer),
-				       !!sk->backlog.tail, sk->lock.users);
-		}
-unlock:	
-		read_unlock_bh(&sap->sk_list.lock);
-		pos = begin + len;
-		if (pos < offset) {
-			len = 0; /* Keep dumping into the buffer start */
-			begin = pos;
-		}
-		if (pos > offset + length) /* We have dumped enough */
-			break;
-	}
-	read_unlock_bh(&llc_main_station.sap_list.lock);
-
-	/* The data in question runs from begin to begin + len */
-	*start = bf + (offset - begin); /* Start of wanted data */
-	len -= (offset - begin); /* Remove unwanted header data from length */
-	return len;
-}
-
 static struct packet_type llc_packet_type = {
 	.type = __constant_htons(ETH_P_802_2),
 	.func = llc_rcv,
@@ -644,9 +555,11 @@ static int __init llc_init(void)
 	llc_main_station.ack_timer.data     = (unsigned long)&llc_main_station;
 	llc_main_station.ack_timer.function = llc_station_ack_tmr_cb;
 
+	if (llc_proc_init())
+		goto err;
 	skb = alloc_skb(0, GFP_ATOMIC);
 	if (!skb)
-		goto err;
+		goto err_skb;
 	llc_build_offset_table();
 	ev = llc_station_ev(skb);
 	memset(ev, 0, sizeof(*ev));
@@ -661,12 +574,13 @@ static int __init llc_init(void)
 	ev->type	= LLC_STATION_EV_TYPE_SIMPLE;
 	ev->prim_type	= LLC_STATION_EV_ENABLE_WITHOUT_DUP_ADDR_CHECK;
 	rc = llc_station_next_state(&llc_main_station, skb);
-	proc_net_create("802.2", 0, llc_proc_get_info);
 	llc_ui_init();
 	dev_add_pack(&llc_packet_type);
 	dev_add_pack(&llc_tr_packet_type);
 out:
 	return rc;
+err_skb:
+	llc_proc_exit();
 err:
 	printk(llc_error_msg);
 	rc = 1;
@@ -676,9 +590,9 @@ static int __init llc_init(void)
 static void __exit llc_exit(void)
 {
 	llc_ui_exit();
+	llc_proc_exit();
 	dev_remove_pack(&llc_packet_type);
 	dev_remove_pack(&llc_tr_packet_type);
-	proc_net_remove("802.2");
 }
 
 module_init(llc_init);

net/llc/llc_proc.c

+/*
+ * proc_llc.c - proc interface for LLC
+ *
+ * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
+ *		 2002 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *
+ * This program can be redistributed or modified under the terms of the
+ * GNU General Public License as published by the Free Software Foundation.
+ * This program is distributed without any warranty or implied warranty
+ * of merchantability or fitness for a particular purpose.
+ *
+ * See the GNU General Public License for more details.
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/seq_file.h>
+#include <net/sock.h>
+#include <net/llc_c_ac.h>
+#include <net/llc_c_ev.h>
+#include <net/llc_c_st.h>
+#include <net/llc_conn.h>
+#include <net/llc_mac.h>
+#include <net/llc_main.h>
+#include <net/llc_sap.h>
+
+#ifdef CONFIG_PROC_FS
+static void llc_ui_format_mac(struct seq_file *seq, unsigned char *mac)
+{
+	seq_printf(seq, "%02X:%02X:%02X:%02X:%02X:%02X",
+		   mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+}
+
+static __inline__ struct sock *llc_get_sk_idx(loff_t pos)
+{
+	struct list_head *sap_entry;
+	struct llc_sap *sap;
+	struct sock *sk = NULL;
+
+	list_for_each(sap_entry, &llc_main_station.sap_list.list) {
+		sap = list_entry(sap_entry, struct llc_sap, node);
+
+		read_lock_bh(&sap->sk_list.lock);
+		for (sk = sap->sk_list.list; pos && sk; sk = sk->next)
+			--pos;
+		if (!pos) {
+			if (!sk)
+				read_unlock_bh(&sap->sk_list.lock);
+			break;
+		}
+		read_unlock_bh(&sap->sk_list.lock);
+	}
+	return sk;
+}
+
+static void *llc_seq_start(struct seq_file *seq, loff_t *pos)
+{
+	loff_t l = *pos;
+
+	read_lock_bh(&llc_main_station.sap_list.lock);
+	return l ? llc_get_sk_idx(--l) : (void *)1;
+}
+
+static void *llc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	struct sock* sk;
+	struct llc_opt *llc;
+	struct llc_sap *sap;
+
+	++*pos;
+	if (v == (void *)1) {
+		if (list_empty(&llc_main_station.sap_list.list)) {
+			sk = NULL;
+			goto out;
+		}
+		sap = list_entry(llc_main_station.sap_list.list.next,
+				 struct llc_sap, node);
+
+		read_lock_bh(&sap->sk_list.lock);
+		sk = sap->sk_list.list;
+		goto out;
+	}
+	sk = v;
+	if (sk->next) {
+		sk = sk->next;
+		goto out;
+	}
+	llc = llc_sk(sk);
+	sap = llc->sap;
+	read_unlock_bh(&sap->sk_list.lock);
+	sk = NULL;
+	for (;;) {
+		if (sap->node.next == &llc_main_station.sap_list.list)
+			break;
+		sap = list_entry(sap->node.next, struct llc_sap, node);
+		read_lock_bh(&sap->sk_list.lock);
+		if (sap->sk_list.list) {
+			sk = sap->sk_list.list;
+			break;
+		}
+		read_unlock_bh(&sap->sk_list.lock);
+	}
+out:
+	return sk;
+}
+
+static void llc_seq_stop(struct seq_file *seq, void *v)
+{
+	read_unlock_bh(&llc_main_station.sap_list.lock);
+}
+
+static int llc_seq_socket_show(struct seq_file *seq, void *v)
+{
+	struct sock* sk;
+	struct llc_opt *llc;
+
+	if (v == (void *)1) {
+		seq_puts(seq, "SKt Mc local_mac_sap        remote_mac_sap   "
+			      "    tx_queue rx_queue st uid link\n");
+		goto out;
+	}
+	sk = v;
+	llc = llc_sk(sk);
+
+	seq_printf(seq, "%2X  %2X ", sk->type,
+		   !llc_mac_null(llc->addr.sllc_mmac));
+
+	if (llc->dev && llc_mac_null(llc->addr.sllc_mmac))
+		llc_ui_format_mac(seq, llc->dev->dev_addr);
+	else if (!llc_mac_null(llc->addr.sllc_mmac))
+		llc_ui_format_mac(seq, llc->addr.sllc_mmac);
+	else
+		seq_printf(seq, "00:00:00:00:00:00");
+	seq_printf(seq, "@%02X ", llc->sap->laddr.lsap);
+	llc_ui_format_mac(seq, llc->addr.sllc_dmac);
+	seq_printf(seq, "@%02X %8d %8d %2d %3d %4d\n", llc->addr.sllc_dsap,
+		   atomic_read(&sk->wmem_alloc), atomic_read(&sk->rmem_alloc),
+		   sk->state, sk->socket ? SOCK_INODE(sk->socket)->i_uid : -1,
+		   llc->link);
+out:
+	return 0;
+}
+
+static char *llc_conn_state_names[] = {
+	[LLC_CONN_STATE_ADM] =        "adm", 
+	[LLC_CONN_STATE_SETUP] =      "setup", 
+	[LLC_CONN_STATE_NORMAL] =     "normal",
+	[LLC_CONN_STATE_BUSY] =       "busy", 
+	[LLC_CONN_STATE_REJ] =        "rej", 
+	[LLC_CONN_STATE_AWAIT] =      "await", 
+	[LLC_CONN_STATE_AWAIT_BUSY] = "await_busy",
+	[LLC_CONN_STATE_AWAIT_REJ] =  "await_rej",
+	[LLC_CONN_STATE_D_CONN]	=     "d_conn",
+	[LLC_CONN_STATE_RESET] =      "reset", 
+	[LLC_CONN_STATE_ERROR] =      "error", 
+	[LLC_CONN_STATE_TEMP] =       "temp", 
+};
+
+static int llc_seq_core_show(struct seq_file *seq, void *v)
+{
+	struct sock* sk;
+	struct llc_opt *llc;
+
+	if (v == (void *)1) {
+		seq_puts(seq, "Connection list:\n"
+			      "dsap state      retr txw rxw pf ff sf df rs cs "
+			      "tack tpfc trs tbs blog busr\n");
+		goto out;
+	}
+	sk = v;
+	llc = llc_sk(sk);
+
+	seq_printf(seq, " %02X  %-10s %3d  %3d %3d %2d %2d %2d %2d %2d %2d "
+			"%4d %4d %3d %3d %4d %4d\n",
+		   llc->daddr.lsap, llc_conn_state_names[llc->state],
+		   llc->retry_count, llc->k, llc->rw, llc->p_flag, llc->f_flag,
+		   llc->s_flag, llc->data_flag, llc->remote_busy_flag,
+		   llc->cause_flag, timer_pending(&llc->ack_timer.timer),
+		   timer_pending(&llc->pf_cycle_timer.timer),
+		   timer_pending(&llc->rej_sent_timer.timer),
+		   timer_pending(&llc->busy_state_timer.timer),
+		   !!sk->backlog.tail, sk->lock.users);
+out:
+	return 0;
+}
+
+struct seq_operations llc_seq_socket_ops = {
+	.start  = llc_seq_start,
+	.next   = llc_seq_next,
+	.stop   = llc_seq_stop,
+	.show   = llc_seq_socket_show,
+};
+
+struct seq_operations llc_seq_core_ops = {
+	.start  = llc_seq_start,
+	.next   = llc_seq_next,
+	.stop   = llc_seq_stop,
+	.show   = llc_seq_core_show,
+};
+
+static int llc_seq_socket_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &llc_seq_socket_ops);
+}
+
+static int llc_seq_core_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &llc_seq_core_ops);
+}
+
+static int llc_proc_perms(struct inode* inode, int op)
+{
+	return 0;
+}
+
+static struct file_operations llc_seq_socket_fops = {
+	.open		= llc_seq_socket_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= seq_release,
+};
+
+static struct file_operations llc_seq_core_fops = {
+	.open		= llc_seq_core_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= seq_release,
+};
+
+static struct inode_operations llc_seq_inode = {
+	.permission	= llc_proc_perms,
+};
+
+static struct proc_dir_entry *llc_proc_dir;
+
+int __init llc_proc_init(void)
+{
+	int rc = -ENOMEM;
+	struct proc_dir_entry *p;
+
+	llc_proc_dir = proc_mkdir("llc", proc_net);
+	if (!llc_proc_dir)
+		goto out;
+
+	p = create_proc_entry("socket", 0, llc_proc_dir);
+	if (!p)
+		goto out_socket;
+
+	p->proc_fops = &llc_seq_socket_fops;
+	p->proc_iops = &llc_seq_inode;
+
+	p = create_proc_entry("core", 0, llc_proc_dir);
+	if (!p)
+		goto out_core;
+
+	p->proc_fops = &llc_seq_core_fops;
+	p->proc_iops = &llc_seq_inode;
+
+	rc = 0;
+out:
+	return rc;
+out_core:
+	remove_proc_entry("socket", llc_proc_dir);
+out_socket:
+	remove_proc_entry("llc", proc_net);
+	goto out;
+}
+
+void __exit llc_proc_exit(void)
+{
+	remove_proc_entry("socket", llc_proc_dir);
+	remove_proc_entry("core", llc_proc_dir);
+	remove_proc_entry("llc", proc_net);
+}
+#else /* CONFIG_PROC_FS */
+int __init llc_proc_init(void)
+{
+	return 0;
+}
+
+void __exit llc_proc_exit(void)
+{
+}
+#endif /* CONFIG_PROC_FS */