[SSI] openssi/kernel/net/unix garbage.c, NONE, 1.3.2.2 af_unix.c, 1.22, 1.23

Update of /cvsroot/ssic-linux/openssi/kernel/net/unix
In directory fdv4jf1.ch3.sourceforge.com:/tmp/cvs-serv16224/kernel/net/unix

Modified Files:
      Tag: OPENSSI-FC
	af_unix.c 
Added Files:
      Tag: OPENSSI-FC
	garbage.c 
Log Message:
Bug fixes and enhancements. See ChangeLog.


--- NEW FILE: garbage.c ---
/*
 * NET3:	Garbage Collector For AF_UNIX sockets
 *
 * Garbage Collector:
 *	Copyright (C) Barak A. Pearlmutter.
 *	Released under the GPL version 2 or later.
 *
 * Chopped about by Alan Cox 22/3/96 to make it fit the AF_UNIX socket problem.
 * If it doesn't work blame me, it worked when Barak sent it.
 *
 * Assumptions:
 *
 *  - object w/ a bit
 *  - free list
 *
 * Current optimizations:
 *
 *  - explicit stack instead of recursion
 *  - tail recurse on first born instead of immediate push/pop
 *  - we gather the stuff that should not be killed into tree
 *    and stack is just a path from root to the current pointer.
 *
 *  Future optimizations:
 *
 *  - don't just push entire root set; process in place
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 *  Fixes:
 *	Alan Cox	07 Sept	1997	Vmalloc internal stack as needed.
 *					Cope with changing max_files.
 *	Al Viro		11 Oct 1998
 *		Graph may have cycles. That is, we can send the descriptor
 *		of foo to bar and vice versa. Current code chokes on that.
 *		Fix: move SCM_RIGHTS ones into the separate list and then
 *		skb_free() them all instead of doing explicit fput's.
 *		Another problem: since fput() may block somebody may
 *		create a new unix_socket when we are in the middle of sweep
 *		phase. Fix: revert the logic wrt MARKED. Mark everything
 *		upon the beginning and unmark non-junk ones.
 *
 *		[12 Oct 1998] AAARGH! New code purges all SCM_RIGHTS
 *		sent to connect()'ed but still not accept()'ed sockets.
 *		Fixed. Old code had slightly different problem here:
 *		extra fput() in situation when we passed the descriptor via
 *		such socket and closed it (descriptor). That would happen on
 *		each unix_gc() until the accept(). Since the struct file in
 *		question would go to the free list and might be reused...
 *		That might be the reason of random oopses on filp_close()
 *		in unrelated processes.
 *
 *	AV		28 Feb 1999
 *		Kill the explicit allocation of stack. Now we keep the tree
 *		with root in dummy + pointer (gc_current) to one of the nodes.
 *		Stack is represented as path from gc_current to dummy. Unmark
 *		now means "add to tree". Push == "make it a son of gc_current".
 *		Pop == "move gc_current to parent". We keep only pointers to
 *		parents (->gc_tree).
 *	AV		1 Mar 1999
 *		Damn. Added missing check for ->dead in listen queues scanning.
 *
 */
 
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/un.h>
#include <linux/net.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/file.h>
#include <linux/proc_fs.h>
#include <linux/tcp.h>

#include <net/sock.h>
#include <net/af_unix.h>
#include <net/scm.h>

/* Internal data structures and random procedures: */

#define GC_HEAD		((struct sock *)(-1))
#define GC_ORPHAN	((struct sock *)(-3))

static struct sock *gc_current = GC_HEAD; /* stack of objects to mark */

atomic_t unix_tot_inflight = ATOMIC_INIT(0);


static struct sock *unix_get_socket(struct file *filp)
{
	struct sock *u_sock = NULL;
	struct inode *inode = filp->f_dentry->d_inode;

