SMP Lock struct file, filedesc and the global file list.

Seigo Tanimura (tanimura) posted the initial delta.

I've polished it quite a bit reducing the need for locking and
adapting it for KSE.

Locks:

1 mutex in each filedesc
   protects all the fields.
   protects "struct file" initialization, while a struct file
     is being changed from &badfileops -> &pipeops or something
     the filedesc should be locked.

1 mutex in each struct file
   protects the refcount fields.
   doesn't protect anything else.
   the flags used for garbage collection have been moved to
     f_gcflag which was the FILLER short, this doesn't need
     locking because the garbage collection is a single threaded
     container.
  could likely be made to use a pool mutex.

1 sx lock for the global filelist.

struct file *	fhold(struct file *fp);
        /* increments reference count on a file */

struct file *	fhold_locked(struct file *fp);
        /* like fhold but expects file to locked */

struct file *	ffind_hold(struct thread *, int fd);
        /* finds the struct file in thread, adds one reference and
                returns it unlocked */

struct file *	ffind_lock(struct thread *, int fd);
        /* ffind_hold, but returns file locked */

I still have to smp-safe the fget cruft, I'll get to that asap.

1 files changed, 9 insertions, 3 deletions

diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c
index a0b8688..da46522 100644
--- a/sys/kern/kern_fork.c
+++ b/sys/kern/kern_fork.c
@@ -269,14 +269,18 @@ fork1(td, flags, procp)
 		 * Unshare file descriptors (from parent.)
 		 */
 		if (flags & RFFDG) {
+			FILEDESC_LOCK(p1->p_fd);
 			if (p1->p_fd->fd_refcnt > 1) {
 				struct filedesc *newfd;
+
 				newfd = fdcopy(td);
+				FILEDESC_UNLOCK(p1->p_fd);
 				PROC_LOCK(p1);
 				fdfree(td);
 				p1->p_fd = newfd;
 				PROC_UNLOCK(p1);
-			}
+			} else
+				FILEDESC_UNLOCK(p1->p_fd);
 		}
 		*procp = NULL;
 		return (0);
@@ -519,9 +523,11 @@ again:
 
 	if (flags & RFCFDG)
 		fd = fdinit(td);
-	else if (flags & RFFDG)
+	else if (flags & RFFDG) {
+		FILEDESC_LOCK(p1->p_fd);
 		fd = fdcopy(td);
-	else
+		FILEDESC_UNLOCK(p1->p_fd);
+	} else
 		fd = fdshare(p1);
 	PROC_LOCK(p2);
 	p2->p_fd = fd;