PERFORCE change 86081 for review

[Robert Watson]

http://perforce.freebsd.org/chv.cgi?CH=86081

Change 86081 by rwatson at rwatson_zoo on 2005/10/30 19:56:18

	Re-inline socket buffer sleep lock assertions, since I'm not
	currently using them.

Affected files ...

.. //depot/projects/netsmp/src/sys/kern/uipc_socket.c#18 edit
.. //depot/projects/netsmp/src/sys/kern/uipc_socket2.c#7 edit
.. //depot/projects/netsmp/src/sys/sys/socketvar.h#6 edit

Differences ...

==== //depot/projects/netsmp/src/sys/kern/uipc_socket.c#18 (text+ko) ====

@@ -391,7 +391,6 @@
 	SOCKBUF_LOCK(&so->so_snd);
 	so->so_snd.sb_flags |= SB_NOINTR;
 	(void)sblock(&so->so_snd, M_WAITOK);
-	sb_lock_assert(&so->so_snd);
 	/*
 	 * socantsendmore_locked() drops the socket buffer mutex so that it
 	 * can safely perform wakeups.  Re-acquire the mutex before
@@ -924,7 +923,6 @@
 	error = sblock(&so->so_snd, SBLOCKWAIT(flags));
 	if (error)
 		goto out_locked;
-	sb_lock_assert(&so->so_snd);
 	do {
 		SOCKBUF_LOCK_ASSERT(&so->so_snd);
 		if (so->so_snd.sb_state & SBS_CANTSENDMORE)
@@ -950,7 +948,6 @@
 			    snderr(so->so_proto->pr_flags & PR_CONNREQUIRED ?
 				   ENOTCONN : EDESTADDRREQ);
 		}
-
 		space = sbspace(&so->so_snd);
 		if (flags & MSG_OOB)
 			space += 1024;
@@ -1184,7 +1181,6 @@
 	error = sblock(&so->so_rcv, SBLOCKWAIT(flags));
 	if (error)
 		goto out;
-	sb_lock_assert(&so->so_rcv);
 
 	m = so->so_rcv.sb_mb;
 	/*
@@ -1423,15 +1419,10 @@
 				error = uiomoveco(mtod(m, char *) + moff,
 						  (int)len, uio,
 						  disposable);
-				SOCKBUF_LOCK(&so->so_rcv);
 			} else
 #endif /* ZERO_COPY_SOCKETS */
-			{
-			sb_lock_assert(&so->so_rcv);
 			error = uiomove(mtod(m, char *) + moff, (int)len, uio);
 			SOCKBUF_LOCK(&so->so_rcv);
-			sb_lock_assert(&so->so_rcv);
-			}
 			if (error)
 				goto release;
 		} else
@@ -1627,7 +1618,6 @@
 	SOCKBUF_LOCK(sb);
 	sb->sb_flags |= SB_NOINTR;
 	(void) sblock(sb, M_WAITOK);
-	sb_lock_assert(sb);
 	/*
 	 * socantrcvmore_locked() drops the socket buffer mutex so that it
 	 * can safely perform wakeups.  Re-acquire the mutex before

==== //depot/projects/netsmp/src/sys/kern/uipc_socket2.c#7 (text+ko) ====

@@ -353,8 +353,6 @@
 /*
  * Lock a sockbuf already known to be locked;
  * return any error returned from sleep (EINTR).
- *
- * XXXRW: Isn't a bit silly that we repeatedly clear and re-set SB_WANT?
  */
 int
 sb_lock(sb)
@@ -372,70 +370,11 @@
 		if (error)
 			return (error);
 	}
-	KASSERT(sb->sb_lock_owner == NULL, ("sb_lock: sb_lock_owner %p",
-	    sb->sb_lock_owner));
 	sb->sb_flags |= SB_LOCK;