	/*
	 *	Socket ?
	 */
	if (inode->i_sock) {
		struct socket * sock = SOCKET_I(inode);
		struct sock * s = sock->sk;

		/*
		 *	PF_UNIX ?
		 */
		if (s && sock->ops && sock->ops->family == PF_UNIX)
			u_sock = s;
	}
	return u_sock;
}

/*
 *	Keep the number of times in flight count for the file
 *	descriptor if it is for an AF_UNIX socket.
 */
 
void unix_inflight(struct file *fp)
{
	struct sock *s = unix_get_socket(fp);
	if(s) {
		atomic_inc(&unix_sk(s)->inflight);
		atomic_inc(&unix_tot_inflight);
	}
}

void unix_notinflight(struct file *fp)
{
	struct sock *s = unix_get_socket(fp);
	if(s) {
		atomic_dec(&unix_sk(s)->inflight);
		atomic_dec(&unix_tot_inflight);
	}
}


/*
 *	Garbage Collector Support Functions
 */

static inline struct sock *pop_stack(void)
{
	struct sock *p = gc_current;
	gc_current = unix_sk(p)->gc_tree;
	return p;
}

static inline int empty_stack(void)
{
	return gc_current == GC_HEAD;
}

static void maybe_unmark_and_push(struct sock *x)
{
	struct unix_sock *u = unix_sk(x);

	if (u->gc_tree != GC_ORPHAN)
		return;
	sock_hold(x);
	u->gc_tree = gc_current;
	gc_current = x;
}


/* The external entry point: unix_gc() */

void unix_gc(void)
{
	static DECLARE_MUTEX(unix_gc_sem);
	int i;
	struct sock *s;
	struct sk_buff_head hitlist;
	struct sk_buff *skb;

	/*
	 *	Avoid a recursive GC.
	 */

	if (down_trylock(&unix_gc_sem))
		return;

#ifdef CONFIG_SSI
	down_read(&unix_table_lock);
#else
	read_lock(&unix_table_lock);
#endif

	forall_unix_sockets(i, s)
	{
		unix_sk(s)->gc_tree = GC_ORPHAN;
	}
	/*
	 *	Everything is now marked 
	 */

	/* Invariant to be maintained:
		- everything unmarked is either:
		-- (a) on the stack, or
		-- (b) has all of its children unmarked
		- everything on the stack is always unmarked
		- nothing is ever pushed onto the stack twice, because:
		-- nothing previously unmarked is ever pushed on the stack
	 */

	/*
	 *	Push root set
	 */

	forall_unix_sockets(i, s)
	{
		int open_count = 0;

		/*
		 *	If all instances of the descriptor are not
		 *	in flight we are in use.
		 *
		 *	Special case: when socket s is embrion, it may be
		 *	hashed but still not in queue of listening socket.
		 *	In this case (see unix_create1()) we set artificial
		 *	negative inflight counter to close race window.
		 *	It is trick of course and dirty one.
		 */
		if (s->sk_socket && s->sk_socket->file)
			open_count = file_count(s->sk_socket->file);
		if (open_count > atomic_read(&unix_sk(s)->inflight))
			maybe_unmark_and_push(s);
	}

	/*
	 *	Mark phase 
	 */

	while (!empty_stack())
	{
		struct sock *x = pop_stack();
		struct sock *sk;

		spin_lock(&x->sk_receive_queue.lock);
		skb = skb_peek(&x->sk_receive_queue);
		
		/*
		 *	Loop through all but first born 
		 */
		
		while (skb && skb != (struct sk_buff *)&x->sk_receive_queue) {
			/*
			 *	Do we have file descriptors ?
			 */
			if(UNIXCB(skb).fp)
			{
				/*
				 *	Process the descriptors of this socket
				 */
				int nfd=UNIXCB(skb).fp->count;
				struct file **fp = UNIXCB(skb).fp->fp;
				while(nfd--)
				{
					/*
					 *	Get the socket the fd matches if
					 *	it indeed does so
					 */
					if((sk=unix_get_socket(*fp++))!=NULL)
					{
						maybe_unmark_and_push(sk);
					}
				}
			}
			/* We have to scan not-yet-accepted ones too */
			if (x->sk_state == TCP_LISTEN)
				maybe_unmark_and_push(skb->sk);
			skb=skb->next;
		}
		spin_unlock(&x->sk_receive_queue.lock);
		sock_put(x);
	}

	skb_queue_head_init(&hitlist);

	forall_unix_sockets(i, s)
	{
		struct unix_sock *u = unix_sk(s);

		if (u->gc_tree == GC_ORPHAN) {
			struct sk_buff *nextsk;

			spin_lock(&s->sk_receive_queue.lock);
			skb = skb_peek(&s->sk_receive_queue);
			while (skb &&
			       skb != (struct sk_buff *)&s->sk_receive_queue) {
				nextsk=skb->next;
				/*
				 *	Do we have file descriptors ?
				 */
				if(UNIXCB(skb).fp)
				{
					__skb_unlink(skb, skb->list);
					__skb_queue_tail(&hitlist,skb);
				}
				skb=nextsk;
			}
			spin_unlock(&s->sk_receive_queue.lock);
		}
		u->gc_tree = GC_ORPHAN;
	}
#ifdef CONFIG_SSI
	up_read(&unix_table_lock);
#else
	read_unlock(&unix_table_lock);
#endif

	/*
	 *	Here we are. Hitlist is filled. Die.
	 */

	__skb_queue_purge(&hitlist);
	up(&unix_gc_sem);
}

