svn commit: r209459 - stable/8/sys/kern
Konstantin Belousov
kib at FreeBSD.org
Wed Jun 23 10:06:58 UTC 2010
Author: kib
Date: Wed Jun 23 10:06:57 2010
New Revision: 209459
URL: http://svn.freebsd.org/changeset/base/209459
Log:
MFC r208920:
Reorganize the code in bdwrite() which handles move of dirtiness from
the buffer pages to buffer. Drain the VPO_BUSY bit of the buffer pages
before setting valid and clean bits.
Stable/8 version of vfs_page_set_validclean() requires page queue lock.
Tested by: pho
Modified:
stable/8/sys/kern/vfs_bio.c
Directory Properties:
stable/8/sys/ (props changed)
stable/8/sys/amd64/include/xen/ (props changed)
stable/8/sys/cddl/contrib/opensolaris/ (props changed)
stable/8/sys/contrib/dev/acpica/ (props changed)
stable/8/sys/contrib/pf/ (props changed)
stable/8/sys/dev/ixgbe/ (props changed)
stable/8/sys/dev/xen/xenpci/ (props changed)
stable/8/sys/geom/sched/ (props changed)
Modified: stable/8/sys/kern/vfs_bio.c
==============================================================================
--- stable/8/sys/kern/vfs_bio.c Wed Jun 23 10:06:31 2010 (r209458)
+++ stable/8/sys/kern/vfs_bio.c Wed Jun 23 10:06:57 2010 (r209459)
@@ -102,8 +102,8 @@ static void vm_hold_load_pages(struct bu
static void vfs_page_set_valid(struct buf *bp, vm_ooffset_t off, vm_page_t m);
static void vfs_page_set_validclean(struct buf *bp, vm_ooffset_t off,
vm_page_t m);
-static void vfs_clean_pages(struct buf *bp);
-static void vfs_setdirty(struct buf *bp);
+static void vfs_drain_busy_pages(struct buf *bp);
+static void vfs_clean_pages_dirty_buf(struct buf *bp);
static void vfs_setdirty_locked_object(struct buf *bp);
static void vfs_vmio_release(struct buf *bp);
static int vfs_bio_clcheck(struct vnode *vp, int size,
@@ -1009,18 +1009,17 @@ bdwrite(struct buf *bp)
}
/*
- * Set the *dirty* buffer range based upon the VM system dirty pages.
- */
- vfs_setdirty(bp);
-
- /*
- * We need to do this here to satisfy the vnode_pager and the
- * pageout daemon, so that it thinks that the pages have been
- * "cleaned". Note that since the pages are in a delayed write
- * buffer -- the VFS layer "will" see that the pages get written
- * out on the next sync, or perhaps the cluster will be completed.
+ * Set the *dirty* buffer range based upon the VM system dirty
+ * pages.
+ *
+ * Mark the buffer pages as clean. We need to do this here to
+ * satisfy the vnode_pager and the pageout daemon, so that it
+ * thinks that the pages have been "cleaned". Note that since
+ * the pages are in a delayed write buffer -- the VFS layer
+ * "will" see that the pages get written out on the next sync,
+ * or perhaps the cluster will be completed.
*/
- vfs_clean_pages(bp);
+ vfs_clean_pages_dirty_buf(bp);
bqrelse(bp);
/*
@@ -2380,31 +2379,46 @@ notinmem:
}
/*
- * vfs_setdirty:
- *
- * Sets the dirty range for a buffer based on the status of the dirty
- * bits in the pages comprising the buffer.
+ * Set the dirty range for a buffer based on the status of the dirty
+ * bits in the pages comprising the buffer. The range is limited
+ * to the size of the buffer.
*
- * The range is limited to the size of the buffer.
+ * Tell the VM system that the pages associated with this buffer
+ * are clean. This is used for delayed writes where the data is
+ * going to go to disk eventually without additional VM intevention.
*
- * This routine is primarily used by NFS, but is generalized for the
- * B_VMIO case.
+ * Note that while we only really need to clean through to b_bcount, we
+ * just go ahead and clean through to b_bufsize.
*/
static void
-vfs_setdirty(struct buf *bp)
+vfs_clean_pages_dirty_buf(struct buf *bp)
{
+ vm_ooffset_t foff, noff, eoff;
+ vm_page_t m;
+ int i;
- /*
- * Degenerate case - empty buffer
- */
- if (bp->b_bufsize == 0)
+ if ((bp->b_flags & B_VMIO) == 0 || bp->b_bufsize == 0)
return;
- if ((bp->b_flags & B_VMIO) == 0)
- return;
+ foff = bp->b_offset;
+ KASSERT(bp->b_offset != NOOFFSET,
+ ("vfs_clean_pages_dirty_buf: no buffer offset"));
VM_OBJECT_LOCK(bp->b_bufobj->bo_object);
+ vfs_drain_busy_pages(bp);
vfs_setdirty_locked_object(bp);
+ vm_page_lock_queues();
+ for (i = 0; i < bp->b_npages; i++) {
+ noff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
+ eoff = noff;
+ if (eoff > bp->b_offset + bp->b_bufsize)
+ eoff = bp->b_offset + bp->b_bufsize;
+ m = bp->b_pages[i];
+ vfs_page_set_validclean(bp, foff, m);
+ /* vm_page_clear_dirty(m, foff & PAGE_MASK, eoff - foff); */
+ foff = noff;
+ }
+ vm_page_unlock_queues();
VM_OBJECT_UNLOCK(bp->b_bufobj->bo_object);
}
@@ -3508,6 +3522,31 @@ vfs_page_set_validclean(struct buf *bp,
}
/*
+ * Ensure that all buffer pages are not busied by VPO_BUSY flag. If
+ * any page is busy, drain the flag.
+ */
+static void
+vfs_drain_busy_pages(struct buf *bp)
+{
+ vm_page_t m;
+ int i, last_busied;
+
+ VM_OBJECT_LOCK_ASSERT(bp->b_bufobj->bo_object, MA_OWNED);
+ last_busied = 0;
+ for (i = 0; i < bp->b_npages; i++) {
+ m = bp->b_pages[i];
+ if ((m->oflags & VPO_BUSY) != 0) {
+ for (; last_busied < i; last_busied++)
+ vm_page_busy(bp->b_pages[last_busied]);
+ while ((m->oflags & VPO_BUSY) != 0)
+ vm_page_sleep(m, "vbpage");
+ }
+ }
+ for (i = 0; i < last_busied; i++)
+ vm_page_wakeup(bp->b_pages[i]);
+}
+
+/*
* This routine is called before a device strategy routine.
* It is used to tell the VM system that paging I/O is in
* progress, and treat the pages associated with the buffer
@@ -3535,15 +3574,9 @@ vfs_busy_pages(struct buf *bp, int clear
KASSERT(bp->b_offset != NOOFFSET,
("vfs_busy_pages: no buffer offset"));
VM_OBJECT_LOCK(obj);
+ vfs_drain_busy_pages(bp);
if (bp->b_bufsize != 0)
vfs_setdirty_locked_object(bp);
-retry:
- for (i = 0; i < bp->b_npages; i++) {
- m = bp->b_pages[i];
-
- if (vm_page_sleep_if_busy(m, FALSE, "vbpage"))
- goto retry;
- }
bogus = 0;
if (clear_modify)
vm_page_lock_queues();
@@ -3588,44 +3621,6 @@ retry:
}
/*
- * Tell the VM system that the pages associated with this buffer
- * are clean. This is used for delayed writes where the data is
- * going to go to disk eventually without additional VM intevention.
- *
- * Note that while we only really need to clean through to b_bcount, we
- * just go ahead and clean through to b_bufsize.
- */
-static void
-vfs_clean_pages(struct buf *bp)
-{
- int i;
- vm_ooffset_t foff, noff, eoff;
- vm_page_t m;
-
- if (!(bp->b_flags & B_VMIO))
- return;
-
- foff = bp->b_offset;
- KASSERT(bp->b_offset != NOOFFSET,
- ("vfs_clean_pages: no buffer offset"));
- VM_OBJECT_LOCK(bp->b_bufobj->bo_object);
- vm_page_lock_queues();
- for (i = 0; i < bp->b_npages; i++) {
- m = bp->b_pages[i];
- noff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
- eoff = noff;
-
- if (eoff > bp->b_offset + bp->b_bufsize)
- eoff = bp->b_offset + bp->b_bufsize;
- vfs_page_set_validclean(bp, foff, m);
- /* vm_page_clear_dirty(m, foff & PAGE_MASK, eoff - foff); */
- foff = noff;
- }
- vm_page_unlock_queues();
- VM_OBJECT_UNLOCK(bp->b_bufobj->bo_object);
-}
-
-/*
* vfs_bio_set_valid:
*
* Set the range within the buffer to valid. The range is
More information about the svn-src-stable
mailing list