-	sb->sb_lock_owner = curthread;
 	return (0);
 }
 
 /*
- * Un-inlined sblock() macro.
- */
-int
-sblock(sb, wf)
-	struct sockbuf *sb;
-	int wf;
-{
-
-	SOCKBUF_LOCK_ASSERT(sb);
-
-	if (sb->sb_flags & SB_LOCK) {
-		if (wf == M_WAITOK)
-			return (sb_lock(sb));
-		else
-			return (EWOULDBLOCK);
-	}
-	sb->sb_flags |= SB_LOCK;
-	sb->sb_lock_owner = curthread;
-	return (0);
-}
-
-/*
- * Un-inlined sbunlock() macro.
- */
-void
-sbunlock(sb)
-	struct sockbuf *sb;
-{
-
-	SOCKBUF_LOCK_ASSERT(sb);
-	KASSERT(sb->sb_flags & SB_LOCK, ("sbunlock: !SB_LOCK"));
-	KASSERT(sb->sb_lock_owner == curthread, ("sbunlock: !curthread"));
-
-	sb->sb_flags &= ~SB_LOCK;
-	sb->sb_lock_owner = NULL;
-	if (sb->sb_flags & SB_WANT) {
-		sb->sb_flags &= ~SB_WANT;
-		wakeup(&sb->sb_flags);
-	}
-}
-
-
-/*
- * We can't assert that the current thread owns the socket buffer sleep lock,
- * but we can at least assert that it is held.
- */
-void
-sb_lock_assert(sb)
-	struct sockbuf *sb;
-{
-
-	KASSERT(sb->sb_flags & SB_LOCK, ("sb_lock_assert: failed"));
-	KASSERT(sb->sb_lock_owner == curthread, ("sb_lock_assert: !curthread"));
-}
-
-/*
  * Wakeup processes waiting on a socket buffer.  Do asynchronous
  * notification via SIGIO if the socket has the SS_ASYNC flag set.
  *

==== //depot/projects/netsmp/src/sys/sys/socketvar.h#6 (text+ko) ====

@@ -111,7 +111,6 @@
 		int	sb_lowat;	/* (c/d) low water mark */
 		int	sb_timeo;	/* (c/d) timeout for read/write */
 		short	sb_flags;	/* (c/d) flags, see below */
-		struct	thread *sb_lock_owner;	/* (c/d), sb_lock owner */
 	} so_rcv, so_snd;
 /*
  * Constants for sb_flags field of struct sockbuf.
@@ -318,6 +317,25 @@
 }
 
 /*
+ * Set lock on sockbuf sb; sleep if lock is already held.
+ * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
+ * Returns error without lock if sleep is interrupted.
+ */
+#define sblock(sb, wf) ((sb)->sb_flags & SB_LOCK ? \
+		(((wf) == M_WAITOK) ? sb_lock(sb) : EWOULDBLOCK) : \
+		((sb)->sb_flags |= SB_LOCK), 0)
+
+/* release lock on sockbuf sb */
+#define	sbunlock(sb) do { \
+	SOCKBUF_LOCK_ASSERT(sb); \
+	(sb)->sb_flags &= ~SB_LOCK; \
+	if ((sb)->sb_flags & SB_WANT) { \
+		(sb)->sb_flags &= ~SB_WANT; \
+		wakeup(&(sb)->sb_flags); \
+	} \
+} while (0)
+
+/*
  * soref()/sorele() ref-count the socket structure.  Note that you must
  * still explicitly close the socket, but the last ref count will free
  * the structure.
@@ -469,10 +487,7 @@
 	    struct thread *td);
 void	sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb);
 int	sbwait(struct sockbuf *sb);
-int	sblock(struct sockbuf *sb, int wf);
 int	sb_lock(struct sockbuf *sb);
-void	sb_lock_assert(struct sockbuf *sb);
-void	sbunlock(struct sockbuf *sb);
 int	soabort(struct socket *so);
 int	soaccept(struct socket *so, struct sockaddr **nam);
 struct	socket *soalloc(int mflags);