Index: af_unix.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/net/unix/af_unix.c,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -d -r1.22 -r1.23
--- af_unix.c	3 Feb 2009 06:18:14 -0000	1.22
+++ af_unix.c	27 Oct 2009 03:18:30 -0000	1.23
@@ -128,7 +128,16 @@
 #endif
 
 struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1];
+#ifdef CONFIG_SSI
+/* SSI: unix_table_lock cannot spin due to might sleep in path:
+ *			(seq_read)
+ * unix_table_lock	(seq_read, ->start)
+ * unix_state_rlock	(seq_read, ->show)	[might_sleep]
+ */
+DECLARE_RWSEM(unix_table_lock);
+#else
 DEFINE_RWLOCK(unix_table_lock);
+#endif
 static atomic_t unix_nr_socks = ATOMIC_INIT(0);
 
 #define unix_sockets_unbound	(&unix_socket_table[UNIX_HASH_SIZE])
@@ -185,7 +194,11 @@
 	unix_state_rlock(s);
 	peer = unix_peer(s);
 	if (peer)
+#ifdef CONFIG_SSI
 		ssi_unix_sock_hold(peer);
+#else
+		sock_hold(peer);
+#endif
 	unix_state_runlock(s);
 	return peer;
 }
@@ -232,16 +245,32 @@
 
 static inline void unix_remove_socket(struct sock *sk)
 {
+#ifdef CONFIG_SSI
+	down_write(&unix_table_lock);
+#else
 	write_lock(&unix_table_lock);
+#endif
 	__unix_remove_socket(sk);
+#ifdef CONFIG_SSI
+	up_write(&unix_table_lock);
+#else
 	write_unlock(&unix_table_lock);
+#endif
 }
 
 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
 {
+#ifdef CONFIG_SSI
+	down_write(&unix_table_lock);
+#else
 	write_lock(&unix_table_lock);
+#endif
 	__unix_insert_socket(list, sk);
+#ifdef CONFIG_SSI
+	up_write(&unix_table_lock);
+#else
 	write_unlock(&unix_table_lock);
+#endif
 }
 
 static struct sock *__unix_find_socket_byname(struct sockaddr_un *sunname,
@@ -268,11 +297,19 @@
 {
 	struct sock *s;
 
+#ifdef CONFIG_SSI
+	down_read(&unix_table_lock);
+#else
 	read_lock(&unix_table_lock);
+#endif
 	s = __unix_find_socket_byname(sunname, len, type, hash);
 	if (s)
 		sock_hold(s);
+#ifdef CONFIG_SSI
+	up_read(&unix_table_lock);
+#else
 	read_unlock(&unix_table_lock);
+#endif
 	return s;
 }
 
@@ -281,7 +318,11 @@
 	struct sock *s;
 	struct hlist_node *node;
 
+#ifdef CONFIG_SSI
+	down_read(&unix_table_lock);
+#else
 	read_lock(&unix_table_lock);
+#endif
 	sk_for_each(s, node,
 		    &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
 		struct dentry *dentry = unix_sk(s)->dentry;
@@ -294,7 +335,11 @@
 	}
 	s = NULL;
 found:
+#ifdef CONFIG_SSI
+	up_read(&unix_table_lock);
+#else
 	read_unlock(&unix_table_lock);
+#endif
 	return s;
 }
 
