kernel - Cleanup and document
authorMatthew Dillon <dillon@apollo.backplane.com>
Fri, 18 Nov 2011 16:08:24 +0000 (08:08 -0800)
committerMatthew Dillon <dillon@apollo.backplane.com>
Fri, 18 Nov 2011 16:08:24 +0000 (08:08 -0800)
* Cleanup and document various bits of code.

sys/kern/kern_lock.c
sys/kern/sys_process.c
sys/vm/vm_fault.c

index 4593cba..10f13ec 100644 (file)
 #endif
 
 #define LK_ALL (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE | \
-       LK_SHARE_NONZERO | LK_WAIT_NONZERO)
+               LK_SHARE_NONZERO | LK_WAIT_NONZERO)
 
 static int acquire(struct lock *lkp, int extflags, int wanted);
 
 static LOCK_INLINE void
-sharelock(struct lock *lkp, int incr) {
+sharelock(struct lock *lkp, int incr)
+{
        lkp->lk_flags |= LK_SHARE_NONZERO;
        lkp->lk_sharecount += incr;
 }
@@ -368,8 +369,8 @@ lkmatch2:
                 * lock, awaken upgrade requestor if we are the last shared
                 * lock, then request an exclusive lock.
                 */
-               if ( (lkp->lk_flags & (LK_SHARE_NONZERO|LK_WAIT_NONZERO)) ==
-                       LK_WAIT_NONZERO) {
+               if ((lkp->lk_flags & (LK_SHARE_NONZERO|LK_WAIT_NONZERO)) ==
+                   LK_WAIT_NONZERO) {
                        ++dowakeup;
                }
                /* fall into exclusive request */
@@ -528,6 +529,9 @@ lockmgr_kernproc(struct lock *lp)
  * Set the lock to be exclusively held.  The caller is holding the lock's
  * spinlock and the spinlock remains held on return.  A panic will occur
  * if the lock cannot be set to exclusive.
+ *
+ * XXX not only unused but these functions also break EXCLUPGRADE's
+ * atomicy.
  */
 void
 lockmgr_setexclusive_interlocked(struct lock *lkp)
index cb45aca..2b78add 100644 (file)
@@ -76,8 +76,8 @@ pread (struct proc *procp, unsigned int addr, unsigned int *retval) {
        pageno = trunc_page(addr);
 
        tmap = map;
-       rv = vm_map_lookup (&tmap, pageno, VM_PROT_READ, &out_entry,
-               &object, &pindex, &out_prot, &wired);
+       rv = vm_map_lookup(&tmap, pageno, VM_PROT_READ, &out_entry,
+                          &object, &pindex, &out_prot, &wired);
 
        if (rv != KERN_SUCCESS)
                return EINVAL;
@@ -154,8 +154,8 @@ pwrite (struct proc *procp, unsigned int addr, unsigned int datum) {
         */
 
        tmap = map;
-       rv = vm_map_lookup (&tmap, pageno, VM_PROT_WRITE, &out_entry,
-               &object, &pindex, &out_prot, &wired);
+       rv = vm_map_lookup(&tmap, pageno, VM_PROT_WRITE, &out_entry,
+                          &object, &pindex, &out_prot, &wired);
        if (rv != KERN_SUCCESS)
                return EINVAL;
 
index fd2f87c..1c01058 100644 (file)
@@ -338,6 +338,9 @@ RetryFault:
                 * If we don't COW now, on a user wire, the user will never
                 * be able to write to the mapping.  If we don't make this
                 * restriction, the bookkeeping would be nearly impossible.
+                *
+                * XXX We have a shared lock, this will have a MP race but
+                * I don't see how it can hurt anything.
                 */
                if ((fs.entry->protection & VM_PROT_WRITE) == 0)
                        fs.entry->max_protection &= ~VM_PROT_WRITE;