@@ -381,22 +426,12 @@
 	unix_state_wlock(sk);
 	sock_orphan(sk);
 	sk->sk_shutdown = SHUTDOWN_MASK;
-#ifndef CONFIG_SSI
 	dentry	     = u->dentry;
 	u->dentry    = NULL;
 	mnt	     = u->mnt;
 	u->mnt	     = NULL;
 	state = sk->sk_state;
 	sk->sk_state = TCP_CLOSE;
-#else
-	dentry	     = u->dentry;
-	mnt	     = u->mnt;
-	state = sk->sk_state;
-	mb();
-	u->dentry    = NULL;
-	u->mnt	     = NULL;
-	sk->sk_state = TCP_CLOSE;
-#endif
 	unix_state_wunlock(sk);
 
 	wake_up_interruptible_all(&u->peer_wait);
@@ -421,7 +456,11 @@
 			sk_wake_async(skpair,1,POLL_HUP);
 			read_unlock(&skpair->sk_callback_lock);
 		}
+#ifdef CONFIG_SSI
 		ssi_unix_sock_put(skpair, 1); /* It may now die */
+#else
+		sock_put(skpair); /* It may now die */
+#endif
 		unix_peer(sk) = NULL;
 	}
 
@@ -659,7 +698,9 @@
 	if (!sk)
 		return 0;
 
+#ifdef CONFIG_SSI
 	ssi_unix_deregister(sock);
+#endif
 	sock->sk = NULL;
 
 	return unix_release_sock (sk, 0);
@@ -692,7 +733,11 @@
 	addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
 	addr->hash = unix_hash_fold(csum_partial((void*)addr->name, addr->len, 0));
 
+#ifdef CONFIG_SSI
+	down_write(&unix_table_lock);
+#else
 	write_lock(&unix_table_lock);
+#endif
 	ordernum = (ordernum+1)&0xFFFFF;
 
 #ifdef CONFIG_SSI
@@ -704,11 +749,12 @@
 
 	if (__unix_find_socket_byname(addr->name, addr->len, 0, addr->hash) ||
 			(ssi_unix_register_byname(sock, addr) != 0)) {
+		up_write(&unix_table_lock);
 #else
 	if (__unix_find_socket_byname(addr->name, addr->len, sock->type,
 				      addr->hash)) {
-#endif
 		write_unlock(&unix_table_lock);
+#endif
 		/* Sanity yield. It is unusual case, but yet... */
 		if (!(ordernum&0xFF))
 			yield();
@@ -721,7 +767,11 @@
 	__unix_remove_socket(sk);
 	u->addr = addr;
 	__unix_insert_socket(&unix_socket_table[addr->hash], sk);
+#ifdef CONFIG_SSI
+	up_write(&unix_table_lock);
+#else
 	write_unlock(&unix_table_lock);
+#endif
 	err = 0;
 
 out:	up(&u->readsem);
@@ -914,7 +964,11 @@
 		addr->hash = UNIX_HASH_SIZE;
 	}
 
+#ifdef CONFIG_SSI
+	down_write(&unix_table_lock);
+#else
 	write_lock(&unix_table_lock);
+#endif
 
 	if (!sunaddr->sun_path[0]) {
 		err = -EADDRINUSE;
@@ -944,7 +998,11 @@
 	__unix_insert_socket(list, sk);
 
 out_unlock:
+#ifdef CONFIG_SSI
+	up_write(&unix_table_lock);
+#else
 	write_unlock(&unix_table_lock);
+#endif
 out_up:
 	up(&u->readsem);
 out:
@@ -1049,7 +1107,11 @@
 		if (other != old_peer)
 #endif
 			unix_dgram_disconnected(sk, old_peer);
+#ifdef CONFIG_SSI
 		ssi_unix_sock_put(old_peer, 1);
+#else
+		sock_put(old_peer);
+#endif
 	} else {
 		unix_peer(sk)=other;
 		unix_state_wunlock(sk);
@@ -1272,11 +1334,10 @@
 #ifdef CONFIG_SSI
 	if (ssi_unix_remote) {
 		ssi_unix_cache_info(newsk);
-	}
-	else {
+	} else {
 #endif
-		sock_hold(sk);
-		unix_peer(newsk) = sk;
+	sock_hold(sk);
+	unix_peer(newsk)	= sk;
 #ifdef CONFIG_SSI
 	}
 #endif
@@ -1819,15 +1880,23 @@
 	kfree_skb(skb);
 pipe_err:
 	if (sent==0 && !(msg->msg_flags&MSG_NOSIGNAL))
+#ifdef CONFIG_SSI
 		ssi_unix_send_sig(SIGPIPE,current,0);
+#else
+		send_sig(SIGPIPE,current,0);
+#endif
 	err = -EPIPE;
 out_err:
         if (other)
+#ifdef CONFIG_SSI
 #ifdef IPC_STALE_RMTUNIX_CACHE_FIX
 		ssi_unix_sock_put(other, 1);
 #else
 		ssi_unix_sock_put(other, 0);
 #endif
+#else
+		sock_put(other);
+#endif
 	scm_destroy(siocb->scm);
 	siocb->scm = NULL;
 	return sent ? : err;
@@ -2128,7 +2197,11 @@
 		sk->sk_shutdown |= mode;
 		other=unix_peer(sk);
 		if (other)
+#ifdef CONFIG_SSI
 			ssi_unix_sock_hold(other);
+#else
+			sock_hold(other);
+#endif
 		unix_state_wunlock(sk);
 		sk->sk_state_change(sk);
 
@@ -2158,7 +2231,11 @@
 			read_unlock(&other->sk_callback_lock);
 		}
 		if (other)
+#ifdef CONFIG_SSI
 			ssi_unix_sock_put(other, 0);
+#else
+			sock_put(other);
+#endif
 	}
 	return 0;
 }
@@ -2257,7 +2334,11 @@
 
 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
 {
+#ifdef CONFIG_SSI
+	down_read(&unix_table_lock);
+#else
 	read_lock(&unix_table_lock);
+#endif
 	return *pos ? unix_seq_idx(seq->private, *pos - 1) : ((void *) 1);
 }
 
@@ -2272,7 +2353,11 @@
 
 static void unix_seq_stop(struct seq_file *seq, void *v)
 {
+#ifdef CONFIG_SSI
+	up_read(&unix_table_lock);
+#else
 	read_unlock(&unix_table_lock);
+#endif
 }
 
 static int unix_seq_show(struct seq_file *seq, void *v)


------------------------------------------------------------------------------
Come build with us! The BlackBerry(R) Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay 
ahead of the curve. Join us from November 9 - 12, 2009. Register now!
http://p.sf.net/sfu/devconference